Gitiles
Code Review Sign In
gerrit.omnirom.org / android_system_update_engine / 2da4902c2a3fc53d10bbc523cc8dc9ee631f1404 / . / include / shill / dbus-proxies.h
blob: 188322ae851be8d70cfeb83392db8eb45a440228 [file] [log] [blame]
Alex Deymod5561a52015-09-03 23:17:52 -0700[diff] [blame]1// Automatic generation of D-Bus interfaces:
2// - org.chromium.flimflam.Device
3// - org.chromium.flimflam.IPConfig
4// - org.chromium.flimflam.Manager
5// - org.chromium.flimflam.Profile
6// - org.chromium.flimflam.Service
7// - org.chromium.flimflam.Task
8// - org.chromium.flimflam.ThirdPartyVpn
9#ifndef ____CHROMEOS_DBUS_BINDING___BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_SHILL_OUT_DEFAULT_GEN_INCLUDE_SHILL_DBUS_PROXIES_H
10#define ____CHROMEOS_DBUS_BINDING___BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_SHILL_OUT_DEFAULT_GEN_INCLUDE_SHILL_DBUS_PROXIES_H
11#include <memory>
12#include <string>
13#include <vector>
14
15#include <base/bind.h>
16#include <base/callback.h>
17#include <base/logging.h>
18#include <base/macros.h>
19#include <base/memory/ref_counted.h>
20#include <chromeos/any.h>
21#include <chromeos/dbus/dbus_method_invoker.h>
22#include <chromeos/dbus/dbus_property.h>
23#include <chromeos/dbus/dbus_signal_handler.h>
24#include <chromeos/errors/error.h>
25#include <chromeos/variant_dictionary.h>
26#include <dbus/bus.h>
27#include <dbus/message.h>
28#include <dbus/object_manager.h>
29#include <dbus/object_path.h>
30#include <dbus/object_proxy.h>
31
32namespace org {
33namespace chromium {
34namespace flimflam {
35
36// Abstract interface proxy for org::chromium::flimflam::Device.
37class DeviceProxyInterface {
38 public:
39 virtual ~DeviceProxyInterface() = default;
40
41 virtual bool AddWakeOnPacketConnection(
42 const std::string& in_ip_endpoint,
43 chromeos::ErrorPtr* error,
44 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
45
46 virtual void AddWakeOnPacketConnectionAsync(
47 const std::string& in_ip_endpoint,
48 const base::Callback<void()>& success_callback,
49 const base::Callback<void(chromeos::Error*)>& error_callback,
50 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
51
52 virtual bool RemoveWakeOnPacketConnection(
53 const std::string& in_ip_endpoint,
54 chromeos::ErrorPtr* error,
55 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
56
57 virtual void RemoveWakeOnPacketConnectionAsync(
58 const std::string& in_ip_endpoint,
59 const base::Callback<void()>& success_callback,
60 const base::Callback<void(chromeos::Error*)>& error_callback,
61 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
62
63 virtual bool RemoveAllWakeOnPacketConnections(
64 chromeos::ErrorPtr* error,
65 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
66
67 virtual void RemoveAllWakeOnPacketConnectionsAsync(
68 const base::Callback<void()>& success_callback,
69 const base::Callback<void(chromeos::Error*)>& error_callback,
70 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
71
72 virtual bool GetProperties(
73 chromeos::VariantDictionary* out_1,
74 chromeos::ErrorPtr* error,
75 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
76
77 virtual void GetPropertiesAsync(
78 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
79 const base::Callback<void(chromeos::Error*)>& error_callback,
80 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
81
82 virtual bool SetProperty(
83 const std::string& in_1,
84 const chromeos::Any& in_2,
85 chromeos::ErrorPtr* error,
86 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
87
88 virtual void SetPropertyAsync(
89 const std::string& in_1,
90 const chromeos::Any& in_2,
91 const base::Callback<void()>& success_callback,
92 const base::Callback<void(chromeos::Error*)>& error_callback,
93 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
94
95 virtual bool ClearProperty(
96 const std::string& in_1,
97 chromeos::ErrorPtr* error,
98 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
99
100 virtual void ClearPropertyAsync(
101 const std::string& in_1,
102 const base::Callback<void()>& success_callback,
103 const base::Callback<void(chromeos::Error*)>& error_callback,
104 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
105
106 virtual bool Enable(
107 chromeos::ErrorPtr* error,
108 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
109
110 virtual void EnableAsync(
111 const base::Callback<void()>& success_callback,
112 const base::Callback<void(chromeos::Error*)>& error_callback,
113 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
114
115 virtual bool Disable(
116 chromeos::ErrorPtr* error,
117 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
118
119 virtual void DisableAsync(
120 const base::Callback<void()>& success_callback,
121 const base::Callback<void(chromeos::Error*)>& error_callback,
122 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
123
124 virtual bool ProposeScan(
125 chromeos::ErrorPtr* error,
126 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
127
128 virtual void ProposeScanAsync(
129 const base::Callback<void()>& success_callback,
130 const base::Callback<void(chromeos::Error*)>& error_callback,
131 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
132
133 virtual bool AddIPConfig(
134 const std::string& in_1,
135 dbus::ObjectPath* out_2,
136 chromeos::ErrorPtr* error,
137 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
138
139 virtual void AddIPConfigAsync(
140 const std::string& in_1,
141 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
142 const base::Callback<void(chromeos::Error*)>& error_callback,
143 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
144
145 virtual bool Register(
146 const std::string& in_1,
147 chromeos::ErrorPtr* error,
148 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
149
150 virtual void RegisterAsync(
151 const std::string& in_1,
152 const base::Callback<void()>& success_callback,
153 const base::Callback<void(chromeos::Error*)>& error_callback,
154 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
155
156 virtual bool RequirePin(
157 const std::string& in_1,
158 bool in_2,
159 chromeos::ErrorPtr* error,
160 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
161
162 virtual void RequirePinAsync(
163 const std::string& in_1,
164 bool in_2,
165 const base::Callback<void()>& success_callback,
166 const base::Callback<void(chromeos::Error*)>& error_callback,
167 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
168
169 virtual bool EnterPin(
170 const std::string& in_1,
171 chromeos::ErrorPtr* error,
172 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
173
174 virtual void EnterPinAsync(
175 const std::string& in_1,
176 const base::Callback<void()>& success_callback,
177 const base::Callback<void(chromeos::Error*)>& error_callback,
178 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
179
180 virtual bool UnblockPin(
181 const std::string& in_1,
182 const std::string& in_2,
183 chromeos::ErrorPtr* error,
184 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
185
186 virtual void UnblockPinAsync(
187 const std::string& in_1,
188 const std::string& in_2,
189 const base::Callback<void()>& success_callback,
190 const base::Callback<void(chromeos::Error*)>& error_callback,
191 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
192
193 virtual bool ChangePin(
194 const std::string& in_1,
195 const std::string& in_2,
196 chromeos::ErrorPtr* error,
197 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
198
199 virtual void ChangePinAsync(
200 const std::string& in_1,
201 const std::string& in_2,
202 const base::Callback<void()>& success_callback,
203 const base::Callback<void(chromeos::Error*)>& error_callback,
204 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
205
206 virtual bool PerformTDLSOperation(
207 const std::string& in_1,
208 const std::string& in_2,
209 std::string* out_3,
210 chromeos::ErrorPtr* error,
211 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
212
213 virtual void PerformTDLSOperationAsync(
214 const std::string& in_1,
215 const std::string& in_2,
216 const base::Callback<void(const std::string&)>& success_callback,
217 const base::Callback<void(chromeos::Error*)>& error_callback,
218 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
219
220 virtual bool Reset(
221 chromeos::ErrorPtr* error,
222 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
223
224 virtual void ResetAsync(
225 const base::Callback<void()>& success_callback,
226 const base::Callback<void(chromeos::Error*)>& error_callback,
227 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
228
229 virtual bool ResetByteCounters(
230 chromeos::ErrorPtr* error,
231 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
232
233 virtual void ResetByteCountersAsync(
234 const base::Callback<void()>& success_callback,
235 const base::Callback<void(chromeos::Error*)>& error_callback,
236 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
237
238 virtual bool SetCarrier(
239 const std::string& in_1,
240 chromeos::ErrorPtr* error,
241 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
242
243 virtual void SetCarrierAsync(
244 const std::string& in_1,
245 const base::Callback<void()>& success_callback,
246 const base::Callback<void(chromeos::Error*)>& error_callback,
247 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
248
249 virtual bool RequestRoam(
250 const std::string& in_1,
251 chromeos::ErrorPtr* error,
252 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
253
254 virtual void RequestRoamAsync(
255 const std::string& in_1,
256 const base::Callback<void()>& success_callback,
257 const base::Callback<void(chromeos::Error*)>& error_callback,
258 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
259
260 virtual void RegisterPropertyChangedSignalHandler(
261 const base::Callback<void(const std::string&,
262 const chromeos::Any&)>& signal_callback,
263 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
264};
265
266} // namespace flimflam
267} // namespace chromium
268} // namespace org
269
270namespace org {
271namespace chromium {
272namespace flimflam {
273
274// Interface proxy for org::chromium::flimflam::Device.
275class DeviceProxy final : public DeviceProxyInterface {
276 public:
277 DeviceProxy(
278 const scoped_refptr<dbus::Bus>& bus,
279 const dbus::ObjectPath& object_path) :
280 bus_{bus},
281 object_path_{object_path},
282 dbus_object_proxy_{
283 bus_->GetObjectProxy(service_name_, object_path_)} {
284 }
285
286 ~DeviceProxy() override {
287 bus_->RemoveObjectProxy(
288 service_name_, object_path_, base::Bind(&base::DoNothing));
289 }
290
291 void RegisterPropertyChangedSignalHandler(
292 const base::Callback<void(const std::string&,
293 const chromeos::Any&)>& signal_callback,
294 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
295 chromeos::dbus_utils::ConnectToSignal(
296 dbus_object_proxy_,
297 "org.chromium.flimflam.Device",
298 "PropertyChanged",
299 signal_callback,
300 on_connected_callback);
301 }
302
303 void ReleaseObjectProxy(const base::Closure& callback) {
304 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
305 }
306
307 const dbus::ObjectPath& GetObjectPath() const {
308 return object_path_;
309 }
310
311 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
312
313 bool AddWakeOnPacketConnection(
314 const std::string& in_ip_endpoint,
315 chromeos::ErrorPtr* error,
316 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
317 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
318 timeout_ms,
319 dbus_object_proxy_,
320 "org.chromium.flimflam.Device",
321 "AddWakeOnPacketConnection",
322 error,
323 in_ip_endpoint);
324 return response && chromeos::dbus_utils::ExtractMethodCallResults(
325 response.get(), error);
326 }
327
328 void AddWakeOnPacketConnectionAsync(
329 const std::string& in_ip_endpoint,
330 const base::Callback<void()>& success_callback,
331 const base::Callback<void(chromeos::Error*)>& error_callback,
332 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
333 chromeos::dbus_utils::CallMethodWithTimeout(
334 timeout_ms,
335 dbus_object_proxy_,
336 "org.chromium.flimflam.Device",
337 "AddWakeOnPacketConnection",
338 success_callback,
339 error_callback,
340 in_ip_endpoint);
341 }
342
343 bool RemoveWakeOnPacketConnection(
344 const std::string& in_ip_endpoint,
345 chromeos::ErrorPtr* error,
346 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
347 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
348 timeout_ms,
349 dbus_object_proxy_,
350 "org.chromium.flimflam.Device",
351 "RemoveWakeOnPacketConnection",
352 error,
353 in_ip_endpoint);
354 return response && chromeos::dbus_utils::ExtractMethodCallResults(
355 response.get(), error);
356 }
357
358 void RemoveWakeOnPacketConnectionAsync(
359 const std::string& in_ip_endpoint,
360 const base::Callback<void()>& success_callback,
361 const base::Callback<void(chromeos::Error*)>& error_callback,
362 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
363 chromeos::dbus_utils::CallMethodWithTimeout(
364 timeout_ms,
365 dbus_object_proxy_,
366 "org.chromium.flimflam.Device",
367 "RemoveWakeOnPacketConnection",
368 success_callback,
369 error_callback,
370 in_ip_endpoint);
371 }
372
373 bool RemoveAllWakeOnPacketConnections(
374 chromeos::ErrorPtr* error,
375 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
376 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
377 timeout_ms,
378 dbus_object_proxy_,
379 "org.chromium.flimflam.Device",
380 "RemoveAllWakeOnPacketConnections",
381 error);
382 return response && chromeos::dbus_utils::ExtractMethodCallResults(
383 response.get(), error);
384 }
385
386 void RemoveAllWakeOnPacketConnectionsAsync(
387 const base::Callback<void()>& success_callback,
388 const base::Callback<void(chromeos::Error*)>& error_callback,
389 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
390 chromeos::dbus_utils::CallMethodWithTimeout(
391 timeout_ms,
392 dbus_object_proxy_,
393 "org.chromium.flimflam.Device",
394 "RemoveAllWakeOnPacketConnections",
395 success_callback,
396 error_callback);
397 }
398
399 bool GetProperties(
400 chromeos::VariantDictionary* out_1,
401 chromeos::ErrorPtr* error,
402 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
403 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
404 timeout_ms,
405 dbus_object_proxy_,
406 "org.chromium.flimflam.Device",
407 "GetProperties",
408 error);
409 return response && chromeos::dbus_utils::ExtractMethodCallResults(
410 response.get(), error, out_1);
411 }
412
413 void GetPropertiesAsync(
414 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
415 const base::Callback<void(chromeos::Error*)>& error_callback,
416 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
417 chromeos::dbus_utils::CallMethodWithTimeout(
418 timeout_ms,
419 dbus_object_proxy_,
420 "org.chromium.flimflam.Device",
421 "GetProperties",
422 success_callback,
423 error_callback);
424 }
425
426 bool SetProperty(
427 const std::string& in_1,
428 const chromeos::Any& in_2,
429 chromeos::ErrorPtr* error,
430 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
431 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
432 timeout_ms,
433 dbus_object_proxy_,
434 "org.chromium.flimflam.Device",
435 "SetProperty",
436 error,
437 in_1,
438 in_2);
439 return response && chromeos::dbus_utils::ExtractMethodCallResults(
440 response.get(), error);
441 }
442
443 void SetPropertyAsync(
444 const std::string& in_1,
445 const chromeos::Any& in_2,
446 const base::Callback<void()>& success_callback,
447 const base::Callback<void(chromeos::Error*)>& error_callback,
448 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
449 chromeos::dbus_utils::CallMethodWithTimeout(
450 timeout_ms,
451 dbus_object_proxy_,
452 "org.chromium.flimflam.Device",
453 "SetProperty",
454 success_callback,
455 error_callback,
456 in_1,
457 in_2);
458 }
459
460 bool ClearProperty(
461 const std::string& in_1,
462 chromeos::ErrorPtr* error,
463 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
464 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
465 timeout_ms,
466 dbus_object_proxy_,
467 "org.chromium.flimflam.Device",
468 "ClearProperty",
469 error,
470 in_1);
471 return response && chromeos::dbus_utils::ExtractMethodCallResults(
472 response.get(), error);
473 }
474
475 void ClearPropertyAsync(
476 const std::string& in_1,
477 const base::Callback<void()>& success_callback,
478 const base::Callback<void(chromeos::Error*)>& error_callback,
479 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
480 chromeos::dbus_utils::CallMethodWithTimeout(
481 timeout_ms,
482 dbus_object_proxy_,
483 "org.chromium.flimflam.Device",
484 "ClearProperty",
485 success_callback,
486 error_callback,
487 in_1);
488 }
489
490 bool Enable(
491 chromeos::ErrorPtr* error,
492 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
493 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
494 timeout_ms,
495 dbus_object_proxy_,
496 "org.chromium.flimflam.Device",
497 "Enable",
498 error);
499 return response && chromeos::dbus_utils::ExtractMethodCallResults(
500 response.get(), error);
501 }
502
503 void EnableAsync(
504 const base::Callback<void()>& success_callback,
505 const base::Callback<void(chromeos::Error*)>& error_callback,
506 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
507 chromeos::dbus_utils::CallMethodWithTimeout(
508 timeout_ms,
509 dbus_object_proxy_,
510 "org.chromium.flimflam.Device",
511 "Enable",
512 success_callback,
513 error_callback);
514 }
515
516 bool Disable(
517 chromeos::ErrorPtr* error,
518 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
519 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
520 timeout_ms,
521 dbus_object_proxy_,
522 "org.chromium.flimflam.Device",
523 "Disable",
524 error);
525 return response && chromeos::dbus_utils::ExtractMethodCallResults(
526 response.get(), error);
527 }
528
529 void DisableAsync(
530 const base::Callback<void()>& success_callback,
531 const base::Callback<void(chromeos::Error*)>& error_callback,
532 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
533 chromeos::dbus_utils::CallMethodWithTimeout(
534 timeout_ms,
535 dbus_object_proxy_,
536 "org.chromium.flimflam.Device",
537 "Disable",
538 success_callback,
539 error_callback);
540 }
541
542 bool ProposeScan(
543 chromeos::ErrorPtr* error,
544 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
545 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
546 timeout_ms,
547 dbus_object_proxy_,
548 "org.chromium.flimflam.Device",
549 "ProposeScan",
550 error);
551 return response && chromeos::dbus_utils::ExtractMethodCallResults(
552 response.get(), error);
553 }
554
555 void ProposeScanAsync(
556 const base::Callback<void()>& success_callback,
557 const base::Callback<void(chromeos::Error*)>& error_callback,
558 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
559 chromeos::dbus_utils::CallMethodWithTimeout(
560 timeout_ms,
561 dbus_object_proxy_,
562 "org.chromium.flimflam.Device",
563 "ProposeScan",
564 success_callback,
565 error_callback);
566 }
567
568 bool AddIPConfig(
569 const std::string& in_1,
570 dbus::ObjectPath* out_2,
571 chromeos::ErrorPtr* error,
572 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
573 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
574 timeout_ms,
575 dbus_object_proxy_,
576 "org.chromium.flimflam.Device",
577 "AddIPConfig",
578 error,
579 in_1);
580 return response && chromeos::dbus_utils::ExtractMethodCallResults(
581 response.get(), error, out_2);
582 }
583
584 void AddIPConfigAsync(
585 const std::string& in_1,
586 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
587 const base::Callback<void(chromeos::Error*)>& error_callback,
588 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
589 chromeos::dbus_utils::CallMethodWithTimeout(
590 timeout_ms,
591 dbus_object_proxy_,
592 "org.chromium.flimflam.Device",
593 "AddIPConfig",
594 success_callback,
595 error_callback,
596 in_1);
597 }
598
599 bool Register(
600 const std::string& in_1,
601 chromeos::ErrorPtr* error,
602 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
603 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
604 timeout_ms,
605 dbus_object_proxy_,
606 "org.chromium.flimflam.Device",
607 "Register",
608 error,
609 in_1);
610 return response && chromeos::dbus_utils::ExtractMethodCallResults(
611 response.get(), error);
612 }
613
614 void RegisterAsync(
615 const std::string& in_1,
616 const base::Callback<void()>& success_callback,
617 const base::Callback<void(chromeos::Error*)>& error_callback,
618 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
619 chromeos::dbus_utils::CallMethodWithTimeout(
620 timeout_ms,
621 dbus_object_proxy_,
622 "org.chromium.flimflam.Device",
623 "Register",
624 success_callback,
625 error_callback,
626 in_1);
627 }
628
629 bool RequirePin(
630 const std::string& in_1,
631 bool in_2,
632 chromeos::ErrorPtr* error,
633 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
634 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
635 timeout_ms,
636 dbus_object_proxy_,
637 "org.chromium.flimflam.Device",
638 "RequirePin",
639 error,
640 in_1,
641 in_2);
642 return response && chromeos::dbus_utils::ExtractMethodCallResults(
643 response.get(), error);
644 }
645
646 void RequirePinAsync(
647 const std::string& in_1,
648 bool in_2,
649 const base::Callback<void()>& success_callback,
650 const base::Callback<void(chromeos::Error*)>& error_callback,
651 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
652 chromeos::dbus_utils::CallMethodWithTimeout(
653 timeout_ms,
654 dbus_object_proxy_,
655 "org.chromium.flimflam.Device",
656 "RequirePin",
657 success_callback,
658 error_callback,
659 in_1,
660 in_2);
661 }
662
663 bool EnterPin(
664 const std::string& in_1,
665 chromeos::ErrorPtr* error,
666 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
667 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
668 timeout_ms,
669 dbus_object_proxy_,
670 "org.chromium.flimflam.Device",
671 "EnterPin",
672 error,
673 in_1);
674 return response && chromeos::dbus_utils::ExtractMethodCallResults(
675 response.get(), error);
676 }
677
678 void EnterPinAsync(
679 const std::string& in_1,
680 const base::Callback<void()>& success_callback,
681 const base::Callback<void(chromeos::Error*)>& error_callback,
682 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
683 chromeos::dbus_utils::CallMethodWithTimeout(
684 timeout_ms,
685 dbus_object_proxy_,
686 "org.chromium.flimflam.Device",
687 "EnterPin",
688 success_callback,
689 error_callback,
690 in_1);
691 }
692
693 bool UnblockPin(
694 const std::string& in_1,
695 const std::string& in_2,
696 chromeos::ErrorPtr* error,
697 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
698 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
699 timeout_ms,
700 dbus_object_proxy_,
701 "org.chromium.flimflam.Device",
702 "UnblockPin",
703 error,
704 in_1,
705 in_2);
706 return response && chromeos::dbus_utils::ExtractMethodCallResults(
707 response.get(), error);
708 }
709
710 void UnblockPinAsync(
711 const std::string& in_1,
712 const std::string& in_2,
713 const base::Callback<void()>& success_callback,
714 const base::Callback<void(chromeos::Error*)>& error_callback,
715 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
716 chromeos::dbus_utils::CallMethodWithTimeout(
717 timeout_ms,
718 dbus_object_proxy_,
719 "org.chromium.flimflam.Device",
720 "UnblockPin",
721 success_callback,
722 error_callback,
723 in_1,
724 in_2);
725 }
726
727 bool ChangePin(
728 const std::string& in_1,
729 const std::string& in_2,
730 chromeos::ErrorPtr* error,
731 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
732 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
733 timeout_ms,
734 dbus_object_proxy_,
735 "org.chromium.flimflam.Device",
736 "ChangePin",
737 error,
738 in_1,
739 in_2);
740 return response && chromeos::dbus_utils::ExtractMethodCallResults(
741 response.get(), error);
742 }
743
744 void ChangePinAsync(
745 const std::string& in_1,
746 const std::string& in_2,
747 const base::Callback<void()>& success_callback,
748 const base::Callback<void(chromeos::Error*)>& error_callback,
749 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
750 chromeos::dbus_utils::CallMethodWithTimeout(
751 timeout_ms,
752 dbus_object_proxy_,
753 "org.chromium.flimflam.Device",
754 "ChangePin",
755 success_callback,
756 error_callback,
757 in_1,
758 in_2);
759 }
760
761 bool PerformTDLSOperation(
762 const std::string& in_1,
763 const std::string& in_2,
764 std::string* out_3,
765 chromeos::ErrorPtr* error,
766 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
767 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
768 timeout_ms,
769 dbus_object_proxy_,
770 "org.chromium.flimflam.Device",
771 "PerformTDLSOperation",
772 error,
773 in_1,
774 in_2);
775 return response && chromeos::dbus_utils::ExtractMethodCallResults(
776 response.get(), error, out_3);
777 }
778
779 void PerformTDLSOperationAsync(
780 const std::string& in_1,
781 const std::string& in_2,
782 const base::Callback<void(const std::string&)>& success_callback,
783 const base::Callback<void(chromeos::Error*)>& error_callback,
784 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
785 chromeos::dbus_utils::CallMethodWithTimeout(
786 timeout_ms,
787 dbus_object_proxy_,
788 "org.chromium.flimflam.Device",
789 "PerformTDLSOperation",
790 success_callback,
791 error_callback,
792 in_1,
793 in_2);
794 }
795
796 bool Reset(
797 chromeos::ErrorPtr* error,
798 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
799 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
800 timeout_ms,
801 dbus_object_proxy_,
802 "org.chromium.flimflam.Device",
803 "Reset",
804 error);
805 return response && chromeos::dbus_utils::ExtractMethodCallResults(
806 response.get(), error);
807 }
808
809 void ResetAsync(
810 const base::Callback<void()>& success_callback,
811 const base::Callback<void(chromeos::Error*)>& error_callback,
812 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
813 chromeos::dbus_utils::CallMethodWithTimeout(
814 timeout_ms,
815 dbus_object_proxy_,
816 "org.chromium.flimflam.Device",
817 "Reset",
818 success_callback,
819 error_callback);
820 }
821
822 bool ResetByteCounters(
823 chromeos::ErrorPtr* error,
824 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
825 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
826 timeout_ms,
827 dbus_object_proxy_,
828 "org.chromium.flimflam.Device",
829 "ResetByteCounters",
830 error);
831 return response && chromeos::dbus_utils::ExtractMethodCallResults(
832 response.get(), error);
833 }
834
835 void ResetByteCountersAsync(
836 const base::Callback<void()>& success_callback,
837 const base::Callback<void(chromeos::Error*)>& error_callback,
838 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
839 chromeos::dbus_utils::CallMethodWithTimeout(
840 timeout_ms,
841 dbus_object_proxy_,
842 "org.chromium.flimflam.Device",
843 "ResetByteCounters",
844 success_callback,
845 error_callback);
846 }
847
848 bool SetCarrier(
849 const std::string& in_1,
850 chromeos::ErrorPtr* error,
851 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
852 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
853 timeout_ms,
854 dbus_object_proxy_,
855 "org.chromium.flimflam.Device",
856 "SetCarrier",
857 error,
858 in_1);
859 return response && chromeos::dbus_utils::ExtractMethodCallResults(
860 response.get(), error);
861 }
862
863 void SetCarrierAsync(
864 const std::string& in_1,
865 const base::Callback<void()>& success_callback,
866 const base::Callback<void(chromeos::Error*)>& error_callback,
867 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
868 chromeos::dbus_utils::CallMethodWithTimeout(
869 timeout_ms,
870 dbus_object_proxy_,
871 "org.chromium.flimflam.Device",
872 "SetCarrier",
873 success_callback,
874 error_callback,
875 in_1);
876 }
877
878 bool RequestRoam(
879 const std::string& in_1,
880 chromeos::ErrorPtr* error,
881 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
882 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
883 timeout_ms,
884 dbus_object_proxy_,
885 "org.chromium.flimflam.Device",
886 "RequestRoam",
887 error,
888 in_1);
889 return response && chromeos::dbus_utils::ExtractMethodCallResults(
890 response.get(), error);
891 }
892
893 void RequestRoamAsync(
894 const std::string& in_1,
895 const base::Callback<void()>& success_callback,
896 const base::Callback<void(chromeos::Error*)>& error_callback,
897 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
898 chromeos::dbus_utils::CallMethodWithTimeout(
899 timeout_ms,
900 dbus_object_proxy_,
901 "org.chromium.flimflam.Device",
902 "RequestRoam",
903 success_callback,
904 error_callback,
905 in_1);
906 }
907
908 private:
909 scoped_refptr<dbus::Bus> bus_;
910 const std::string service_name_{"org.chromium.flimflam"};
911 dbus::ObjectPath object_path_;
912 dbus::ObjectProxy* dbus_object_proxy_;
913
914 DISALLOW_COPY_AND_ASSIGN(DeviceProxy);
915};
916
917} // namespace flimflam
918} // namespace chromium
919} // namespace org
920
921namespace org {
922namespace chromium {
923namespace flimflam {
924
925// Abstract interface proxy for org::chromium::flimflam::IPConfig.
926class IPConfigProxyInterface {
927 public:
928 virtual ~IPConfigProxyInterface() = default;
929
930 virtual bool GetProperties(
931 chromeos::VariantDictionary* out_1,
932 chromeos::ErrorPtr* error,
933 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
934
935 virtual void GetPropertiesAsync(
936 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
937 const base::Callback<void(chromeos::Error*)>& error_callback,
938 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
939
940 virtual bool SetProperty(
941 const std::string& in_1,
942 const chromeos::Any& in_2,
943 chromeos::ErrorPtr* error,
944 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
945
946 virtual void SetPropertyAsync(
947 const std::string& in_1,
948 const chromeos::Any& in_2,
949 const base::Callback<void()>& success_callback,
950 const base::Callback<void(chromeos::Error*)>& error_callback,
951 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
952
953 virtual bool ClearProperty(
954 const std::string& in_1,
955 chromeos::ErrorPtr* error,
956 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
957
958 virtual void ClearPropertyAsync(
959 const std::string& in_1,
960 const base::Callback<void()>& success_callback,
961 const base::Callback<void(chromeos::Error*)>& error_callback,
962 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
963
964 virtual bool Remove(
965 chromeos::ErrorPtr* error,
966 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
967
968 virtual void RemoveAsync(
969 const base::Callback<void()>& success_callback,
970 const base::Callback<void(chromeos::Error*)>& error_callback,
971 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
972
973 virtual bool Refresh(
974 chromeos::ErrorPtr* error,
975 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
976
977 virtual void RefreshAsync(
978 const base::Callback<void()>& success_callback,
979 const base::Callback<void(chromeos::Error*)>& error_callback,
980 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
981
982 virtual void RegisterPropertyChangedSignalHandler(
983 const base::Callback<void(const std::string&,
984 const chromeos::Any&)>& signal_callback,
985 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
986};
987
988} // namespace flimflam
989} // namespace chromium
990} // namespace org
991
992namespace org {
993namespace chromium {
994namespace flimflam {
995
996// Interface proxy for org::chromium::flimflam::IPConfig.
997class IPConfigProxy final : public IPConfigProxyInterface {
998 public:
999 IPConfigProxy(
1000 const scoped_refptr<dbus::Bus>& bus,
1001 const dbus::ObjectPath& object_path) :
1002 bus_{bus},
1003 object_path_{object_path},
1004 dbus_object_proxy_{
1005 bus_->GetObjectProxy(service_name_, object_path_)} {
1006 }
1007
1008 ~IPConfigProxy() override {
1009 bus_->RemoveObjectProxy(
1010 service_name_, object_path_, base::Bind(&base::DoNothing));
1011 }
1012
1013 void RegisterPropertyChangedSignalHandler(
1014 const base::Callback<void(const std::string&,
1015 const chromeos::Any&)>& signal_callback,
1016 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
1017 chromeos::dbus_utils::ConnectToSignal(
1018 dbus_object_proxy_,
1019 "org.chromium.flimflam.IPConfig",
1020 "PropertyChanged",
1021 signal_callback,
1022 on_connected_callback);
1023 }
1024
1025 void ReleaseObjectProxy(const base::Closure& callback) {
1026 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
1027 }
1028
1029 const dbus::ObjectPath& GetObjectPath() const {
1030 return object_path_;
1031 }
1032
1033 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
1034
1035 bool GetProperties(
1036 chromeos::VariantDictionary* out_1,
1037 chromeos::ErrorPtr* error,
1038 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1039 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1040 timeout_ms,
1041 dbus_object_proxy_,
1042 "org.chromium.flimflam.IPConfig",
1043 "GetProperties",
1044 error);
1045 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1046 response.get(), error, out_1);
1047 }
1048
1049 void GetPropertiesAsync(
1050 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
1051 const base::Callback<void(chromeos::Error*)>& error_callback,
1052 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1053 chromeos::dbus_utils::CallMethodWithTimeout(
1054 timeout_ms,
1055 dbus_object_proxy_,
1056 "org.chromium.flimflam.IPConfig",
1057 "GetProperties",
1058 success_callback,
1059 error_callback);
1060 }
1061
1062 bool SetProperty(
1063 const std::string& in_1,
1064 const chromeos::Any& in_2,
1065 chromeos::ErrorPtr* error,
1066 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1067 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1068 timeout_ms,
1069 dbus_object_proxy_,
1070 "org.chromium.flimflam.IPConfig",
1071 "SetProperty",
1072 error,
1073 in_1,
1074 in_2);
1075 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1076 response.get(), error);
1077 }
1078
1079 void SetPropertyAsync(
1080 const std::string& in_1,
1081 const chromeos::Any& in_2,
1082 const base::Callback<void()>& success_callback,
1083 const base::Callback<void(chromeos::Error*)>& error_callback,
1084 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1085 chromeos::dbus_utils::CallMethodWithTimeout(
1086 timeout_ms,
1087 dbus_object_proxy_,
1088 "org.chromium.flimflam.IPConfig",
1089 "SetProperty",
1090 success_callback,
1091 error_callback,
1092 in_1,
1093 in_2);
1094 }
1095
1096 bool ClearProperty(
1097 const std::string& in_1,
1098 chromeos::ErrorPtr* error,
1099 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1100 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1101 timeout_ms,
1102 dbus_object_proxy_,
1103 "org.chromium.flimflam.IPConfig",
1104 "ClearProperty",
1105 error,
1106 in_1);
1107 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1108 response.get(), error);
1109 }
1110
1111 void ClearPropertyAsync(
1112 const std::string& in_1,
1113 const base::Callback<void()>& success_callback,
1114 const base::Callback<void(chromeos::Error*)>& error_callback,
1115 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1116 chromeos::dbus_utils::CallMethodWithTimeout(
1117 timeout_ms,
1118 dbus_object_proxy_,
1119 "org.chromium.flimflam.IPConfig",
1120 "ClearProperty",
1121 success_callback,
1122 error_callback,
1123 in_1);
1124 }
1125
1126 bool Remove(
1127 chromeos::ErrorPtr* error,
1128 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1129 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1130 timeout_ms,
1131 dbus_object_proxy_,
1132 "org.chromium.flimflam.IPConfig",
1133 "Remove",
1134 error);
1135 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1136 response.get(), error);
1137 }
1138
1139 void RemoveAsync(
1140 const base::Callback<void()>& success_callback,
1141 const base::Callback<void(chromeos::Error*)>& error_callback,
1142 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1143 chromeos::dbus_utils::CallMethodWithTimeout(
1144 timeout_ms,
1145 dbus_object_proxy_,
1146 "org.chromium.flimflam.IPConfig",
1147 "Remove",
1148 success_callback,
1149 error_callback);
1150 }
1151
1152 bool Refresh(
1153 chromeos::ErrorPtr* error,
1154 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1155 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1156 timeout_ms,
1157 dbus_object_proxy_,
1158 "org.chromium.flimflam.IPConfig",
1159 "Refresh",
1160 error);
1161 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1162 response.get(), error);
1163 }
1164
1165 void RefreshAsync(
1166 const base::Callback<void()>& success_callback,
1167 const base::Callback<void(chromeos::Error*)>& error_callback,
1168 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1169 chromeos::dbus_utils::CallMethodWithTimeout(
1170 timeout_ms,
1171 dbus_object_proxy_,
1172 "org.chromium.flimflam.IPConfig",
1173 "Refresh",
1174 success_callback,
1175 error_callback);
1176 }
1177
1178 private:
1179 scoped_refptr<dbus::Bus> bus_;
1180 const std::string service_name_{"org.chromium.flimflam"};
1181 dbus::ObjectPath object_path_;
1182 dbus::ObjectProxy* dbus_object_proxy_;
1183
1184 DISALLOW_COPY_AND_ASSIGN(IPConfigProxy);
1185};
1186
1187} // namespace flimflam
1188} // namespace chromium
1189} // namespace org
1190
1191namespace org {
1192namespace chromium {
1193namespace flimflam {
1194
1195// Abstract interface proxy for org::chromium::flimflam::Manager.
1196class ManagerProxyInterface {
1197 public:
1198 virtual ~ManagerProxyInterface() = default;
1199
1200 virtual bool GetProperties(
1201 chromeos::VariantDictionary* out_1,
1202 chromeos::ErrorPtr* error,
1203 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1204
1205 virtual void GetPropertiesAsync(
1206 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
1207 const base::Callback<void(chromeos::Error*)>& error_callback,
1208 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1209
1210 virtual bool SetProperty(
1211 const std::string& in_1,
1212 const chromeos::Any& in_2,
1213 chromeos::ErrorPtr* error,
1214 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1215
1216 virtual void SetPropertyAsync(
1217 const std::string& in_1,
1218 const chromeos::Any& in_2,
1219 const base::Callback<void()>& success_callback,
1220 const base::Callback<void(chromeos::Error*)>& error_callback,
1221 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1222
1223 virtual bool GetState(
1224 std::string* out_1,
1225 chromeos::ErrorPtr* error,
1226 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1227
1228 virtual void GetStateAsync(
1229 const base::Callback<void(const std::string&)>& success_callback,
1230 const base::Callback<void(chromeos::Error*)>& error_callback,
1231 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1232
1233 virtual bool CreateProfile(
1234 const std::string& in_1,
1235 dbus::ObjectPath* out_2,
1236 chromeos::ErrorPtr* error,
1237 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1238
1239 virtual void CreateProfileAsync(
1240 const std::string& in_1,
1241 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1242 const base::Callback<void(chromeos::Error*)>& error_callback,
1243 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1244
1245 virtual bool RemoveProfile(
1246 const std::string& in_1,
1247 chromeos::ErrorPtr* error,
1248 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1249
1250 virtual void RemoveProfileAsync(
1251 const std::string& in_1,
1252 const base::Callback<void()>& success_callback,
1253 const base::Callback<void(chromeos::Error*)>& error_callback,
1254 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1255
1256 virtual bool PushProfile(
1257 const std::string& in_1,
1258 dbus::ObjectPath* out_2,
1259 chromeos::ErrorPtr* error,
1260 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1261
1262 virtual void PushProfileAsync(
1263 const std::string& in_1,
1264 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1265 const base::Callback<void(chromeos::Error*)>& error_callback,
1266 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1267
1268 virtual bool InsertUserProfile(
1269 const std::string& in_1,
1270 const std::string& in_2,
1271 dbus::ObjectPath* out_3,
1272 chromeos::ErrorPtr* error,
1273 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1274
1275 virtual void InsertUserProfileAsync(
1276 const std::string& in_1,
1277 const std::string& in_2,
1278 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1279 const base::Callback<void(chromeos::Error*)>& error_callback,
1280 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1281
1282 virtual bool PopProfile(
1283 const std::string& in_1,
1284 chromeos::ErrorPtr* error,
1285 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1286
1287 virtual void PopProfileAsync(
1288 const std::string& in_1,
1289 const base::Callback<void()>& success_callback,
1290 const base::Callback<void(chromeos::Error*)>& error_callback,
1291 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1292
1293 virtual bool PopAnyProfile(
1294 chromeos::ErrorPtr* error,
1295 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1296
1297 virtual void PopAnyProfileAsync(
1298 const base::Callback<void()>& success_callback,
1299 const base::Callback<void(chromeos::Error*)>& error_callback,
1300 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1301
1302 virtual bool PopAllUserProfiles(
1303 chromeos::ErrorPtr* error,
1304 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1305
1306 virtual void PopAllUserProfilesAsync(
1307 const base::Callback<void()>& success_callback,
1308 const base::Callback<void(chromeos::Error*)>& error_callback,
1309 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1310
1311 virtual bool RecheckPortal(
1312 chromeos::ErrorPtr* error,
1313 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1314
1315 virtual void RecheckPortalAsync(
1316 const base::Callback<void()>& success_callback,
1317 const base::Callback<void(chromeos::Error*)>& error_callback,
1318 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1319
1320 virtual bool RequestScan(
1321 const std::string& in_1,
1322 chromeos::ErrorPtr* error,
1323 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1324
1325 virtual void RequestScanAsync(
1326 const std::string& in_1,
1327 const base::Callback<void()>& success_callback,
1328 const base::Callback<void(chromeos::Error*)>& error_callback,
1329 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1330
1331 virtual bool EnableTechnology(
1332 const std::string& in_1,
1333 chromeos::ErrorPtr* error,
1334 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1335
1336 virtual void EnableTechnologyAsync(
1337 const std::string& in_1,
1338 const base::Callback<void()>& success_callback,
1339 const base::Callback<void(chromeos::Error*)>& error_callback,
1340 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1341
1342 virtual bool DisableTechnology(
1343 const std::string& in_1,
1344 chromeos::ErrorPtr* error,
1345 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1346
1347 virtual void DisableTechnologyAsync(
1348 const std::string& in_1,
1349 const base::Callback<void()>& success_callback,
1350 const base::Callback<void(chromeos::Error*)>& error_callback,
1351 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1352
1353 virtual bool GetService(
1354 const chromeos::VariantDictionary& in_1,
1355 dbus::ObjectPath* out_2,
1356 chromeos::ErrorPtr* error,
1357 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1358
1359 virtual void GetServiceAsync(
1360 const chromeos::VariantDictionary& in_1,
1361 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1362 const base::Callback<void(chromeos::Error*)>& error_callback,
1363 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1364
1365 virtual bool GetWifiService(
1366 const chromeos::VariantDictionary& in_1,
1367 dbus::ObjectPath* out_2,
1368 chromeos::ErrorPtr* error,
1369 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1370
1371 virtual void GetWifiServiceAsync(
1372 const chromeos::VariantDictionary& in_1,
1373 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1374 const base::Callback<void(chromeos::Error*)>& error_callback,
1375 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1376
1377 virtual bool ConfigureService(
1378 const chromeos::VariantDictionary& in_1,
1379 dbus::ObjectPath* out_2,
1380 chromeos::ErrorPtr* error,
1381 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1382
1383 virtual void ConfigureServiceAsync(
1384 const chromeos::VariantDictionary& in_1,
1385 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1386 const base::Callback<void(chromeos::Error*)>& error_callback,
1387 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1388
1389 virtual bool ConfigureServiceForProfile(
1390 const dbus::ObjectPath& in_1,
1391 const chromeos::VariantDictionary& in_2,
1392 dbus::ObjectPath* out_3,
1393 chromeos::ErrorPtr* error,
1394 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1395
1396 virtual void ConfigureServiceForProfileAsync(
1397 const dbus::ObjectPath& in_1,
1398 const chromeos::VariantDictionary& in_2,
1399 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1400 const base::Callback<void(chromeos::Error*)>& error_callback,
1401 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1402
1403 virtual bool FindMatchingService(
1404 const chromeos::VariantDictionary& in_1,
1405 dbus::ObjectPath* out_2,
1406 chromeos::ErrorPtr* error,
1407 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1408
1409 virtual void FindMatchingServiceAsync(
1410 const chromeos::VariantDictionary& in_1,
1411 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1412 const base::Callback<void(chromeos::Error*)>& error_callback,
1413 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1414
1415 virtual bool GetVPNService(
1416 const chromeos::VariantDictionary& in_1,
1417 dbus::ObjectPath* out_2,
1418 chromeos::ErrorPtr* error,
1419 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1420
1421 virtual void GetVPNServiceAsync(
1422 const chromeos::VariantDictionary& in_1,
1423 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1424 const base::Callback<void(chromeos::Error*)>& error_callback,
1425 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1426
1427 virtual bool GetDebugLevel(
1428 int32_t* out_1,
1429 chromeos::ErrorPtr* error,
1430 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1431
1432 virtual void GetDebugLevelAsync(
1433 const base::Callback<void(int32_t)>& success_callback,
1434 const base::Callback<void(chromeos::Error*)>& error_callback,
1435 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1436
1437 virtual bool SetDebugLevel(
1438 int32_t in_1,
1439 chromeos::ErrorPtr* error,
1440 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1441
1442 virtual void SetDebugLevelAsync(
1443 int32_t in_1,
1444 const base::Callback<void()>& success_callback,
1445 const base::Callback<void(chromeos::Error*)>& error_callback,
1446 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1447
1448 virtual bool GetServiceOrder(
1449 std::string* out_1,
1450 chromeos::ErrorPtr* error,
1451 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1452
1453 virtual void GetServiceOrderAsync(
1454 const base::Callback<void(const std::string&)>& success_callback,
1455 const base::Callback<void(chromeos::Error*)>& error_callback,
1456 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1457
1458 virtual bool SetServiceOrder(
1459 const std::string& in_1,
1460 chromeos::ErrorPtr* error,
1461 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1462
1463 virtual void SetServiceOrderAsync(
1464 const std::string& in_1,
1465 const base::Callback<void()>& success_callback,
1466 const base::Callback<void(chromeos::Error*)>& error_callback,
1467 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1468
1469 virtual bool GetDebugTags(
1470 std::string* out_1,
1471 chromeos::ErrorPtr* error,
1472 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1473
1474 virtual void GetDebugTagsAsync(
1475 const base::Callback<void(const std::string&)>& success_callback,
1476 const base::Callback<void(chromeos::Error*)>& error_callback,
1477 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1478
1479 virtual bool SetDebugTags(
1480 const std::string& in_1,
1481 chromeos::ErrorPtr* error,
1482 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1483
1484 virtual void SetDebugTagsAsync(
1485 const std::string& in_1,
1486 const base::Callback<void()>& success_callback,
1487 const base::Callback<void(chromeos::Error*)>& error_callback,
1488 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1489
1490 virtual bool ListDebugTags(
1491 std::string* out_1,
1492 chromeos::ErrorPtr* error,
1493 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1494
1495 virtual void ListDebugTagsAsync(
1496 const base::Callback<void(const std::string&)>& success_callback,
1497 const base::Callback<void(chromeos::Error*)>& error_callback,
1498 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1499
1500 virtual bool GetNetworksForGeolocation(
1501 chromeos::VariantDictionary* out_1,
1502 chromeos::ErrorPtr* error,
1503 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1504
1505 virtual void GetNetworksForGeolocationAsync(
1506 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
1507 const base::Callback<void(chromeos::Error*)>& error_callback,
1508 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1509
1510 virtual bool VerifyDestination(
1511 const std::string& in_certificate,
1512 const std::string& in_public_key,
1513 const std::string& in_nonce,
1514 const std::string& in_signed_data,
1515 const std::string& in_destination_udn,
1516 const std::string& in_hotspot_ssid,
1517 const std::string& in_hotspot_bssid,
1518 bool* out_8,
1519 chromeos::ErrorPtr* error,
1520 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1521
1522 virtual void VerifyDestinationAsync(
1523 const std::string& in_certificate,
1524 const std::string& in_public_key,
1525 const std::string& in_nonce,
1526 const std::string& in_signed_data,
1527 const std::string& in_destination_udn,
1528 const std::string& in_hotspot_ssid,
1529 const std::string& in_hotspot_bssid,
1530 const base::Callback<void(bool)>& success_callback,
1531 const base::Callback<void(chromeos::Error*)>& error_callback,
1532 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1533
1534 virtual bool VerifyAndEncryptCredentials(
1535 const std::string& in_certificate,
1536 const std::string& in_public_key,
1537 const std::string& in_nonce,
1538 const std::string& in_signed_data,
1539 const std::string& in_destination_udn,
1540 const std::string& in_hotspot_ssid,
1541 const std::string& in_hotspot_bssid,
1542 const dbus::ObjectPath& in_network,
1543 std::string* out_9,
1544 chromeos::ErrorPtr* error,
1545 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1546
1547 virtual void VerifyAndEncryptCredentialsAsync(
1548 const std::string& in_certificate,
1549 const std::string& in_public_key,
1550 const std::string& in_nonce,
1551 const std::string& in_signed_data,
1552 const std::string& in_destination_udn,
1553 const std::string& in_hotspot_ssid,
1554 const std::string& in_hotspot_bssid,
1555 const dbus::ObjectPath& in_network,
1556 const base::Callback<void(const std::string&)>& success_callback,
1557 const base::Callback<void(chromeos::Error*)>& error_callback,
1558 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1559
1560 virtual bool VerifyAndEncryptData(
1561 const std::string& in_certificate,
1562 const std::string& in_public_key,
1563 const std::string& in_nonce,
1564 const std::string& in_signed_data,
1565 const std::string& in_destination_udn,
1566 const std::string& in_hotspot_ssid,
1567 const std::string& in_hotspot_bssid,
1568 const std::string& in_data,
1569 std::string* out_9,
1570 chromeos::ErrorPtr* error,
1571 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1572
1573 virtual void VerifyAndEncryptDataAsync(
1574 const std::string& in_certificate,
1575 const std::string& in_public_key,
1576 const std::string& in_nonce,
1577 const std::string& in_signed_data,
1578 const std::string& in_destination_udn,
1579 const std::string& in_hotspot_ssid,
1580 const std::string& in_hotspot_bssid,
1581 const std::string& in_data,
1582 const base::Callback<void(const std::string&)>& success_callback,
1583 const base::Callback<void(chromeos::Error*)>& error_callback,
1584 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1585
1586 virtual bool ConnectToBestServices(
1587 chromeos::ErrorPtr* error,
1588 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1589
1590 virtual void ConnectToBestServicesAsync(
1591 const base::Callback<void()>& success_callback,
1592 const base::Callback<void(chromeos::Error*)>& error_callback,
1593 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1594
1595 virtual bool CreateConnectivityReport(
1596 chromeos::ErrorPtr* error,
1597 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1598
1599 virtual void CreateConnectivityReportAsync(
1600 const base::Callback<void()>& success_callback,
1601 const base::Callback<void(chromeos::Error*)>& error_callback,
1602 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1603
1604 virtual bool ClaimInterface(
1605 const std::string& in_claimer_name,
1606 const std::string& in_interface_name,
1607 chromeos::ErrorPtr* error,
1608 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1609
1610 virtual void ClaimInterfaceAsync(
1611 const std::string& in_claimer_name,
1612 const std::string& in_interface_name,
1613 const base::Callback<void()>& success_callback,
1614 const base::Callback<void(chromeos::Error*)>& error_callback,
1615 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1616
1617 virtual bool ReleaseInterface(
1618 const std::string& in_claimer_name,
1619 const std::string& in_interface_name,
1620 chromeos::ErrorPtr* error,
1621 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1622
1623 virtual void ReleaseInterfaceAsync(
1624 const std::string& in_claimer_name,
1625 const std::string& in_interface_name,
1626 const base::Callback<void()>& success_callback,
1627 const base::Callback<void(chromeos::Error*)>& error_callback,
1628 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1629
1630 virtual bool SetSchedScan(
1631 bool in_1,
1632 chromeos::ErrorPtr* error,
1633 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1634
1635 virtual void SetSchedScanAsync(
1636 bool in_1,
1637 const base::Callback<void()>& success_callback,
1638 const base::Callback<void(chromeos::Error*)>& error_callback,
1639 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
1640
1641 virtual void RegisterPropertyChangedSignalHandler(
1642 const base::Callback<void(const std::string&,
1643 const chromeos::Any&)>& signal_callback,
1644 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
1645
1646 virtual void RegisterStateChangedSignalHandler(
1647 const base::Callback<void(const std::string&)>& signal_callback,
1648 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
1649};
1650
1651} // namespace flimflam
1652} // namespace chromium
1653} // namespace org
1654
1655namespace org {
1656namespace chromium {
1657namespace flimflam {
1658
1659// Interface proxy for org::chromium::flimflam::Manager.
1660class ManagerProxy final : public ManagerProxyInterface {
1661 public:
1662 ManagerProxy(const scoped_refptr<dbus::Bus>& bus) :
1663 bus_{bus},
1664 dbus_object_proxy_{
1665 bus_->GetObjectProxy(service_name_, object_path_)} {
1666 }
1667
1668 ~ManagerProxy() override {
1669 bus_->RemoveObjectProxy(
1670 service_name_, object_path_, base::Bind(&base::DoNothing));
1671 }
1672
1673 void RegisterPropertyChangedSignalHandler(
1674 const base::Callback<void(const std::string&,
1675 const chromeos::Any&)>& signal_callback,
1676 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
1677 chromeos::dbus_utils::ConnectToSignal(
1678 dbus_object_proxy_,
1679 "org.chromium.flimflam.Manager",
1680 "PropertyChanged",
1681 signal_callback,
1682 on_connected_callback);
1683 }
1684
1685 void RegisterStateChangedSignalHandler(
1686 const base::Callback<void(const std::string&)>& signal_callback,
1687 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
1688 chromeos::dbus_utils::ConnectToSignal(
1689 dbus_object_proxy_,
1690 "org.chromium.flimflam.Manager",
1691 "StateChanged",
1692 signal_callback,
1693 on_connected_callback);
1694 }
1695
1696 void ReleaseObjectProxy(const base::Closure& callback) {
1697 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
1698 }
1699
1700 const dbus::ObjectPath& GetObjectPath() const {
1701 return object_path_;
1702 }
1703
1704 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
1705
1706 bool GetProperties(
1707 chromeos::VariantDictionary* out_1,
1708 chromeos::ErrorPtr* error,
1709 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1710 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1711 timeout_ms,
1712 dbus_object_proxy_,
1713 "org.chromium.flimflam.Manager",
1714 "GetProperties",
1715 error);
1716 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1717 response.get(), error, out_1);
1718 }
1719
1720 void GetPropertiesAsync(
1721 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
1722 const base::Callback<void(chromeos::Error*)>& error_callback,
1723 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1724 chromeos::dbus_utils::CallMethodWithTimeout(
1725 timeout_ms,
1726 dbus_object_proxy_,
1727 "org.chromium.flimflam.Manager",
1728 "GetProperties",
1729 success_callback,
1730 error_callback);
1731 }
1732
1733 bool SetProperty(
1734 const std::string& in_1,
1735 const chromeos::Any& in_2,
1736 chromeos::ErrorPtr* error,
1737 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1738 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1739 timeout_ms,
1740 dbus_object_proxy_,
1741 "org.chromium.flimflam.Manager",
1742 "SetProperty",
1743 error,
1744 in_1,
1745 in_2);
1746 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1747 response.get(), error);
1748 }
1749
1750 void SetPropertyAsync(
1751 const std::string& in_1,
1752 const chromeos::Any& in_2,
1753 const base::Callback<void()>& success_callback,
1754 const base::Callback<void(chromeos::Error*)>& error_callback,
1755 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1756 chromeos::dbus_utils::CallMethodWithTimeout(
1757 timeout_ms,
1758 dbus_object_proxy_,
1759 "org.chromium.flimflam.Manager",
1760 "SetProperty",
1761 success_callback,
1762 error_callback,
1763 in_1,
1764 in_2);
1765 }
1766
1767 bool GetState(
1768 std::string* out_1,
1769 chromeos::ErrorPtr* error,
1770 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1771 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1772 timeout_ms,
1773 dbus_object_proxy_,
1774 "org.chromium.flimflam.Manager",
1775 "GetState",
1776 error);
1777 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1778 response.get(), error, out_1);
1779 }
1780
1781 void GetStateAsync(
1782 const base::Callback<void(const std::string&)>& success_callback,
1783 const base::Callback<void(chromeos::Error*)>& error_callback,
1784 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1785 chromeos::dbus_utils::CallMethodWithTimeout(
1786 timeout_ms,
1787 dbus_object_proxy_,
1788 "org.chromium.flimflam.Manager",
1789 "GetState",
1790 success_callback,
1791 error_callback);
1792 }
1793
1794 bool CreateProfile(
1795 const std::string& in_1,
1796 dbus::ObjectPath* out_2,
1797 chromeos::ErrorPtr* error,
1798 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1799 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1800 timeout_ms,
1801 dbus_object_proxy_,
1802 "org.chromium.flimflam.Manager",
1803 "CreateProfile",
1804 error,
1805 in_1);
1806 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1807 response.get(), error, out_2);
1808 }
1809
1810 void CreateProfileAsync(
1811 const std::string& in_1,
1812 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1813 const base::Callback<void(chromeos::Error*)>& error_callback,
1814 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1815 chromeos::dbus_utils::CallMethodWithTimeout(
1816 timeout_ms,
1817 dbus_object_proxy_,
1818 "org.chromium.flimflam.Manager",
1819 "CreateProfile",
1820 success_callback,
1821 error_callback,
1822 in_1);
1823 }
1824
1825 bool RemoveProfile(
1826 const std::string& in_1,
1827 chromeos::ErrorPtr* error,
1828 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1829 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1830 timeout_ms,
1831 dbus_object_proxy_,
1832 "org.chromium.flimflam.Manager",
1833 "RemoveProfile",
1834 error,
1835 in_1);
1836 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1837 response.get(), error);
1838 }
1839
1840 void RemoveProfileAsync(
1841 const std::string& in_1,
1842 const base::Callback<void()>& success_callback,
1843 const base::Callback<void(chromeos::Error*)>& error_callback,
1844 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1845 chromeos::dbus_utils::CallMethodWithTimeout(
1846 timeout_ms,
1847 dbus_object_proxy_,
1848 "org.chromium.flimflam.Manager",
1849 "RemoveProfile",
1850 success_callback,
1851 error_callback,
1852 in_1);
1853 }
1854
1855 bool PushProfile(
1856 const std::string& in_1,
1857 dbus::ObjectPath* out_2,
1858 chromeos::ErrorPtr* error,
1859 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1860 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1861 timeout_ms,
1862 dbus_object_proxy_,
1863 "org.chromium.flimflam.Manager",
1864 "PushProfile",
1865 error,
1866 in_1);
1867 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1868 response.get(), error, out_2);
1869 }
1870
1871 void PushProfileAsync(
1872 const std::string& in_1,
1873 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1874 const base::Callback<void(chromeos::Error*)>& error_callback,
1875 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1876 chromeos::dbus_utils::CallMethodWithTimeout(
1877 timeout_ms,
1878 dbus_object_proxy_,
1879 "org.chromium.flimflam.Manager",
1880 "PushProfile",
1881 success_callback,
1882 error_callback,
1883 in_1);
1884 }
1885
1886 bool InsertUserProfile(
1887 const std::string& in_1,
1888 const std::string& in_2,
1889 dbus::ObjectPath* out_3,
1890 chromeos::ErrorPtr* error,
1891 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1892 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1893 timeout_ms,
1894 dbus_object_proxy_,
1895 "org.chromium.flimflam.Manager",
1896 "InsertUserProfile",
1897 error,
1898 in_1,
1899 in_2);
1900 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1901 response.get(), error, out_3);
1902 }
1903
1904 void InsertUserProfileAsync(
1905 const std::string& in_1,
1906 const std::string& in_2,
1907 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
1908 const base::Callback<void(chromeos::Error*)>& error_callback,
1909 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1910 chromeos::dbus_utils::CallMethodWithTimeout(
1911 timeout_ms,
1912 dbus_object_proxy_,
1913 "org.chromium.flimflam.Manager",
1914 "InsertUserProfile",
1915 success_callback,
1916 error_callback,
1917 in_1,
1918 in_2);
1919 }
1920
1921 bool PopProfile(
1922 const std::string& in_1,
1923 chromeos::ErrorPtr* error,
1924 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1925 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1926 timeout_ms,
1927 dbus_object_proxy_,
1928 "org.chromium.flimflam.Manager",
1929 "PopProfile",
1930 error,
1931 in_1);
1932 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1933 response.get(), error);
1934 }
1935
1936 void PopProfileAsync(
1937 const std::string& in_1,
1938 const base::Callback<void()>& success_callback,
1939 const base::Callback<void(chromeos::Error*)>& error_callback,
1940 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1941 chromeos::dbus_utils::CallMethodWithTimeout(
1942 timeout_ms,
1943 dbus_object_proxy_,
1944 "org.chromium.flimflam.Manager",
1945 "PopProfile",
1946 success_callback,
1947 error_callback,
1948 in_1);
1949 }
1950
1951 bool PopAnyProfile(
1952 chromeos::ErrorPtr* error,
1953 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1954 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1955 timeout_ms,
1956 dbus_object_proxy_,
1957 "org.chromium.flimflam.Manager",
1958 "PopAnyProfile",
1959 error);
1960 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1961 response.get(), error);
1962 }
1963
1964 void PopAnyProfileAsync(
1965 const base::Callback<void()>& success_callback,
1966 const base::Callback<void(chromeos::Error*)>& error_callback,
1967 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1968 chromeos::dbus_utils::CallMethodWithTimeout(
1969 timeout_ms,
1970 dbus_object_proxy_,
1971 "org.chromium.flimflam.Manager",
1972 "PopAnyProfile",
1973 success_callback,
1974 error_callback);
1975 }
1976
1977 bool PopAllUserProfiles(
1978 chromeos::ErrorPtr* error,
1979 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1980 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
1981 timeout_ms,
1982 dbus_object_proxy_,
1983 "org.chromium.flimflam.Manager",
1984 "PopAllUserProfiles",
1985 error);
1986 return response && chromeos::dbus_utils::ExtractMethodCallResults(
1987 response.get(), error);
1988 }
1989
1990 void PopAllUserProfilesAsync(
1991 const base::Callback<void()>& success_callback,
1992 const base::Callback<void(chromeos::Error*)>& error_callback,
1993 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1994 chromeos::dbus_utils::CallMethodWithTimeout(
1995 timeout_ms,
1996 dbus_object_proxy_,
1997 "org.chromium.flimflam.Manager",
1998 "PopAllUserProfiles",
1999 success_callback,
2000 error_callback);
2001 }
2002
2003 bool RecheckPortal(
2004 chromeos::ErrorPtr* error,
2005 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2006 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2007 timeout_ms,
2008 dbus_object_proxy_,
2009 "org.chromium.flimflam.Manager",
2010 "RecheckPortal",
2011 error);
2012 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2013 response.get(), error);
2014 }
2015
2016 void RecheckPortalAsync(
2017 const base::Callback<void()>& success_callback,
2018 const base::Callback<void(chromeos::Error*)>& error_callback,
2019 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2020 chromeos::dbus_utils::CallMethodWithTimeout(
2021 timeout_ms,
2022 dbus_object_proxy_,
2023 "org.chromium.flimflam.Manager",
2024 "RecheckPortal",
2025 success_callback,
2026 error_callback);
2027 }
2028
2029 bool RequestScan(
2030 const std::string& in_1,
2031 chromeos::ErrorPtr* error,
2032 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2033 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2034 timeout_ms,
2035 dbus_object_proxy_,
2036 "org.chromium.flimflam.Manager",
2037 "RequestScan",
2038 error,
2039 in_1);
2040 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2041 response.get(), error);
2042 }
2043
2044 void RequestScanAsync(
2045 const std::string& in_1,
2046 const base::Callback<void()>& success_callback,
2047 const base::Callback<void(chromeos::Error*)>& error_callback,
2048 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2049 chromeos::dbus_utils::CallMethodWithTimeout(
2050 timeout_ms,
2051 dbus_object_proxy_,
2052 "org.chromium.flimflam.Manager",
2053 "RequestScan",
2054 success_callback,
2055 error_callback,
2056 in_1);
2057 }
2058
2059 bool EnableTechnology(
2060 const std::string& in_1,
2061 chromeos::ErrorPtr* error,
2062 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2063 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2064 timeout_ms,
2065 dbus_object_proxy_,
2066 "org.chromium.flimflam.Manager",
2067 "EnableTechnology",
2068 error,
2069 in_1);
2070 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2071 response.get(), error);
2072 }
2073
2074 void EnableTechnologyAsync(
2075 const std::string& in_1,
2076 const base::Callback<void()>& success_callback,
2077 const base::Callback<void(chromeos::Error*)>& error_callback,
2078 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2079 chromeos::dbus_utils::CallMethodWithTimeout(
2080 timeout_ms,
2081 dbus_object_proxy_,
2082 "org.chromium.flimflam.Manager",
2083 "EnableTechnology",
2084 success_callback,
2085 error_callback,
2086 in_1);
2087 }
2088
2089 bool DisableTechnology(
2090 const std::string& in_1,
2091 chromeos::ErrorPtr* error,
2092 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2093 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2094 timeout_ms,
2095 dbus_object_proxy_,
2096 "org.chromium.flimflam.Manager",
2097 "DisableTechnology",
2098 error,
2099 in_1);
2100 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2101 response.get(), error);
2102 }
2103
2104 void DisableTechnologyAsync(
2105 const std::string& in_1,
2106 const base::Callback<void()>& success_callback,
2107 const base::Callback<void(chromeos::Error*)>& error_callback,
2108 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2109 chromeos::dbus_utils::CallMethodWithTimeout(
2110 timeout_ms,
2111 dbus_object_proxy_,
2112 "org.chromium.flimflam.Manager",
2113 "DisableTechnology",
2114 success_callback,
2115 error_callback,
2116 in_1);
2117 }
2118
2119 bool GetService(
2120 const chromeos::VariantDictionary& in_1,
2121 dbus::ObjectPath* out_2,
2122 chromeos::ErrorPtr* error,
2123 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2124 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2125 timeout_ms,
2126 dbus_object_proxy_,
2127 "org.chromium.flimflam.Manager",
2128 "GetService",
2129 error,
2130 in_1);
2131 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2132 response.get(), error, out_2);
2133 }
2134
2135 void GetServiceAsync(
2136 const chromeos::VariantDictionary& in_1,
2137 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
2138 const base::Callback<void(chromeos::Error*)>& error_callback,
2139 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2140 chromeos::dbus_utils::CallMethodWithTimeout(
2141 timeout_ms,
2142 dbus_object_proxy_,
2143 "org.chromium.flimflam.Manager",
2144 "GetService",
2145 success_callback,
2146 error_callback,
2147 in_1);
2148 }
2149
2150 bool GetWifiService(
2151 const chromeos::VariantDictionary& in_1,
2152 dbus::ObjectPath* out_2,
2153 chromeos::ErrorPtr* error,
2154 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2155 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2156 timeout_ms,
2157 dbus_object_proxy_,
2158 "org.chromium.flimflam.Manager",
2159 "GetWifiService",
2160 error,
2161 in_1);
2162 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2163 response.get(), error, out_2);
2164 }
2165
2166 void GetWifiServiceAsync(
2167 const chromeos::VariantDictionary& in_1,
2168 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
2169 const base::Callback<void(chromeos::Error*)>& error_callback,
2170 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2171 chromeos::dbus_utils::CallMethodWithTimeout(
2172 timeout_ms,
2173 dbus_object_proxy_,
2174 "org.chromium.flimflam.Manager",
2175 "GetWifiService",
2176 success_callback,
2177 error_callback,
2178 in_1);
2179 }
2180
2181 bool ConfigureService(
2182 const chromeos::VariantDictionary& in_1,
2183 dbus::ObjectPath* out_2,
2184 chromeos::ErrorPtr* error,
2185 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2186 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2187 timeout_ms,
2188 dbus_object_proxy_,
2189 "org.chromium.flimflam.Manager",
2190 "ConfigureService",
2191 error,
2192 in_1);
2193 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2194 response.get(), error, out_2);
2195 }
2196
2197 void ConfigureServiceAsync(
2198 const chromeos::VariantDictionary& in_1,
2199 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
2200 const base::Callback<void(chromeos::Error*)>& error_callback,
2201 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2202 chromeos::dbus_utils::CallMethodWithTimeout(
2203 timeout_ms,
2204 dbus_object_proxy_,
2205 "org.chromium.flimflam.Manager",
2206 "ConfigureService",
2207 success_callback,
2208 error_callback,
2209 in_1);
2210 }
2211
2212 bool ConfigureServiceForProfile(
2213 const dbus::ObjectPath& in_1,
2214 const chromeos::VariantDictionary& in_2,
2215 dbus::ObjectPath* out_3,
2216 chromeos::ErrorPtr* error,
2217 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2218 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2219 timeout_ms,
2220 dbus_object_proxy_,
2221 "org.chromium.flimflam.Manager",
2222 "ConfigureServiceForProfile",
2223 error,
2224 in_1,
2225 in_2);
2226 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2227 response.get(), error, out_3);
2228 }
2229
2230 void ConfigureServiceForProfileAsync(
2231 const dbus::ObjectPath& in_1,
2232 const chromeos::VariantDictionary& in_2,
2233 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
2234 const base::Callback<void(chromeos::Error*)>& error_callback,
2235 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2236 chromeos::dbus_utils::CallMethodWithTimeout(
2237 timeout_ms,
2238 dbus_object_proxy_,
2239 "org.chromium.flimflam.Manager",
2240 "ConfigureServiceForProfile",
2241 success_callback,
2242 error_callback,
2243 in_1,
2244 in_2);
2245 }
2246
2247 bool FindMatchingService(
2248 const chromeos::VariantDictionary& in_1,
2249 dbus::ObjectPath* out_2,
2250 chromeos::ErrorPtr* error,
2251 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2252 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2253 timeout_ms,
2254 dbus_object_proxy_,
2255 "org.chromium.flimflam.Manager",
2256 "FindMatchingService",
2257 error,
2258 in_1);
2259 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2260 response.get(), error, out_2);
2261 }
2262
2263 void FindMatchingServiceAsync(
2264 const chromeos::VariantDictionary& in_1,
2265 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
2266 const base::Callback<void(chromeos::Error*)>& error_callback,
2267 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2268 chromeos::dbus_utils::CallMethodWithTimeout(
2269 timeout_ms,
2270 dbus_object_proxy_,
2271 "org.chromium.flimflam.Manager",
2272 "FindMatchingService",
2273 success_callback,
2274 error_callback,
2275 in_1);
2276 }
2277
2278 bool GetVPNService(
2279 const chromeos::VariantDictionary& in_1,
2280 dbus::ObjectPath* out_2,
2281 chromeos::ErrorPtr* error,
2282 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2283 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2284 timeout_ms,
2285 dbus_object_proxy_,
2286 "org.chromium.flimflam.Manager",
2287 "GetVPNService",
2288 error,
2289 in_1);
2290 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2291 response.get(), error, out_2);
2292 }
2293
2294 void GetVPNServiceAsync(
2295 const chromeos::VariantDictionary& in_1,
2296 const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
2297 const base::Callback<void(chromeos::Error*)>& error_callback,
2298 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2299 chromeos::dbus_utils::CallMethodWithTimeout(
2300 timeout_ms,
2301 dbus_object_proxy_,
2302 "org.chromium.flimflam.Manager",
2303 "GetVPNService",
2304 success_callback,
2305 error_callback,
2306 in_1);
2307 }
2308
2309 bool GetDebugLevel(
2310 int32_t* out_1,
2311 chromeos::ErrorPtr* error,
2312 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2313 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2314 timeout_ms,
2315 dbus_object_proxy_,
2316 "org.chromium.flimflam.Manager",
2317 "GetDebugLevel",
2318 error);
2319 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2320 response.get(), error, out_1);
2321 }
2322
2323 void GetDebugLevelAsync(
2324 const base::Callback<void(int32_t)>& success_callback,
2325 const base::Callback<void(chromeos::Error*)>& error_callback,
2326 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2327 chromeos::dbus_utils::CallMethodWithTimeout(
2328 timeout_ms,
2329 dbus_object_proxy_,
2330 "org.chromium.flimflam.Manager",
2331 "GetDebugLevel",
2332 success_callback,
2333 error_callback);
2334 }
2335
2336 bool SetDebugLevel(
2337 int32_t in_1,
2338 chromeos::ErrorPtr* error,
2339 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2340 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2341 timeout_ms,
2342 dbus_object_proxy_,
2343 "org.chromium.flimflam.Manager",
2344 "SetDebugLevel",
2345 error,
2346 in_1);
2347 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2348 response.get(), error);
2349 }
2350
2351 void SetDebugLevelAsync(
2352 int32_t in_1,
2353 const base::Callback<void()>& success_callback,
2354 const base::Callback<void(chromeos::Error*)>& error_callback,
2355 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2356 chromeos::dbus_utils::CallMethodWithTimeout(
2357 timeout_ms,
2358 dbus_object_proxy_,
2359 "org.chromium.flimflam.Manager",
2360 "SetDebugLevel",
2361 success_callback,
2362 error_callback,
2363 in_1);
2364 }
2365
2366 bool GetServiceOrder(
2367 std::string* out_1,
2368 chromeos::ErrorPtr* error,
2369 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2370 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2371 timeout_ms,
2372 dbus_object_proxy_,
2373 "org.chromium.flimflam.Manager",
2374 "GetServiceOrder",
2375 error);
2376 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2377 response.get(), error, out_1);
2378 }
2379
2380 void GetServiceOrderAsync(
2381 const base::Callback<void(const std::string&)>& success_callback,
2382 const base::Callback<void(chromeos::Error*)>& error_callback,
2383 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2384 chromeos::dbus_utils::CallMethodWithTimeout(
2385 timeout_ms,
2386 dbus_object_proxy_,
2387 "org.chromium.flimflam.Manager",
2388 "GetServiceOrder",
2389 success_callback,
2390 error_callback);
2391 }
2392
2393 bool SetServiceOrder(
2394 const std::string& in_1,
2395 chromeos::ErrorPtr* error,
2396 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2397 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2398 timeout_ms,
2399 dbus_object_proxy_,
2400 "org.chromium.flimflam.Manager",
2401 "SetServiceOrder",
2402 error,
2403 in_1);
2404 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2405 response.get(), error);
2406 }
2407
2408 void SetServiceOrderAsync(
2409 const std::string& in_1,
2410 const base::Callback<void()>& success_callback,
2411 const base::Callback<void(chromeos::Error*)>& error_callback,
2412 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2413 chromeos::dbus_utils::CallMethodWithTimeout(
2414 timeout_ms,
2415 dbus_object_proxy_,
2416 "org.chromium.flimflam.Manager",
2417 "SetServiceOrder",
2418 success_callback,
2419 error_callback,
2420 in_1);
2421 }
2422
2423 bool GetDebugTags(
2424 std::string* out_1,
2425 chromeos::ErrorPtr* error,
2426 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2427 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2428 timeout_ms,
2429 dbus_object_proxy_,
2430 "org.chromium.flimflam.Manager",
2431 "GetDebugTags",
2432 error);
2433 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2434 response.get(), error, out_1);
2435 }
2436
2437 void GetDebugTagsAsync(
2438 const base::Callback<void(const std::string&)>& success_callback,
2439 const base::Callback<void(chromeos::Error*)>& error_callback,
2440 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2441 chromeos::dbus_utils::CallMethodWithTimeout(
2442 timeout_ms,
2443 dbus_object_proxy_,
2444 "org.chromium.flimflam.Manager",
2445 "GetDebugTags",
2446 success_callback,
2447 error_callback);
2448 }
2449
2450 bool SetDebugTags(
2451 const std::string& in_1,
2452 chromeos::ErrorPtr* error,
2453 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2454 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2455 timeout_ms,
2456 dbus_object_proxy_,
2457 "org.chromium.flimflam.Manager",
2458 "SetDebugTags",
2459 error,
2460 in_1);
2461 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2462 response.get(), error);
2463 }
2464
2465 void SetDebugTagsAsync(
2466 const std::string& in_1,
2467 const base::Callback<void()>& success_callback,
2468 const base::Callback<void(chromeos::Error*)>& error_callback,
2469 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2470 chromeos::dbus_utils::CallMethodWithTimeout(
2471 timeout_ms,
2472 dbus_object_proxy_,
2473 "org.chromium.flimflam.Manager",
2474 "SetDebugTags",
2475 success_callback,
2476 error_callback,
2477 in_1);
2478 }
2479
2480 bool ListDebugTags(
2481 std::string* out_1,
2482 chromeos::ErrorPtr* error,
2483 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2484 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2485 timeout_ms,
2486 dbus_object_proxy_,
2487 "org.chromium.flimflam.Manager",
2488 "ListDebugTags",
2489 error);
2490 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2491 response.get(), error, out_1);
2492 }
2493
2494 void ListDebugTagsAsync(
2495 const base::Callback<void(const std::string&)>& success_callback,
2496 const base::Callback<void(chromeos::Error*)>& error_callback,
2497 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2498 chromeos::dbus_utils::CallMethodWithTimeout(
2499 timeout_ms,
2500 dbus_object_proxy_,
2501 "org.chromium.flimflam.Manager",
2502 "ListDebugTags",
2503 success_callback,
2504 error_callback);
2505 }
2506
2507 bool GetNetworksForGeolocation(
2508 chromeos::VariantDictionary* out_1,
2509 chromeos::ErrorPtr* error,
2510 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2511 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2512 timeout_ms,
2513 dbus_object_proxy_,
2514 "org.chromium.flimflam.Manager",
2515 "GetNetworksForGeolocation",
2516 error);
2517 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2518 response.get(), error, out_1);
2519 }
2520
2521 void GetNetworksForGeolocationAsync(
2522 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
2523 const base::Callback<void(chromeos::Error*)>& error_callback,
2524 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2525 chromeos::dbus_utils::CallMethodWithTimeout(
2526 timeout_ms,
2527 dbus_object_proxy_,
2528 "org.chromium.flimflam.Manager",
2529 "GetNetworksForGeolocation",
2530 success_callback,
2531 error_callback);
2532 }
2533
2534 bool VerifyDestination(
2535 const std::string& in_certificate,
2536 const std::string& in_public_key,
2537 const std::string& in_nonce,
2538 const std::string& in_signed_data,
2539 const std::string& in_destination_udn,
2540 const std::string& in_hotspot_ssid,
2541 const std::string& in_hotspot_bssid,
2542 bool* out_8,
2543 chromeos::ErrorPtr* error,
2544 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2545 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2546 timeout_ms,
2547 dbus_object_proxy_,
2548 "org.chromium.flimflam.Manager",
2549 "VerifyDestination",
2550 error,
2551 in_certificate,
2552 in_public_key,
2553 in_nonce,
2554 in_signed_data,
2555 in_destination_udn,
2556 in_hotspot_ssid,
2557 in_hotspot_bssid);
2558 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2559 response.get(), error, out_8);
2560 }
2561
2562 void VerifyDestinationAsync(
2563 const std::string& in_certificate,
2564 const std::string& in_public_key,
2565 const std::string& in_nonce,
2566 const std::string& in_signed_data,
2567 const std::string& in_destination_udn,
2568 const std::string& in_hotspot_ssid,
2569 const std::string& in_hotspot_bssid,
2570 const base::Callback<void(bool)>& success_callback,
2571 const base::Callback<void(chromeos::Error*)>& error_callback,
2572 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2573 chromeos::dbus_utils::CallMethodWithTimeout(
2574 timeout_ms,
2575 dbus_object_proxy_,
2576 "org.chromium.flimflam.Manager",
2577 "VerifyDestination",
2578 success_callback,
2579 error_callback,
2580 in_certificate,
2581 in_public_key,
2582 in_nonce,
2583 in_signed_data,
2584 in_destination_udn,
2585 in_hotspot_ssid,
2586 in_hotspot_bssid);
2587 }
2588
2589 bool VerifyAndEncryptCredentials(
2590 const std::string& in_certificate,
2591 const std::string& in_public_key,
2592 const std::string& in_nonce,
2593 const std::string& in_signed_data,
2594 const std::string& in_destination_udn,
2595 const std::string& in_hotspot_ssid,
2596 const std::string& in_hotspot_bssid,
2597 const dbus::ObjectPath& in_network,
2598 std::string* out_9,
2599 chromeos::ErrorPtr* error,
2600 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2601 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2602 timeout_ms,
2603 dbus_object_proxy_,
2604 "org.chromium.flimflam.Manager",
2605 "VerifyAndEncryptCredentials",
2606 error,
2607 in_certificate,
2608 in_public_key,
2609 in_nonce,
2610 in_signed_data,
2611 in_destination_udn,
2612 in_hotspot_ssid,
2613 in_hotspot_bssid,
2614 in_network);
2615 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2616 response.get(), error, out_9);
2617 }
2618
2619 void VerifyAndEncryptCredentialsAsync(
2620 const std::string& in_certificate,
2621 const std::string& in_public_key,
2622 const std::string& in_nonce,
2623 const std::string& in_signed_data,
2624 const std::string& in_destination_udn,
2625 const std::string& in_hotspot_ssid,
2626 const std::string& in_hotspot_bssid,
2627 const dbus::ObjectPath& in_network,
2628 const base::Callback<void(const std::string&)>& success_callback,
2629 const base::Callback<void(chromeos::Error*)>& error_callback,
2630 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2631 chromeos::dbus_utils::CallMethodWithTimeout(
2632 timeout_ms,
2633 dbus_object_proxy_,
2634 "org.chromium.flimflam.Manager",
2635 "VerifyAndEncryptCredentials",
2636 success_callback,
2637 error_callback,
2638 in_certificate,
2639 in_public_key,
2640 in_nonce,
2641 in_signed_data,
2642 in_destination_udn,
2643 in_hotspot_ssid,
2644 in_hotspot_bssid,
2645 in_network);
2646 }
2647
2648 bool VerifyAndEncryptData(
2649 const std::string& in_certificate,
2650 const std::string& in_public_key,
2651 const std::string& in_nonce,
2652 const std::string& in_signed_data,
2653 const std::string& in_destination_udn,
2654 const std::string& in_hotspot_ssid,
2655 const std::string& in_hotspot_bssid,
2656 const std::string& in_data,
2657 std::string* out_9,
2658 chromeos::ErrorPtr* error,
2659 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2660 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2661 timeout_ms,
2662 dbus_object_proxy_,
2663 "org.chromium.flimflam.Manager",
2664 "VerifyAndEncryptData",
2665 error,
2666 in_certificate,
2667 in_public_key,
2668 in_nonce,
2669 in_signed_data,
2670 in_destination_udn,
2671 in_hotspot_ssid,
2672 in_hotspot_bssid,
2673 in_data);
2674 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2675 response.get(), error, out_9);
2676 }
2677
2678 void VerifyAndEncryptDataAsync(
2679 const std::string& in_certificate,
2680 const std::string& in_public_key,
2681 const std::string& in_nonce,
2682 const std::string& in_signed_data,
2683 const std::string& in_destination_udn,
2684 const std::string& in_hotspot_ssid,
2685 const std::string& in_hotspot_bssid,
2686 const std::string& in_data,
2687 const base::Callback<void(const std::string&)>& success_callback,
2688 const base::Callback<void(chromeos::Error*)>& error_callback,
2689 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2690 chromeos::dbus_utils::CallMethodWithTimeout(
2691 timeout_ms,
2692 dbus_object_proxy_,
2693 "org.chromium.flimflam.Manager",
2694 "VerifyAndEncryptData",
2695 success_callback,
2696 error_callback,
2697 in_certificate,
2698 in_public_key,
2699 in_nonce,
2700 in_signed_data,
2701 in_destination_udn,
2702 in_hotspot_ssid,
2703 in_hotspot_bssid,
2704 in_data);
2705 }
2706
2707 bool ConnectToBestServices(
2708 chromeos::ErrorPtr* error,
2709 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2710 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2711 timeout_ms,
2712 dbus_object_proxy_,
2713 "org.chromium.flimflam.Manager",
2714 "ConnectToBestServices",
2715 error);
2716 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2717 response.get(), error);
2718 }
2719
2720 void ConnectToBestServicesAsync(
2721 const base::Callback<void()>& success_callback,
2722 const base::Callback<void(chromeos::Error*)>& error_callback,
2723 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2724 chromeos::dbus_utils::CallMethodWithTimeout(
2725 timeout_ms,
2726 dbus_object_proxy_,
2727 "org.chromium.flimflam.Manager",
2728 "ConnectToBestServices",
2729 success_callback,
2730 error_callback);
2731 }
2732
2733 bool CreateConnectivityReport(
2734 chromeos::ErrorPtr* error,
2735 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2736 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2737 timeout_ms,
2738 dbus_object_proxy_,
2739 "org.chromium.flimflam.Manager",
2740 "CreateConnectivityReport",
2741 error);
2742 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2743 response.get(), error);
2744 }
2745
2746 void CreateConnectivityReportAsync(
2747 const base::Callback<void()>& success_callback,
2748 const base::Callback<void(chromeos::Error*)>& error_callback,
2749 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2750 chromeos::dbus_utils::CallMethodWithTimeout(
2751 timeout_ms,
2752 dbus_object_proxy_,
2753 "org.chromium.flimflam.Manager",
2754 "CreateConnectivityReport",
2755 success_callback,
2756 error_callback);
2757 }
2758
2759 bool ClaimInterface(
2760 const std::string& in_claimer_name,
2761 const std::string& in_interface_name,
2762 chromeos::ErrorPtr* error,
2763 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2764 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2765 timeout_ms,
2766 dbus_object_proxy_,
2767 "org.chromium.flimflam.Manager",
2768 "ClaimInterface",
2769 error,
2770 in_claimer_name,
2771 in_interface_name);
2772 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2773 response.get(), error);
2774 }
2775
2776 void ClaimInterfaceAsync(
2777 const std::string& in_claimer_name,
2778 const std::string& in_interface_name,
2779 const base::Callback<void()>& success_callback,
2780 const base::Callback<void(chromeos::Error*)>& error_callback,
2781 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2782 chromeos::dbus_utils::CallMethodWithTimeout(
2783 timeout_ms,
2784 dbus_object_proxy_,
2785 "org.chromium.flimflam.Manager",
2786 "ClaimInterface",
2787 success_callback,
2788 error_callback,
2789 in_claimer_name,
2790 in_interface_name);
2791 }
2792
2793 bool ReleaseInterface(
2794 const std::string& in_claimer_name,
2795 const std::string& in_interface_name,
2796 chromeos::ErrorPtr* error,
2797 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2798 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2799 timeout_ms,
2800 dbus_object_proxy_,
2801 "org.chromium.flimflam.Manager",
2802 "ReleaseInterface",
2803 error,
2804 in_claimer_name,
2805 in_interface_name);
2806 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2807 response.get(), error);
2808 }
2809
2810 void ReleaseInterfaceAsync(
2811 const std::string& in_claimer_name,
2812 const std::string& in_interface_name,
2813 const base::Callback<void()>& success_callback,
2814 const base::Callback<void(chromeos::Error*)>& error_callback,
2815 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2816 chromeos::dbus_utils::CallMethodWithTimeout(
2817 timeout_ms,
2818 dbus_object_proxy_,
2819 "org.chromium.flimflam.Manager",
2820 "ReleaseInterface",
2821 success_callback,
2822 error_callback,
2823 in_claimer_name,
2824 in_interface_name);
2825 }
2826
2827 bool SetSchedScan(
2828 bool in_1,
2829 chromeos::ErrorPtr* error,
2830 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2831 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2832 timeout_ms,
2833 dbus_object_proxy_,
2834 "org.chromium.flimflam.Manager",
2835 "SetSchedScan",
2836 error,
2837 in_1);
2838 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2839 response.get(), error);
2840 }
2841
2842 void SetSchedScanAsync(
2843 bool in_1,
2844 const base::Callback<void()>& success_callback,
2845 const base::Callback<void(chromeos::Error*)>& error_callback,
2846 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2847 chromeos::dbus_utils::CallMethodWithTimeout(
2848 timeout_ms,
2849 dbus_object_proxy_,
2850 "org.chromium.flimflam.Manager",
2851 "SetSchedScan",
2852 success_callback,
2853 error_callback,
2854 in_1);
2855 }
2856
2857 private:
2858 scoped_refptr<dbus::Bus> bus_;
2859 const std::string service_name_{"org.chromium.flimflam"};
2860 const dbus::ObjectPath object_path_{"/"};
2861 dbus::ObjectProxy* dbus_object_proxy_;
2862
2863 DISALLOW_COPY_AND_ASSIGN(ManagerProxy);
2864};
2865
2866} // namespace flimflam
2867} // namespace chromium
2868} // namespace org
2869
2870namespace org {
2871namespace chromium {
2872namespace flimflam {
2873
2874// Abstract interface proxy for org::chromium::flimflam::Profile.
2875class ProfileProxyInterface {
2876 public:
2877 virtual ~ProfileProxyInterface() = default;
2878
2879 virtual bool GetProperties(
2880 chromeos::VariantDictionary* out_1,
2881 chromeos::ErrorPtr* error,
2882 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
2883
2884 virtual void GetPropertiesAsync(
2885 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
2886 const base::Callback<void(chromeos::Error*)>& error_callback,
2887 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
2888
2889 virtual bool SetProperty(
2890 const std::string& in_1,
2891 const chromeos::Any& in_2,
2892 chromeos::ErrorPtr* error,
2893 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
2894
2895 virtual void SetPropertyAsync(
2896 const std::string& in_1,
2897 const chromeos::Any& in_2,
2898 const base::Callback<void()>& success_callback,
2899 const base::Callback<void(chromeos::Error*)>& error_callback,
2900 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
2901
2902 virtual bool GetEntry(
2903 const std::string& in_1,
2904 chromeos::VariantDictionary* out_2,
2905 chromeos::ErrorPtr* error,
2906 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
2907
2908 virtual void GetEntryAsync(
2909 const std::string& in_1,
2910 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
2911 const base::Callback<void(chromeos::Error*)>& error_callback,
2912 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
2913
2914 virtual bool DeleteEntry(
2915 const std::string& in_1,
2916 chromeos::ErrorPtr* error,
2917 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
2918
2919 virtual void DeleteEntryAsync(
2920 const std::string& in_1,
2921 const base::Callback<void()>& success_callback,
2922 const base::Callback<void(chromeos::Error*)>& error_callback,
2923 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
2924
2925 virtual void RegisterPropertyChangedSignalHandler(
2926 const base::Callback<void(const std::string&,
2927 const chromeos::Any&)>& signal_callback,
2928 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
2929};
2930
2931} // namespace flimflam
2932} // namespace chromium
2933} // namespace org
2934
2935namespace org {
2936namespace chromium {
2937namespace flimflam {
2938
2939// Interface proxy for org::chromium::flimflam::Profile.
2940class ProfileProxy final : public ProfileProxyInterface {
2941 public:
2942 ProfileProxy(
2943 const scoped_refptr<dbus::Bus>& bus,
2944 const dbus::ObjectPath& object_path) :
2945 bus_{bus},
2946 object_path_{object_path},
2947 dbus_object_proxy_{
2948 bus_->GetObjectProxy(service_name_, object_path_)} {
2949 }
2950
2951 ~ProfileProxy() override {
2952 bus_->RemoveObjectProxy(
2953 service_name_, object_path_, base::Bind(&base::DoNothing));
2954 }
2955
2956 void RegisterPropertyChangedSignalHandler(
2957 const base::Callback<void(const std::string&,
2958 const chromeos::Any&)>& signal_callback,
2959 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
2960 chromeos::dbus_utils::ConnectToSignal(
2961 dbus_object_proxy_,
2962 "org.chromium.flimflam.Profile",
2963 "PropertyChanged",
2964 signal_callback,
2965 on_connected_callback);
2966 }
2967
2968 void ReleaseObjectProxy(const base::Closure& callback) {
2969 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
2970 }
2971
2972 const dbus::ObjectPath& GetObjectPath() const {
2973 return object_path_;
2974 }
2975
2976 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
2977
2978 bool GetProperties(
2979 chromeos::VariantDictionary* out_1,
2980 chromeos::ErrorPtr* error,
2981 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2982 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
2983 timeout_ms,
2984 dbus_object_proxy_,
2985 "org.chromium.flimflam.Profile",
2986 "GetProperties",
2987 error);
2988 return response && chromeos::dbus_utils::ExtractMethodCallResults(
2989 response.get(), error, out_1);
2990 }
2991
2992 void GetPropertiesAsync(
2993 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
2994 const base::Callback<void(chromeos::Error*)>& error_callback,
2995 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
2996 chromeos::dbus_utils::CallMethodWithTimeout(
2997 timeout_ms,
2998 dbus_object_proxy_,
2999 "org.chromium.flimflam.Profile",
3000 "GetProperties",
3001 success_callback,
3002 error_callback);
3003 }
3004
3005 bool SetProperty(
3006 const std::string& in_1,
3007 const chromeos::Any& in_2,
3008 chromeos::ErrorPtr* error,
3009 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3010 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3011 timeout_ms,
3012 dbus_object_proxy_,
3013 "org.chromium.flimflam.Profile",
3014 "SetProperty",
3015 error,
3016 in_1,
3017 in_2);
3018 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3019 response.get(), error);
3020 }
3021
3022 void SetPropertyAsync(
3023 const std::string& in_1,
3024 const chromeos::Any& in_2,
3025 const base::Callback<void()>& success_callback,
3026 const base::Callback<void(chromeos::Error*)>& error_callback,
3027 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3028 chromeos::dbus_utils::CallMethodWithTimeout(
3029 timeout_ms,
3030 dbus_object_proxy_,
3031 "org.chromium.flimflam.Profile",
3032 "SetProperty",
3033 success_callback,
3034 error_callback,
3035 in_1,
3036 in_2);
3037 }
3038
3039 bool GetEntry(
3040 const std::string& in_1,
3041 chromeos::VariantDictionary* out_2,
3042 chromeos::ErrorPtr* error,
3043 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3044 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3045 timeout_ms,
3046 dbus_object_proxy_,
3047 "org.chromium.flimflam.Profile",
3048 "GetEntry",
3049 error,
3050 in_1);
3051 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3052 response.get(), error, out_2);
3053 }
3054
3055 void GetEntryAsync(
3056 const std::string& in_1,
3057 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
3058 const base::Callback<void(chromeos::Error*)>& error_callback,
3059 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3060 chromeos::dbus_utils::CallMethodWithTimeout(
3061 timeout_ms,
3062 dbus_object_proxy_,
3063 "org.chromium.flimflam.Profile",
3064 "GetEntry",
3065 success_callback,
3066 error_callback,
3067 in_1);
3068 }
3069
3070 bool DeleteEntry(
3071 const std::string& in_1,
3072 chromeos::ErrorPtr* error,
3073 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3074 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3075 timeout_ms,
3076 dbus_object_proxy_,
3077 "org.chromium.flimflam.Profile",
3078 "DeleteEntry",
3079 error,
3080 in_1);
3081 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3082 response.get(), error);
3083 }
3084
3085 void DeleteEntryAsync(
3086 const std::string& in_1,
3087 const base::Callback<void()>& success_callback,
3088 const base::Callback<void(chromeos::Error*)>& error_callback,
3089 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3090 chromeos::dbus_utils::CallMethodWithTimeout(
3091 timeout_ms,
3092 dbus_object_proxy_,
3093 "org.chromium.flimflam.Profile",
3094 "DeleteEntry",
3095 success_callback,
3096 error_callback,
3097 in_1);
3098 }
3099
3100 private:
3101 scoped_refptr<dbus::Bus> bus_;
3102 const std::string service_name_{"org.chromium.flimflam"};
3103 dbus::ObjectPath object_path_;
3104 dbus::ObjectProxy* dbus_object_proxy_;
3105
3106 DISALLOW_COPY_AND_ASSIGN(ProfileProxy);
3107};
3108
3109} // namespace flimflam
3110} // namespace chromium
3111} // namespace org
3112
3113namespace org {
3114namespace chromium {
3115namespace flimflam {
3116
3117// Abstract interface proxy for org::chromium::flimflam::Service.
3118class ServiceProxyInterface {
3119 public:
3120 virtual ~ServiceProxyInterface() = default;
3121
3122 virtual bool GetProperties(
3123 chromeos::VariantDictionary* out_1,
3124 chromeos::ErrorPtr* error,
3125 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3126
3127 virtual void GetPropertiesAsync(
3128 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
3129 const base::Callback<void(chromeos::Error*)>& error_callback,
3130 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3131
3132 virtual bool SetProperty(
3133 const std::string& in_1,
3134 const chromeos::Any& in_2,
3135 chromeos::ErrorPtr* error,
3136 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3137
3138 virtual void SetPropertyAsync(
3139 const std::string& in_1,
3140 const chromeos::Any& in_2,
3141 const base::Callback<void()>& success_callback,
3142 const base::Callback<void(chromeos::Error*)>& error_callback,
3143 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3144
3145 virtual bool SetProperties(
3146 const chromeos::VariantDictionary& in_1,
3147 chromeos::ErrorPtr* error,
3148 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3149
3150 virtual void SetPropertiesAsync(
3151 const chromeos::VariantDictionary& in_1,
3152 const base::Callback<void()>& success_callback,
3153 const base::Callback<void(chromeos::Error*)>& error_callback,
3154 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3155
3156 virtual bool ClearProperty(
3157 const std::string& in_1,
3158 chromeos::ErrorPtr* error,
3159 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3160
3161 virtual void ClearPropertyAsync(
3162 const std::string& in_1,
3163 const base::Callback<void()>& success_callback,
3164 const base::Callback<void(chromeos::Error*)>& error_callback,
3165 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3166
3167 virtual bool ClearProperties(
3168 const std::vector<std::string>& in_1,
3169 std::vector<bool>* out_2,
3170 chromeos::ErrorPtr* error,
3171 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3172
3173 virtual void ClearPropertiesAsync(
3174 const std::vector<std::string>& in_1,
3175 const base::Callback<void(const std::vector<bool>&)>& success_callback,
3176 const base::Callback<void(chromeos::Error*)>& error_callback,
3177 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3178
3179 virtual bool Connect(
3180 chromeos::ErrorPtr* error,
3181 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3182
3183 virtual void ConnectAsync(
3184 const base::Callback<void()>& success_callback,
3185 const base::Callback<void(chromeos::Error*)>& error_callback,
3186 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3187
3188 virtual bool Disconnect(
3189 chromeos::ErrorPtr* error,
3190 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3191
3192 virtual void DisconnectAsync(
3193 const base::Callback<void()>& success_callback,
3194 const base::Callback<void(chromeos::Error*)>& error_callback,
3195 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3196
3197 virtual bool Remove(
3198 chromeos::ErrorPtr* error,
3199 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3200
3201 virtual void RemoveAsync(
3202 const base::Callback<void()>& success_callback,
3203 const base::Callback<void(chromeos::Error*)>& error_callback,
3204 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3205
3206 virtual bool ActivateCellularModem(
3207 const std::string& in_1,
3208 chromeos::ErrorPtr* error,
3209 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3210
3211 virtual void ActivateCellularModemAsync(
3212 const std::string& in_1,
3213 const base::Callback<void()>& success_callback,
3214 const base::Callback<void(chromeos::Error*)>& error_callback,
3215 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3216
3217 virtual bool CompleteCellularActivation(
3218 chromeos::ErrorPtr* error,
3219 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3220
3221 virtual void CompleteCellularActivationAsync(
3222 const base::Callback<void()>& success_callback,
3223 const base::Callback<void(chromeos::Error*)>& error_callback,
3224 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3225
3226 virtual bool GetLoadableProfileEntries(
3227 std::map<dbus::ObjectPath, std::string>* out_1,
3228 chromeos::ErrorPtr* error,
3229 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3230
3231 virtual void GetLoadableProfileEntriesAsync(
3232 const base::Callback<void(const std::map<dbus::ObjectPath, std::string>&)>& success_callback,
3233 const base::Callback<void(chromeos::Error*)>& error_callback,
3234 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3235
3236 virtual void RegisterPropertyChangedSignalHandler(
3237 const base::Callback<void(const std::string&,
3238 const chromeos::Any&)>& signal_callback,
3239 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
3240};
3241
3242} // namespace flimflam
3243} // namespace chromium
3244} // namespace org
3245
3246namespace org {
3247namespace chromium {
3248namespace flimflam {
3249
3250// Interface proxy for org::chromium::flimflam::Service.
3251class ServiceProxy final : public ServiceProxyInterface {
3252 public:
3253 ServiceProxy(
3254 const scoped_refptr<dbus::Bus>& bus,
3255 const dbus::ObjectPath& object_path) :
3256 bus_{bus},
3257 object_path_{object_path},
3258 dbus_object_proxy_{
3259 bus_->GetObjectProxy(service_name_, object_path_)} {
3260 }
3261
3262 ~ServiceProxy() override {
3263 bus_->RemoveObjectProxy(
3264 service_name_, object_path_, base::Bind(&base::DoNothing));
3265 }
3266
3267 void RegisterPropertyChangedSignalHandler(
3268 const base::Callback<void(const std::string&,
3269 const chromeos::Any&)>& signal_callback,
3270 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
3271 chromeos::dbus_utils::ConnectToSignal(
3272 dbus_object_proxy_,
3273 "org.chromium.flimflam.Service",
3274 "PropertyChanged",
3275 signal_callback,
3276 on_connected_callback);
3277 }
3278
3279 void ReleaseObjectProxy(const base::Closure& callback) {
3280 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
3281 }
3282
3283 const dbus::ObjectPath& GetObjectPath() const {
3284 return object_path_;
3285 }
3286
3287 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
3288
3289 bool GetProperties(
3290 chromeos::VariantDictionary* out_1,
3291 chromeos::ErrorPtr* error,
3292 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3293 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3294 timeout_ms,
3295 dbus_object_proxy_,
3296 "org.chromium.flimflam.Service",
3297 "GetProperties",
3298 error);
3299 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3300 response.get(), error, out_1);
3301 }
3302
3303 void GetPropertiesAsync(
3304 const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
3305 const base::Callback<void(chromeos::Error*)>& error_callback,
3306 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3307 chromeos::dbus_utils::CallMethodWithTimeout(
3308 timeout_ms,
3309 dbus_object_proxy_,
3310 "org.chromium.flimflam.Service",
3311 "GetProperties",
3312 success_callback,
3313 error_callback);
3314 }
3315
3316 bool SetProperty(
3317 const std::string& in_1,
3318 const chromeos::Any& in_2,
3319 chromeos::ErrorPtr* error,
3320 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3321 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3322 timeout_ms,
3323 dbus_object_proxy_,
3324 "org.chromium.flimflam.Service",
3325 "SetProperty",
3326 error,
3327 in_1,
3328 in_2);
3329 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3330 response.get(), error);
3331 }
3332
3333 void SetPropertyAsync(
3334 const std::string& in_1,
3335 const chromeos::Any& in_2,
3336 const base::Callback<void()>& success_callback,
3337 const base::Callback<void(chromeos::Error*)>& error_callback,
3338 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3339 chromeos::dbus_utils::CallMethodWithTimeout(
3340 timeout_ms,
3341 dbus_object_proxy_,
3342 "org.chromium.flimflam.Service",
3343 "SetProperty",
3344 success_callback,
3345 error_callback,
3346 in_1,
3347 in_2);
3348 }
3349
3350 bool SetProperties(
3351 const chromeos::VariantDictionary& in_1,
3352 chromeos::ErrorPtr* error,
3353 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3354 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3355 timeout_ms,
3356 dbus_object_proxy_,
3357 "org.chromium.flimflam.Service",
3358 "SetProperties",
3359 error,
3360 in_1);
3361 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3362 response.get(), error);
3363 }
3364
3365 void SetPropertiesAsync(
3366 const chromeos::VariantDictionary& in_1,
3367 const base::Callback<void()>& success_callback,
3368 const base::Callback<void(chromeos::Error*)>& error_callback,
3369 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3370 chromeos::dbus_utils::CallMethodWithTimeout(
3371 timeout_ms,
3372 dbus_object_proxy_,
3373 "org.chromium.flimflam.Service",
3374 "SetProperties",
3375 success_callback,
3376 error_callback,
3377 in_1);
3378 }
3379
3380 bool ClearProperty(
3381 const std::string& in_1,
3382 chromeos::ErrorPtr* error,
3383 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3384 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3385 timeout_ms,
3386 dbus_object_proxy_,
3387 "org.chromium.flimflam.Service",
3388 "ClearProperty",
3389 error,
3390 in_1);
3391 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3392 response.get(), error);
3393 }
3394
3395 void ClearPropertyAsync(
3396 const std::string& in_1,
3397 const base::Callback<void()>& success_callback,
3398 const base::Callback<void(chromeos::Error*)>& error_callback,
3399 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3400 chromeos::dbus_utils::CallMethodWithTimeout(
3401 timeout_ms,
3402 dbus_object_proxy_,
3403 "org.chromium.flimflam.Service",
3404 "ClearProperty",
3405 success_callback,
3406 error_callback,
3407 in_1);
3408 }
3409
3410 bool ClearProperties(
3411 const std::vector<std::string>& in_1,
3412 std::vector<bool>* out_2,
3413 chromeos::ErrorPtr* error,
3414 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3415 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3416 timeout_ms,
3417 dbus_object_proxy_,
3418 "org.chromium.flimflam.Service",
3419 "ClearProperties",
3420 error,
3421 in_1);
3422 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3423 response.get(), error, out_2);
3424 }
3425
3426 void ClearPropertiesAsync(
3427 const std::vector<std::string>& in_1,
3428 const base::Callback<void(const std::vector<bool>&)>& success_callback,
3429 const base::Callback<void(chromeos::Error*)>& error_callback,
3430 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3431 chromeos::dbus_utils::CallMethodWithTimeout(
3432 timeout_ms,
3433 dbus_object_proxy_,
3434 "org.chromium.flimflam.Service",
3435 "ClearProperties",
3436 success_callback,
3437 error_callback,
3438 in_1);
3439 }
3440
3441 bool Connect(
3442 chromeos::ErrorPtr* error,
3443 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3444 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3445 timeout_ms,
3446 dbus_object_proxy_,
3447 "org.chromium.flimflam.Service",
3448 "Connect",
3449 error);
3450 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3451 response.get(), error);
3452 }
3453
3454 void ConnectAsync(
3455 const base::Callback<void()>& success_callback,
3456 const base::Callback<void(chromeos::Error*)>& error_callback,
3457 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3458 chromeos::dbus_utils::CallMethodWithTimeout(
3459 timeout_ms,
3460 dbus_object_proxy_,
3461 "org.chromium.flimflam.Service",
3462 "Connect",
3463 success_callback,
3464 error_callback);
3465 }
3466
3467 bool Disconnect(
3468 chromeos::ErrorPtr* error,
3469 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3470 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3471 timeout_ms,
3472 dbus_object_proxy_,
3473 "org.chromium.flimflam.Service",
3474 "Disconnect",
3475 error);
3476 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3477 response.get(), error);
3478 }
3479
3480 void DisconnectAsync(
3481 const base::Callback<void()>& success_callback,
3482 const base::Callback<void(chromeos::Error*)>& error_callback,
3483 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3484 chromeos::dbus_utils::CallMethodWithTimeout(
3485 timeout_ms,
3486 dbus_object_proxy_,
3487 "org.chromium.flimflam.Service",
3488 "Disconnect",
3489 success_callback,
3490 error_callback);
3491 }
3492
3493 bool Remove(
3494 chromeos::ErrorPtr* error,
3495 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3496 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3497 timeout_ms,
3498 dbus_object_proxy_,
3499 "org.chromium.flimflam.Service",
3500 "Remove",
3501 error);
3502 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3503 response.get(), error);
3504 }
3505
3506 void RemoveAsync(
3507 const base::Callback<void()>& success_callback,
3508 const base::Callback<void(chromeos::Error*)>& error_callback,
3509 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3510 chromeos::dbus_utils::CallMethodWithTimeout(
3511 timeout_ms,
3512 dbus_object_proxy_,
3513 "org.chromium.flimflam.Service",
3514 "Remove",
3515 success_callback,
3516 error_callback);
3517 }
3518
3519 bool ActivateCellularModem(
3520 const std::string& in_1,
3521 chromeos::ErrorPtr* error,
3522 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3523 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3524 timeout_ms,
3525 dbus_object_proxy_,
3526 "org.chromium.flimflam.Service",
3527 "ActivateCellularModem",
3528 error,
3529 in_1);
3530 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3531 response.get(), error);
3532 }
3533
3534 void ActivateCellularModemAsync(
3535 const std::string& in_1,
3536 const base::Callback<void()>& success_callback,
3537 const base::Callback<void(chromeos::Error*)>& error_callback,
3538 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3539 chromeos::dbus_utils::CallMethodWithTimeout(
3540 timeout_ms,
3541 dbus_object_proxy_,
3542 "org.chromium.flimflam.Service",
3543 "ActivateCellularModem",
3544 success_callback,
3545 error_callback,
3546 in_1);
3547 }
3548
3549 bool CompleteCellularActivation(
3550 chromeos::ErrorPtr* error,
3551 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3552 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3553 timeout_ms,
3554 dbus_object_proxy_,
3555 "org.chromium.flimflam.Service",
3556 "CompleteCellularActivation",
3557 error);
3558 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3559 response.get(), error);
3560 }
3561
3562 void CompleteCellularActivationAsync(
3563 const base::Callback<void()>& success_callback,
3564 const base::Callback<void(chromeos::Error*)>& error_callback,
3565 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3566 chromeos::dbus_utils::CallMethodWithTimeout(
3567 timeout_ms,
3568 dbus_object_proxy_,
3569 "org.chromium.flimflam.Service",
3570 "CompleteCellularActivation",
3571 success_callback,
3572 error_callback);
3573 }
3574
3575 bool GetLoadableProfileEntries(
3576 std::map<dbus::ObjectPath, std::string>* out_1,
3577 chromeos::ErrorPtr* error,
3578 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3579 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3580 timeout_ms,
3581 dbus_object_proxy_,
3582 "org.chromium.flimflam.Service",
3583 "GetLoadableProfileEntries",
3584 error);
3585 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3586 response.get(), error, out_1);
3587 }
3588
3589 void GetLoadableProfileEntriesAsync(
3590 const base::Callback<void(const std::map<dbus::ObjectPath, std::string>&)>& success_callback,
3591 const base::Callback<void(chromeos::Error*)>& error_callback,
3592 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3593 chromeos::dbus_utils::CallMethodWithTimeout(
3594 timeout_ms,
3595 dbus_object_proxy_,
3596 "org.chromium.flimflam.Service",
3597 "GetLoadableProfileEntries",
3598 success_callback,
3599 error_callback);
3600 }
3601
3602 private:
3603 scoped_refptr<dbus::Bus> bus_;
3604 const std::string service_name_{"org.chromium.flimflam"};
3605 dbus::ObjectPath object_path_;
3606 dbus::ObjectProxy* dbus_object_proxy_;
3607
3608 DISALLOW_COPY_AND_ASSIGN(ServiceProxy);
3609};
3610
3611} // namespace flimflam
3612} // namespace chromium
3613} // namespace org
3614
3615namespace org {
3616namespace chromium {
3617namespace flimflam {
3618
3619// Abstract interface proxy for org::chromium::flimflam::Task.
3620class TaskProxyInterface {
3621 public:
3622 virtual ~TaskProxyInterface() = default;
3623
3624 virtual bool getsec(
3625 std::string* out_1,
3626 std::string* out_2,
3627 chromeos::ErrorPtr* error,
3628 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3629
3630 virtual void getsecAsync(
3631 const base::Callback<void(const std::string&, const std::string&)>& success_callback,
3632 const base::Callback<void(chromeos::Error*)>& error_callback,
3633 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3634
3635 virtual bool notify(
3636 const std::string& in_1,
3637 const std::map<std::string, std::string>& in_2,
3638 chromeos::ErrorPtr* error,
3639 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3640
3641 virtual void notifyAsync(
3642 const std::string& in_1,
3643 const std::map<std::string, std::string>& in_2,
3644 const base::Callback<void()>& success_callback,
3645 const base::Callback<void(chromeos::Error*)>& error_callback,
3646 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3647};
3648
3649} // namespace flimflam
3650} // namespace chromium
3651} // namespace org
3652
3653namespace org {
3654namespace chromium {
3655namespace flimflam {
3656
3657// Interface proxy for org::chromium::flimflam::Task.
3658class TaskProxy final : public TaskProxyInterface {
3659 public:
3660 TaskProxy(
3661 const scoped_refptr<dbus::Bus>& bus,
3662 const dbus::ObjectPath& object_path) :
3663 bus_{bus},
3664 object_path_{object_path},
3665 dbus_object_proxy_{
3666 bus_->GetObjectProxy(service_name_, object_path_)} {
3667 }
3668
3669 ~TaskProxy() override {
3670 bus_->RemoveObjectProxy(
3671 service_name_, object_path_, base::Bind(&base::DoNothing));
3672 }
3673
3674 void ReleaseObjectProxy(const base::Closure& callback) {
3675 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
3676 }
3677
3678 const dbus::ObjectPath& GetObjectPath() const {
3679 return object_path_;
3680 }
3681
3682 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
3683
3684 bool getsec(
3685 std::string* out_1,
3686 std::string* out_2,
3687 chromeos::ErrorPtr* error,
3688 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3689 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3690 timeout_ms,
3691 dbus_object_proxy_,
3692 "org.chromium.flimflam.Task",
3693 "getsec",
3694 error);
3695 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3696 response.get(), error, out_1, out_2);
3697 }
3698
3699 void getsecAsync(
3700 const base::Callback<void(const std::string&, const std::string&)>& success_callback,
3701 const base::Callback<void(chromeos::Error*)>& error_callback,
3702 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3703 chromeos::dbus_utils::CallMethodWithTimeout(
3704 timeout_ms,
3705 dbus_object_proxy_,
3706 "org.chromium.flimflam.Task",
3707 "getsec",
3708 success_callback,
3709 error_callback);
3710 }
3711
3712 bool notify(
3713 const std::string& in_1,
3714 const std::map<std::string, std::string>& in_2,
3715 chromeos::ErrorPtr* error,
3716 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3717 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3718 timeout_ms,
3719 dbus_object_proxy_,
3720 "org.chromium.flimflam.Task",
3721 "notify",
3722 error,
3723 in_1,
3724 in_2);
3725 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3726 response.get(), error);
3727 }
3728
3729 void notifyAsync(
3730 const std::string& in_1,
3731 const std::map<std::string, std::string>& in_2,
3732 const base::Callback<void()>& success_callback,
3733 const base::Callback<void(chromeos::Error*)>& error_callback,
3734 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3735 chromeos::dbus_utils::CallMethodWithTimeout(
3736 timeout_ms,
3737 dbus_object_proxy_,
3738 "org.chromium.flimflam.Task",
3739 "notify",
3740 success_callback,
3741 error_callback,
3742 in_1,
3743 in_2);
3744 }
3745
3746 private:
3747 scoped_refptr<dbus::Bus> bus_;
3748 const std::string service_name_{"org.chromium.flimflam"};
3749 dbus::ObjectPath object_path_;
3750 dbus::ObjectProxy* dbus_object_proxy_;
3751
3752 DISALLOW_COPY_AND_ASSIGN(TaskProxy);
3753};
3754
3755} // namespace flimflam
3756} // namespace chromium
3757} // namespace org
3758
3759namespace org {
3760namespace chromium {
3761namespace flimflam {
3762
3763// Abstract interface proxy for org::chromium::flimflam::ThirdPartyVpn.
3764class ThirdPartyVpnProxyInterface {
3765 public:
3766 virtual ~ThirdPartyVpnProxyInterface() = default;
3767
3768 virtual bool SetParameters(
3769 const std::map<std::string, std::string>& in_parameters,
3770 std::string* out_warning,
3771 chromeos::ErrorPtr* error,
3772 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3773
3774 virtual void SetParametersAsync(
3775 const std::map<std::string, std::string>& in_parameters,
3776 const base::Callback<void(const std::string& /*warning*/)>& success_callback,
3777 const base::Callback<void(chromeos::Error*)>& error_callback,
3778 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3779
3780 virtual bool UpdateConnectionState(
3781 uint32_t in_connection_state,
3782 chromeos::ErrorPtr* error,
3783 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3784
3785 virtual void UpdateConnectionStateAsync(
3786 uint32_t in_connection_state,
3787 const base::Callback<void()>& success_callback,
3788 const base::Callback<void(chromeos::Error*)>& error_callback,
3789 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3790
3791 virtual bool SendPacket(
3792 const std::vector<uint8_t>& in_ip_packet,
3793 chromeos::ErrorPtr* error,
3794 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3795
3796 virtual void SendPacketAsync(
3797 const std::vector<uint8_t>& in_ip_packet,
3798 const base::Callback<void()>& success_callback,
3799 const base::Callback<void(chromeos::Error*)>& error_callback,
3800 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
3801
3802 virtual void RegisterOnPacketReceivedSignalHandler(
3803 const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
3804 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
3805
3806 virtual void RegisterOnPlatformMessageSignalHandler(
3807 const base::Callback<void(uint32_t)>& signal_callback,
3808 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
3809};
3810
3811} // namespace flimflam
3812} // namespace chromium
3813} // namespace org
3814
3815namespace org {
3816namespace chromium {
3817namespace flimflam {
3818
3819// Interface proxy for org::chromium::flimflam::ThirdPartyVpn.
3820class ThirdPartyVpnProxy final : public ThirdPartyVpnProxyInterface {
3821 public:
3822 ThirdPartyVpnProxy(
3823 const scoped_refptr<dbus::Bus>& bus,
3824 const dbus::ObjectPath& object_path) :
3825 bus_{bus},
3826 object_path_{object_path},
3827 dbus_object_proxy_{
3828 bus_->GetObjectProxy(service_name_, object_path_)} {
3829 }
3830
3831 ~ThirdPartyVpnProxy() override {
3832 bus_->RemoveObjectProxy(
3833 service_name_, object_path_, base::Bind(&base::DoNothing));
3834 }
3835
3836 void RegisterOnPacketReceivedSignalHandler(
3837 const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
3838 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
3839 chromeos::dbus_utils::ConnectToSignal(
3840 dbus_object_proxy_,
3841 "org.chromium.flimflam.ThirdPartyVpn",
3842 "OnPacketReceived",
3843 signal_callback,
3844 on_connected_callback);
3845 }
3846
3847 void RegisterOnPlatformMessageSignalHandler(
3848 const base::Callback<void(uint32_t)>& signal_callback,
3849 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
3850 chromeos::dbus_utils::ConnectToSignal(
3851 dbus_object_proxy_,
3852 "org.chromium.flimflam.ThirdPartyVpn",
3853 "OnPlatformMessage",
3854 signal_callback,
3855 on_connected_callback);
3856 }
3857
3858 void ReleaseObjectProxy(const base::Closure& callback) {
3859 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
3860 }
3861
3862 const dbus::ObjectPath& GetObjectPath() const {
3863 return object_path_;
3864 }
3865
3866 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
3867
3868 bool SetParameters(
3869 const std::map<std::string, std::string>& in_parameters,
3870 std::string* out_warning,
3871 chromeos::ErrorPtr* error,
3872 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3873 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3874 timeout_ms,
3875 dbus_object_proxy_,
3876 "org.chromium.flimflam.ThirdPartyVpn",
3877 "SetParameters",
3878 error,
3879 in_parameters);
3880 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3881 response.get(), error, out_warning);
3882 }
3883
3884 void SetParametersAsync(
3885 const std::map<std::string, std::string>& in_parameters,
3886 const base::Callback<void(const std::string& /*warning*/)>& success_callback,
3887 const base::Callback<void(chromeos::Error*)>& error_callback,
3888 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3889 chromeos::dbus_utils::CallMethodWithTimeout(
3890 timeout_ms,
3891 dbus_object_proxy_,
3892 "org.chromium.flimflam.ThirdPartyVpn",
3893 "SetParameters",
3894 success_callback,
3895 error_callback,
3896 in_parameters);
3897 }
3898
3899 bool UpdateConnectionState(
3900 uint32_t in_connection_state,
3901 chromeos::ErrorPtr* error,
3902 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3903 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3904 timeout_ms,
3905 dbus_object_proxy_,
3906 "org.chromium.flimflam.ThirdPartyVpn",
3907 "UpdateConnectionState",
3908 error,
3909 in_connection_state);
3910 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3911 response.get(), error);
3912 }
3913
3914 void UpdateConnectionStateAsync(
3915 uint32_t in_connection_state,
3916 const base::Callback<void()>& success_callback,
3917 const base::Callback<void(chromeos::Error*)>& error_callback,
3918 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3919 chromeos::dbus_utils::CallMethodWithTimeout(
3920 timeout_ms,
3921 dbus_object_proxy_,
3922 "org.chromium.flimflam.ThirdPartyVpn",
3923 "UpdateConnectionState",
3924 success_callback,
3925 error_callback,
3926 in_connection_state);
3927 }
3928
3929 bool SendPacket(
3930 const std::vector<uint8_t>& in_ip_packet,
3931 chromeos::ErrorPtr* error,
3932 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3933 auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
3934 timeout_ms,
3935 dbus_object_proxy_,
3936 "org.chromium.flimflam.ThirdPartyVpn",
3937 "SendPacket",
3938 error,
3939 in_ip_packet);
3940 return response && chromeos::dbus_utils::ExtractMethodCallResults(
3941 response.get(), error);
3942 }
3943
3944 void SendPacketAsync(
3945 const std::vector<uint8_t>& in_ip_packet,
3946 const base::Callback<void()>& success_callback,
3947 const base::Callback<void(chromeos::Error*)>& error_callback,
3948 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
3949 chromeos::dbus_utils::CallMethodWithTimeout(
3950 timeout_ms,
3951 dbus_object_proxy_,
3952 "org.chromium.flimflam.ThirdPartyVpn",
3953 "SendPacket",
3954 success_callback,
3955 error_callback,
3956 in_ip_packet);
3957 }
3958
3959 private:
3960 scoped_refptr<dbus::Bus> bus_;
3961 const std::string service_name_{"org.chromium.flimflam"};
3962 dbus::ObjectPath object_path_;
3963 dbus::ObjectProxy* dbus_object_proxy_;
3964
3965 DISALLOW_COPY_AND_ASSIGN(ThirdPartyVpnProxy);
3966};
3967
3968} // namespace flimflam
3969} // namespace chromium
3970} // namespace org
3971
3972#endif // ____CHROMEOS_DBUS_BINDING___BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_SHILL_OUT_DEFAULT_GEN_INCLUDE_SHILL_DBUS_PROXIES_H