1// Automatic generation of D-Bus interfaces:
2//  - org.chromium.SessionManagerInterface
3#ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXIES_H
4#define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXIES_H
5#include <memory>
6#include <string>
7#include <vector>
8
9#include <base/bind.h>
10#include <base/callback.h>
11#include <base/logging.h>
12#include <base/macros.h>
13#include <base/memory/ref_counted.h>
14#include <brillo/any.h>
15#include <brillo/dbus/dbus_method_invoker.h>
16#include <brillo/dbus/dbus_property.h>
17#include <brillo/dbus/dbus_signal_handler.h>
18#include <brillo/errors/error.h>
19#include <brillo/variant_dictionary.h>
20#include <dbus/bus.h>
21#include <dbus/message.h>
22#include <dbus/object_manager.h>
23#include <dbus/object_path.h>
24#include <dbus/object_proxy.h>
25
26namespace org {
27namespace chromium {
28
29// Abstract interface proxy for org::chromium::SessionManagerInterface.
30class SessionManagerInterfaceProxyInterface {
31 public:
32  virtual ~SessionManagerInterfaceProxyInterface() = default;
33
34  virtual bool EmitLoginPromptVisible(
35      brillo::ErrorPtr* error,
36      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
37
38  virtual void EmitLoginPromptVisibleAsync(
39      const base::Callback<void()>& success_callback,
40      const base::Callback<void(brillo::Error*)>& error_callback,
41      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
42
43  virtual bool EnableChromeTesting(
44      bool in_force_relaunch,
45      const std::vector<std::string>& in_extra_arguments,
46      std::string* out_filepath,
47      brillo::ErrorPtr* error,
48      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
49
50  virtual void EnableChromeTestingAsync(
51      bool in_force_relaunch,
52      const std::vector<std::string>& in_extra_arguments,
53      const base::Callback<void(const std::string& /*filepath*/)>& success_callback,
54      const base::Callback<void(brillo::Error*)>& error_callback,
55      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
56
57  virtual bool StartSession(
58      const std::string& in_email_address,
59      const std::string& in_unique_identifier,
60      bool* out_done,
61      brillo::ErrorPtr* error,
62      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
63
64  virtual void StartSessionAsync(
65      const std::string& in_email_address,
66      const std::string& in_unique_identifier,
67      const base::Callback<void(bool /*done*/)>& success_callback,
68      const base::Callback<void(brillo::Error*)>& error_callback,
69      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
70
71  virtual bool StopSession(
72      const std::string& in_unique_identifier,
73      bool* out_done,
74      brillo::ErrorPtr* error,
75      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
76
77  virtual void StopSessionAsync(
78      const std::string& in_unique_identifier,
79      const base::Callback<void(bool /*done*/)>& success_callback,
80      const base::Callback<void(brillo::Error*)>& error_callback,
81      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
82
83  virtual bool StorePolicy(
84      const std::vector<uint8_t>& in_policy_blob,
85      bool* out_done,
86      brillo::ErrorPtr* error,
87      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
88
89  virtual void StorePolicyAsync(
90      const std::vector<uint8_t>& in_policy_blob,
91      const base::Callback<void(bool /*done*/)>& success_callback,
92      const base::Callback<void(brillo::Error*)>& error_callback,
93      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
94
95  virtual bool RetrievePolicy(
96      std::vector<uint8_t>* out_policy_blob,
97      brillo::ErrorPtr* error,
98      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
99
100  virtual void RetrievePolicyAsync(
101      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
102      const base::Callback<void(brillo::Error*)>& error_callback,
103      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
104
105  virtual bool StorePolicyForUser(
106      const std::string& in_user_email,
107      const std::vector<uint8_t>& in_policy_blob,
108      bool* out_done,
109      brillo::ErrorPtr* error,
110      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
111
112  virtual void StorePolicyForUserAsync(
113      const std::string& in_user_email,
114      const std::vector<uint8_t>& in_policy_blob,
115      const base::Callback<void(bool /*done*/)>& success_callback,
116      const base::Callback<void(brillo::Error*)>& error_callback,
117      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
118
119  virtual bool RetrievePolicyForUser(
120      const std::string& in_user_email,
121      std::vector<uint8_t>* out_policy_blob,
122      brillo::ErrorPtr* error,
123      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
124
125  virtual void RetrievePolicyForUserAsync(
126      const std::string& in_user_email,
127      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
128      const base::Callback<void(brillo::Error*)>& error_callback,
129      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
130
131  virtual bool StoreDeviceLocalAccountPolicy(
132      const std::string& in_account_id,
133      const std::vector<uint8_t>& in_policy_blob,
134      bool* out_done,
135      brillo::ErrorPtr* error,
136      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
137
138  virtual void StoreDeviceLocalAccountPolicyAsync(
139      const std::string& in_account_id,
140      const std::vector<uint8_t>& in_policy_blob,
141      const base::Callback<void(bool /*done*/)>& success_callback,
142      const base::Callback<void(brillo::Error*)>& error_callback,
143      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
144
145  virtual bool RetrieveDeviceLocalAccountPolicy(
146      const std::string& in_account_id,
147      std::vector<uint8_t>* out_policy_blob,
148      brillo::ErrorPtr* error,
149      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
150
151  virtual void RetrieveDeviceLocalAccountPolicyAsync(
152      const std::string& in_account_id,
153      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
154      const base::Callback<void(brillo::Error*)>& error_callback,
155      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
156
157  virtual bool RetrieveSessionState(
158      std::string* out_state,
159      brillo::ErrorPtr* error,
160      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
161
162  virtual void RetrieveSessionStateAsync(
163      const base::Callback<void(const std::string& /*state*/)>& success_callback,
164      const base::Callback<void(brillo::Error*)>& error_callback,
165      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
166
167  virtual bool RetrieveActiveSessions(
168      std::map<std::string, std::string>* out_sessions,
169      brillo::ErrorPtr* error,
170      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
171
172  virtual void RetrieveActiveSessionsAsync(
173      const base::Callback<void(const std::map<std::string, std::string>& /*sessions*/)>& success_callback,
174      const base::Callback<void(brillo::Error*)>& error_callback,
175      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
176
177  virtual bool HandleSupervisedUserCreationStarting(
178      brillo::ErrorPtr* error,
179      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
180
181  virtual void HandleSupervisedUserCreationStartingAsync(
182      const base::Callback<void()>& success_callback,
183      const base::Callback<void(brillo::Error*)>& error_callback,
184      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
185
186  virtual bool HandleSupervisedUserCreationFinished(
187      brillo::ErrorPtr* error,
188      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
189
190  virtual void HandleSupervisedUserCreationFinishedAsync(
191      const base::Callback<void()>& success_callback,
192      const base::Callback<void(brillo::Error*)>& error_callback,
193      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
194
195  virtual bool LockScreen(
196      brillo::ErrorPtr* error,
197      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
198
199  virtual void LockScreenAsync(
200      const base::Callback<void()>& success_callback,
201      const base::Callback<void(brillo::Error*)>& error_callback,
202      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
203
204  virtual bool HandleLockScreenShown(
205      brillo::ErrorPtr* error,
206      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
207
208  virtual void HandleLockScreenShownAsync(
209      const base::Callback<void()>& success_callback,
210      const base::Callback<void(brillo::Error*)>& error_callback,
211      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
212
213  virtual bool HandleLockScreenDismissed(
214      brillo::ErrorPtr* error,
215      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
216
217  virtual void HandleLockScreenDismissedAsync(
218      const base::Callback<void()>& success_callback,
219      const base::Callback<void(brillo::Error*)>& error_callback,
220      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
221
222  virtual bool RestartJob(
223      const dbus::FileDescriptor& in_cred_fd,
224      const std::vector<std::string>& in_argv,
225      brillo::ErrorPtr* error,
226      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
227
228  virtual void RestartJobAsync(
229      const dbus::FileDescriptor& in_cred_fd,
230      const std::vector<std::string>& in_argv,
231      const base::Callback<void()>& success_callback,
232      const base::Callback<void(brillo::Error*)>& error_callback,
233      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
234
235  virtual bool StartDeviceWipe(
236      bool* out_done,
237      brillo::ErrorPtr* error,
238      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
239
240  virtual void StartDeviceWipeAsync(
241      const base::Callback<void(bool /*done*/)>& success_callback,
242      const base::Callback<void(brillo::Error*)>& error_callback,
243      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
244
245  virtual bool SetFlagsForUser(
246      const std::string& in_user_email,
247      const std::vector<std::string>& in_flags,
248      brillo::ErrorPtr* error,
249      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
250
251  virtual void SetFlagsForUserAsync(
252      const std::string& in_user_email,
253      const std::vector<std::string>& in_flags,
254      const base::Callback<void()>& success_callback,
255      const base::Callback<void(brillo::Error*)>& error_callback,
256      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
257
258  virtual bool GetServerBackedStateKeys(
259      std::vector<std::vector<uint8_t>>* out_state_keys,
260      brillo::ErrorPtr* error,
261      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
262
263  virtual void GetServerBackedStateKeysAsync(
264      const base::Callback<void(const std::vector<std::vector<uint8_t>>& /*state_keys*/)>& success_callback,
265      const base::Callback<void(brillo::Error*)>& error_callback,
266      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
267
268  virtual bool InitMachineInfo(
269      const std::string& in_data,
270      brillo::ErrorPtr* error,
271      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
272
273  virtual void InitMachineInfoAsync(
274      const std::string& in_data,
275      const base::Callback<void()>& success_callback,
276      const base::Callback<void(brillo::Error*)>& error_callback,
277      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
278
279  virtual void RegisterLoginPromptVisibleSignalHandler(
280      const base::Closure& signal_callback,
281      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
282
283  virtual void RegisterSessionStateChangedSignalHandler(
284      const base::Callback<void(const std::string&)>& signal_callback,
285      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
286
287  virtual void RegisterSetOwnerKeyCompleteSignalHandler(
288      const base::Callback<void(const std::string&)>& signal_callback,
289      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
290
291  virtual void RegisterPropertyChangeCompleteSignalHandler(
292      const base::Callback<void(const std::string&)>& signal_callback,
293      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
294
295  virtual void RegisterScreenIsLockedSignalHandler(
296      const base::Closure& signal_callback,
297      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
298
299  virtual void RegisterScreenIsUnlockedSignalHandler(
300      const base::Closure& signal_callback,
301      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
302};
303
304}  // namespace chromium
305}  // namespace org
306
307namespace org {
308namespace chromium {
309
310// Interface proxy for org::chromium::SessionManagerInterface.
311class SessionManagerInterfaceProxy final : public SessionManagerInterfaceProxyInterface {
312 public:
313  SessionManagerInterfaceProxy(const scoped_refptr<dbus::Bus>& bus) :
314      bus_{bus},
315      dbus_object_proxy_{
316          bus_->GetObjectProxy(service_name_, object_path_)} {
317  }
318
319  ~SessionManagerInterfaceProxy() override {
320    bus_->RemoveObjectProxy(
321        service_name_, object_path_, base::Bind(&base::DoNothing));
322  }
323
324  void RegisterLoginPromptVisibleSignalHandler(
325      const base::Closure& signal_callback,
326      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
327    brillo::dbus_utils::ConnectToSignal(
328        dbus_object_proxy_,
329        "org.chromium.SessionManagerInterface",
330        "LoginPromptVisible",
331        signal_callback,
332        on_connected_callback);
333  }
334
335  void RegisterSessionStateChangedSignalHandler(
336      const base::Callback<void(const std::string&)>& signal_callback,
337      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
338    brillo::dbus_utils::ConnectToSignal(
339        dbus_object_proxy_,
340        "org.chromium.SessionManagerInterface",
341        "SessionStateChanged",
342        signal_callback,
343        on_connected_callback);
344  }
345
346  void RegisterSetOwnerKeyCompleteSignalHandler(
347      const base::Callback<void(const std::string&)>& signal_callback,
348      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
349    brillo::dbus_utils::ConnectToSignal(
350        dbus_object_proxy_,
351        "org.chromium.SessionManagerInterface",
352        "SetOwnerKeyComplete",
353        signal_callback,
354        on_connected_callback);
355  }
356
357  void RegisterPropertyChangeCompleteSignalHandler(
358      const base::Callback<void(const std::string&)>& signal_callback,
359      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
360    brillo::dbus_utils::ConnectToSignal(
361        dbus_object_proxy_,
362        "org.chromium.SessionManagerInterface",
363        "PropertyChangeComplete",
364        signal_callback,
365        on_connected_callback);
366  }
367
368  void RegisterScreenIsLockedSignalHandler(
369      const base::Closure& signal_callback,
370      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
371    brillo::dbus_utils::ConnectToSignal(
372        dbus_object_proxy_,
373        "org.chromium.SessionManagerInterface",
374        "ScreenIsLocked",
375        signal_callback,
376        on_connected_callback);
377  }
378
379  void RegisterScreenIsUnlockedSignalHandler(
380      const base::Closure& signal_callback,
381      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
382    brillo::dbus_utils::ConnectToSignal(
383        dbus_object_proxy_,
384        "org.chromium.SessionManagerInterface",
385        "ScreenIsUnlocked",
386        signal_callback,
387        on_connected_callback);
388  }
389
390  void ReleaseObjectProxy(const base::Closure& callback) {
391    bus_->RemoveObjectProxy(service_name_, object_path_, callback);
392  }
393
394  const dbus::ObjectPath& GetObjectPath() const {
395    return object_path_;
396  }
397
398  dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
399
400  bool EmitLoginPromptVisible(
401      brillo::ErrorPtr* error,
402      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
403    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
404        timeout_ms,
405        dbus_object_proxy_,
406        "org.chromium.SessionManagerInterface",
407        "EmitLoginPromptVisible",
408        error);
409    return response && brillo::dbus_utils::ExtractMethodCallResults(
410        response.get(), error);
411  }
412
413  void EmitLoginPromptVisibleAsync(
414      const base::Callback<void()>& success_callback,
415      const base::Callback<void(brillo::Error*)>& error_callback,
416      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
417    brillo::dbus_utils::CallMethodWithTimeout(
418        timeout_ms,
419        dbus_object_proxy_,
420        "org.chromium.SessionManagerInterface",
421        "EmitLoginPromptVisible",
422        success_callback,
423        error_callback);
424  }
425
426  bool EnableChromeTesting(
427      bool in_force_relaunch,
428      const std::vector<std::string>& in_extra_arguments,
429      std::string* out_filepath,
430      brillo::ErrorPtr* error,
431      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
432    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
433        timeout_ms,
434        dbus_object_proxy_,
435        "org.chromium.SessionManagerInterface",
436        "EnableChromeTesting",
437        error,
438        in_force_relaunch,
439        in_extra_arguments);
440    return response && brillo::dbus_utils::ExtractMethodCallResults(
441        response.get(), error, out_filepath);
442  }
443
444  void EnableChromeTestingAsync(
445      bool in_force_relaunch,
446      const std::vector<std::string>& in_extra_arguments,
447      const base::Callback<void(const std::string& /*filepath*/)>& success_callback,
448      const base::Callback<void(brillo::Error*)>& error_callback,
449      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
450    brillo::dbus_utils::CallMethodWithTimeout(
451        timeout_ms,
452        dbus_object_proxy_,
453        "org.chromium.SessionManagerInterface",
454        "EnableChromeTesting",
455        success_callback,
456        error_callback,
457        in_force_relaunch,
458        in_extra_arguments);
459  }
460
461  bool StartSession(
462      const std::string& in_email_address,
463      const std::string& in_unique_identifier,
464      bool* out_done,
465      brillo::ErrorPtr* error,
466      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
467    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
468        timeout_ms,
469        dbus_object_proxy_,
470        "org.chromium.SessionManagerInterface",
471        "StartSession",
472        error,
473        in_email_address,
474        in_unique_identifier);
475    return response && brillo::dbus_utils::ExtractMethodCallResults(
476        response.get(), error, out_done);
477  }
478
479  void StartSessionAsync(
480      const std::string& in_email_address,
481      const std::string& in_unique_identifier,
482      const base::Callback<void(bool /*done*/)>& success_callback,
483      const base::Callback<void(brillo::Error*)>& error_callback,
484      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
485    brillo::dbus_utils::CallMethodWithTimeout(
486        timeout_ms,
487        dbus_object_proxy_,
488        "org.chromium.SessionManagerInterface",
489        "StartSession",
490        success_callback,
491        error_callback,
492        in_email_address,
493        in_unique_identifier);
494  }
495
496  bool StopSession(
497      const std::string& in_unique_identifier,
498      bool* out_done,
499      brillo::ErrorPtr* error,
500      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
501    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
502        timeout_ms,
503        dbus_object_proxy_,
504        "org.chromium.SessionManagerInterface",
505        "StopSession",
506        error,
507        in_unique_identifier);
508    return response && brillo::dbus_utils::ExtractMethodCallResults(
509        response.get(), error, out_done);
510  }
511
512  void StopSessionAsync(
513      const std::string& in_unique_identifier,
514      const base::Callback<void(bool /*done*/)>& success_callback,
515      const base::Callback<void(brillo::Error*)>& error_callback,
516      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
517    brillo::dbus_utils::CallMethodWithTimeout(
518        timeout_ms,
519        dbus_object_proxy_,
520        "org.chromium.SessionManagerInterface",
521        "StopSession",
522        success_callback,
523        error_callback,
524        in_unique_identifier);
525  }
526
527  bool StorePolicy(
528      const std::vector<uint8_t>& in_policy_blob,
529      bool* out_done,
530      brillo::ErrorPtr* error,
531      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
532    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
533        timeout_ms,
534        dbus_object_proxy_,
535        "org.chromium.SessionManagerInterface",
536        "StorePolicy",
537        error,
538        in_policy_blob);
539    return response && brillo::dbus_utils::ExtractMethodCallResults(
540        response.get(), error, out_done);
541  }
542
543  void StorePolicyAsync(
544      const std::vector<uint8_t>& in_policy_blob,
545      const base::Callback<void(bool /*done*/)>& success_callback,
546      const base::Callback<void(brillo::Error*)>& error_callback,
547      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
548    brillo::dbus_utils::CallMethodWithTimeout(
549        timeout_ms,
550        dbus_object_proxy_,
551        "org.chromium.SessionManagerInterface",
552        "StorePolicy",
553        success_callback,
554        error_callback,
555        in_policy_blob);
556  }
557
558  bool RetrievePolicy(
559      std::vector<uint8_t>* out_policy_blob,
560      brillo::ErrorPtr* error,
561      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
562    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
563        timeout_ms,
564        dbus_object_proxy_,
565        "org.chromium.SessionManagerInterface",
566        "RetrievePolicy",
567        error);
568    return response && brillo::dbus_utils::ExtractMethodCallResults(
569        response.get(), error, out_policy_blob);
570  }
571
572  void RetrievePolicyAsync(
573      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
574      const base::Callback<void(brillo::Error*)>& error_callback,
575      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
576    brillo::dbus_utils::CallMethodWithTimeout(
577        timeout_ms,
578        dbus_object_proxy_,
579        "org.chromium.SessionManagerInterface",
580        "RetrievePolicy",
581        success_callback,
582        error_callback);
583  }
584
585  bool StorePolicyForUser(
586      const std::string& in_user_email,
587      const std::vector<uint8_t>& in_policy_blob,
588      bool* out_done,
589      brillo::ErrorPtr* error,
590      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
591    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
592        timeout_ms,
593        dbus_object_proxy_,
594        "org.chromium.SessionManagerInterface",
595        "StorePolicyForUser",
596        error,
597        in_user_email,
598        in_policy_blob);
599    return response && brillo::dbus_utils::ExtractMethodCallResults(
600        response.get(), error, out_done);
601  }
602
603  void StorePolicyForUserAsync(
604      const std::string& in_user_email,
605      const std::vector<uint8_t>& in_policy_blob,
606      const base::Callback<void(bool /*done*/)>& success_callback,
607      const base::Callback<void(brillo::Error*)>& error_callback,
608      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
609    brillo::dbus_utils::CallMethodWithTimeout(
610        timeout_ms,
611        dbus_object_proxy_,
612        "org.chromium.SessionManagerInterface",
613        "StorePolicyForUser",
614        success_callback,
615        error_callback,
616        in_user_email,
617        in_policy_blob);
618  }
619
620  bool RetrievePolicyForUser(
621      const std::string& in_user_email,
622      std::vector<uint8_t>* out_policy_blob,
623      brillo::ErrorPtr* error,
624      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
625    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
626        timeout_ms,
627        dbus_object_proxy_,
628        "org.chromium.SessionManagerInterface",
629        "RetrievePolicyForUser",
630        error,
631        in_user_email);
632    return response && brillo::dbus_utils::ExtractMethodCallResults(
633        response.get(), error, out_policy_blob);
634  }
635
636  void RetrievePolicyForUserAsync(
637      const std::string& in_user_email,
638      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
639      const base::Callback<void(brillo::Error*)>& error_callback,
640      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
641    brillo::dbus_utils::CallMethodWithTimeout(
642        timeout_ms,
643        dbus_object_proxy_,
644        "org.chromium.SessionManagerInterface",
645        "RetrievePolicyForUser",
646        success_callback,
647        error_callback,
648        in_user_email);
649  }
650
651  bool StoreDeviceLocalAccountPolicy(
652      const std::string& in_account_id,
653      const std::vector<uint8_t>& in_policy_blob,
654      bool* out_done,
655      brillo::ErrorPtr* error,
656      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
657    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
658        timeout_ms,
659        dbus_object_proxy_,
660        "org.chromium.SessionManagerInterface",
661        "StoreDeviceLocalAccountPolicy",
662        error,
663        in_account_id,
664        in_policy_blob);
665    return response && brillo::dbus_utils::ExtractMethodCallResults(
666        response.get(), error, out_done);
667  }
668
669  void StoreDeviceLocalAccountPolicyAsync(
670      const std::string& in_account_id,
671      const std::vector<uint8_t>& in_policy_blob,
672      const base::Callback<void(bool /*done*/)>& success_callback,
673      const base::Callback<void(brillo::Error*)>& error_callback,
674      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
675    brillo::dbus_utils::CallMethodWithTimeout(
676        timeout_ms,
677        dbus_object_proxy_,
678        "org.chromium.SessionManagerInterface",
679        "StoreDeviceLocalAccountPolicy",
680        success_callback,
681        error_callback,
682        in_account_id,
683        in_policy_blob);
684  }
685
686  bool RetrieveDeviceLocalAccountPolicy(
687      const std::string& in_account_id,
688      std::vector<uint8_t>* out_policy_blob,
689      brillo::ErrorPtr* error,
690      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
691    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
692        timeout_ms,
693        dbus_object_proxy_,
694        "org.chromium.SessionManagerInterface",
695        "RetrieveDeviceLocalAccountPolicy",
696        error,
697        in_account_id);
698    return response && brillo::dbus_utils::ExtractMethodCallResults(
699        response.get(), error, out_policy_blob);
700  }
701
702  void RetrieveDeviceLocalAccountPolicyAsync(
703      const std::string& in_account_id,
704      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
705      const base::Callback<void(brillo::Error*)>& error_callback,
706      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
707    brillo::dbus_utils::CallMethodWithTimeout(
708        timeout_ms,
709        dbus_object_proxy_,
710        "org.chromium.SessionManagerInterface",
711        "RetrieveDeviceLocalAccountPolicy",
712        success_callback,
713        error_callback,
714        in_account_id);
715  }
716
717  bool RetrieveSessionState(
718      std::string* out_state,
719      brillo::ErrorPtr* error,
720      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
721    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
722        timeout_ms,
723        dbus_object_proxy_,
724        "org.chromium.SessionManagerInterface",
725        "RetrieveSessionState",
726        error);
727    return response && brillo::dbus_utils::ExtractMethodCallResults(
728        response.get(), error, out_state);
729  }
730
731  void RetrieveSessionStateAsync(
732      const base::Callback<void(const std::string& /*state*/)>& success_callback,
733      const base::Callback<void(brillo::Error*)>& error_callback,
734      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
735    brillo::dbus_utils::CallMethodWithTimeout(
736        timeout_ms,
737        dbus_object_proxy_,
738        "org.chromium.SessionManagerInterface",
739        "RetrieveSessionState",
740        success_callback,
741        error_callback);
742  }
743
744  bool RetrieveActiveSessions(
745      std::map<std::string, std::string>* out_sessions,
746      brillo::ErrorPtr* error,
747      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
748    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
749        timeout_ms,
750        dbus_object_proxy_,
751        "org.chromium.SessionManagerInterface",
752        "RetrieveActiveSessions",
753        error);
754    return response && brillo::dbus_utils::ExtractMethodCallResults(
755        response.get(), error, out_sessions);
756  }
757
758  void RetrieveActiveSessionsAsync(
759      const base::Callback<void(const std::map<std::string, std::string>& /*sessions*/)>& success_callback,
760      const base::Callback<void(brillo::Error*)>& error_callback,
761      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
762    brillo::dbus_utils::CallMethodWithTimeout(
763        timeout_ms,
764        dbus_object_proxy_,
765        "org.chromium.SessionManagerInterface",
766        "RetrieveActiveSessions",
767        success_callback,
768        error_callback);
769  }
770
771  bool HandleSupervisedUserCreationStarting(
772      brillo::ErrorPtr* error,
773      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
774    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
775        timeout_ms,
776        dbus_object_proxy_,
777        "org.chromium.SessionManagerInterface",
778        "HandleSupervisedUserCreationStarting",
779        error);
780    return response && brillo::dbus_utils::ExtractMethodCallResults(
781        response.get(), error);
782  }
783
784  void HandleSupervisedUserCreationStartingAsync(
785      const base::Callback<void()>& success_callback,
786      const base::Callback<void(brillo::Error*)>& error_callback,
787      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
788    brillo::dbus_utils::CallMethodWithTimeout(
789        timeout_ms,
790        dbus_object_proxy_,
791        "org.chromium.SessionManagerInterface",
792        "HandleSupervisedUserCreationStarting",
793        success_callback,
794        error_callback);
795  }
796
797  bool HandleSupervisedUserCreationFinished(
798      brillo::ErrorPtr* error,
799      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
800    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
801        timeout_ms,
802        dbus_object_proxy_,
803        "org.chromium.SessionManagerInterface",
804        "HandleSupervisedUserCreationFinished",
805        error);
806    return response && brillo::dbus_utils::ExtractMethodCallResults(
807        response.get(), error);
808  }
809
810  void HandleSupervisedUserCreationFinishedAsync(
811      const base::Callback<void()>& success_callback,
812      const base::Callback<void(brillo::Error*)>& error_callback,
813      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
814    brillo::dbus_utils::CallMethodWithTimeout(
815        timeout_ms,
816        dbus_object_proxy_,
817        "org.chromium.SessionManagerInterface",
818        "HandleSupervisedUserCreationFinished",
819        success_callback,
820        error_callback);
821  }
822
823  bool LockScreen(
824      brillo::ErrorPtr* error,
825      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
826    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
827        timeout_ms,
828        dbus_object_proxy_,
829        "org.chromium.SessionManagerInterface",
830        "LockScreen",
831        error);
832    return response && brillo::dbus_utils::ExtractMethodCallResults(
833        response.get(), error);
834  }
835
836  void LockScreenAsync(
837      const base::Callback<void()>& success_callback,
838      const base::Callback<void(brillo::Error*)>& error_callback,
839      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
840    brillo::dbus_utils::CallMethodWithTimeout(
841        timeout_ms,
842        dbus_object_proxy_,
843        "org.chromium.SessionManagerInterface",
844        "LockScreen",
845        success_callback,
846        error_callback);
847  }
848
849  bool HandleLockScreenShown(
850      brillo::ErrorPtr* error,
851      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
852    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
853        timeout_ms,
854        dbus_object_proxy_,
855        "org.chromium.SessionManagerInterface",
856        "HandleLockScreenShown",
857        error);
858    return response && brillo::dbus_utils::ExtractMethodCallResults(
859        response.get(), error);
860  }
861
862  void HandleLockScreenShownAsync(
863      const base::Callback<void()>& success_callback,
864      const base::Callback<void(brillo::Error*)>& error_callback,
865      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
866    brillo::dbus_utils::CallMethodWithTimeout(
867        timeout_ms,
868        dbus_object_proxy_,
869        "org.chromium.SessionManagerInterface",
870        "HandleLockScreenShown",
871        success_callback,
872        error_callback);
873  }
874
875  bool HandleLockScreenDismissed(
876      brillo::ErrorPtr* error,
877      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
878    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
879        timeout_ms,
880        dbus_object_proxy_,
881        "org.chromium.SessionManagerInterface",
882        "HandleLockScreenDismissed",
883        error);
884    return response && brillo::dbus_utils::ExtractMethodCallResults(
885        response.get(), error);
886  }
887
888  void HandleLockScreenDismissedAsync(
889      const base::Callback<void()>& success_callback,
890      const base::Callback<void(brillo::Error*)>& error_callback,
891      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
892    brillo::dbus_utils::CallMethodWithTimeout(
893        timeout_ms,
894        dbus_object_proxy_,
895        "org.chromium.SessionManagerInterface",
896        "HandleLockScreenDismissed",
897        success_callback,
898        error_callback);
899  }
900
901  bool RestartJob(
902      const dbus::FileDescriptor& in_cred_fd,
903      const std::vector<std::string>& in_argv,
904      brillo::ErrorPtr* error,
905      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
906    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
907        timeout_ms,
908        dbus_object_proxy_,
909        "org.chromium.SessionManagerInterface",
910        "RestartJob",
911        error,
912        in_cred_fd,
913        in_argv);
914    return response && brillo::dbus_utils::ExtractMethodCallResults(
915        response.get(), error);
916  }
917
918  void RestartJobAsync(
919      const dbus::FileDescriptor& in_cred_fd,
920      const std::vector<std::string>& in_argv,
921      const base::Callback<void()>& success_callback,
922      const base::Callback<void(brillo::Error*)>& error_callback,
923      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
924    brillo::dbus_utils::CallMethodWithTimeout(
925        timeout_ms,
926        dbus_object_proxy_,
927        "org.chromium.SessionManagerInterface",
928        "RestartJob",
929        success_callback,
930        error_callback,
931        in_cred_fd,
932        in_argv);
933  }
934
935  bool StartDeviceWipe(
936      bool* out_done,
937      brillo::ErrorPtr* error,
938      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
939    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
940        timeout_ms,
941        dbus_object_proxy_,
942        "org.chromium.SessionManagerInterface",
943        "StartDeviceWipe",
944        error);
945    return response && brillo::dbus_utils::ExtractMethodCallResults(
946        response.get(), error, out_done);
947  }
948
949  void StartDeviceWipeAsync(
950      const base::Callback<void(bool /*done*/)>& success_callback,
951      const base::Callback<void(brillo::Error*)>& error_callback,
952      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
953    brillo::dbus_utils::CallMethodWithTimeout(
954        timeout_ms,
955        dbus_object_proxy_,
956        "org.chromium.SessionManagerInterface",
957        "StartDeviceWipe",
958        success_callback,
959        error_callback);
960  }
961
962  bool SetFlagsForUser(
963      const std::string& in_user_email,
964      const std::vector<std::string>& in_flags,
965      brillo::ErrorPtr* error,
966      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
967    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
968        timeout_ms,
969        dbus_object_proxy_,
970        "org.chromium.SessionManagerInterface",
971        "SetFlagsForUser",
972        error,
973        in_user_email,
974        in_flags);
975    return response && brillo::dbus_utils::ExtractMethodCallResults(
976        response.get(), error);
977  }
978
979  void SetFlagsForUserAsync(
980      const std::string& in_user_email,
981      const std::vector<std::string>& in_flags,
982      const base::Callback<void()>& success_callback,
983      const base::Callback<void(brillo::Error*)>& error_callback,
984      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
985    brillo::dbus_utils::CallMethodWithTimeout(
986        timeout_ms,
987        dbus_object_proxy_,
988        "org.chromium.SessionManagerInterface",
989        "SetFlagsForUser",
990        success_callback,
991        error_callback,
992        in_user_email,
993        in_flags);
994  }
995
996  bool GetServerBackedStateKeys(
997      std::vector<std::vector<uint8_t>>* out_state_keys,
998      brillo::ErrorPtr* error,
999      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1000    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
1001        timeout_ms,
1002        dbus_object_proxy_,
1003        "org.chromium.SessionManagerInterface",
1004        "GetServerBackedStateKeys",
1005        error);
1006    return response && brillo::dbus_utils::ExtractMethodCallResults(
1007        response.get(), error, out_state_keys);
1008  }
1009
1010  void GetServerBackedStateKeysAsync(
1011      const base::Callback<void(const std::vector<std::vector<uint8_t>>& /*state_keys*/)>& success_callback,
1012      const base::Callback<void(brillo::Error*)>& error_callback,
1013      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1014    brillo::dbus_utils::CallMethodWithTimeout(
1015        timeout_ms,
1016        dbus_object_proxy_,
1017        "org.chromium.SessionManagerInterface",
1018        "GetServerBackedStateKeys",
1019        success_callback,
1020        error_callback);
1021  }
1022
1023  bool InitMachineInfo(
1024      const std::string& in_data,
1025      brillo::ErrorPtr* error,
1026      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1027    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
1028        timeout_ms,
1029        dbus_object_proxy_,
1030        "org.chromium.SessionManagerInterface",
1031        "InitMachineInfo",
1032        error,
1033        in_data);
1034    return response && brillo::dbus_utils::ExtractMethodCallResults(
1035        response.get(), error);
1036  }
1037
1038  void InitMachineInfoAsync(
1039      const std::string& in_data,
1040      const base::Callback<void()>& success_callback,
1041      const base::Callback<void(brillo::Error*)>& error_callback,
1042      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
1043    brillo::dbus_utils::CallMethodWithTimeout(
1044        timeout_ms,
1045        dbus_object_proxy_,
1046        "org.chromium.SessionManagerInterface",
1047        "InitMachineInfo",
1048        success_callback,
1049        error_callback,
1050        in_data);
1051  }
1052
1053 private:
1054  scoped_refptr<dbus::Bus> bus_;
1055  const std::string service_name_{"org.chromium.SessionManager"};
1056  const dbus::ObjectPath object_path_{"/org/chromium/SessionManager"};
1057  dbus::ObjectProxy* dbus_object_proxy_;
1058
1059  DISALLOW_COPY_AND_ASSIGN(SessionManagerInterfaceProxy);
1060};
1061
1062}  // namespace chromium
1063}  // namespace org
1064
1065#endif  // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXIES_H
1066