include/session_manager/dbus-proxies.h

// Automatic generation of D-Bus interfaces:
//  - org.chromium.SessionManagerInterface
#ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXIES_H
#define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXIES_H
#include <memory>
#include <string>
#include <vector>

#include <base/bind.h>
#include <base/callback.h>
#include <base/logging.h>
#include <base/macros.h>
#include <base/memory/ref_counted.h>
#include <brillo/any.h>
#include <brillo/dbus/dbus_method_invoker.h>
#include <brillo/dbus/dbus_property.h>
#include <brillo/dbus/dbus_signal_handler.h>
#include <brillo/errors/error.h>
#include <brillo/variant_dictionary.h>
#include <dbus/bus.h>
#include <dbus/message.h>
#include <dbus/object_manager.h>
#include <dbus/object_path.h>
#include <dbus/object_proxy.h>

namespace org {
namespace chromium {

// Abstract interface proxy for org::chromium::SessionManagerInterface.
class SessionManagerInterfaceProxyInterface {
 public:
  virtual ~SessionManagerInterfaceProxyInterface() = default;

  virtual bool EmitLoginPromptVisible(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void EmitLoginPromptVisibleAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool EnableChromeTesting(
      bool in_force_relaunch,
      const std::vector<std::string>& in_extra_arguments,
      std::string* out_filepath,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void EnableChromeTestingAsync(
      bool in_force_relaunch,
      const std::vector<std::string>& in_extra_arguments,
      const base::Callback<void(const std::string& /*filepath*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool StartSession(
      const std::string& in_email_address,
      const std::string& in_unique_identifier,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void StartSessionAsync(
      const std::string& in_email_address,
      const std::string& in_unique_identifier,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool StopSession(
      const std::string& in_unique_identifier,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void StopSessionAsync(
      const std::string& in_unique_identifier,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool StorePolicy(
      const std::vector<uint8_t>& in_policy_blob,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void StorePolicyAsync(
      const std::vector<uint8_t>& in_policy_blob,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool RetrievePolicy(
      std::vector<uint8_t>* out_policy_blob,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void RetrievePolicyAsync(
      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool StorePolicyForUser(
      const std::string& in_user_email,
      const std::vector<uint8_t>& in_policy_blob,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void StorePolicyForUserAsync(
      const std::string& in_user_email,
      const std::vector<uint8_t>& in_policy_blob,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool RetrievePolicyForUser(
      const std::string& in_user_email,
      std::vector<uint8_t>* out_policy_blob,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void RetrievePolicyForUserAsync(
      const std::string& in_user_email,
      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool StoreDeviceLocalAccountPolicy(
      const std::string& in_account_id,
      const std::vector<uint8_t>& in_policy_blob,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void StoreDeviceLocalAccountPolicyAsync(
      const std::string& in_account_id,
      const std::vector<uint8_t>& in_policy_blob,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool RetrieveDeviceLocalAccountPolicy(
      const std::string& in_account_id,
      std::vector<uint8_t>* out_policy_blob,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void RetrieveDeviceLocalAccountPolicyAsync(
      const std::string& in_account_id,
      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool RetrieveSessionState(
      std::string* out_state,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void RetrieveSessionStateAsync(
      const base::Callback<void(const std::string& /*state*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool RetrieveActiveSessions(
      std::map<std::string, std::string>* out_sessions,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void RetrieveActiveSessionsAsync(
      const base::Callback<void(const std::map<std::string, std::string>& /*sessions*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool HandleSupervisedUserCreationStarting(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void HandleSupervisedUserCreationStartingAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool HandleSupervisedUserCreationFinished(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void HandleSupervisedUserCreationFinishedAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool LockScreen(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void LockScreenAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool HandleLockScreenShown(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void HandleLockScreenShownAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool HandleLockScreenDismissed(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void HandleLockScreenDismissedAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool RestartJob(
      const dbus::FileDescriptor& in_cred_fd,
      const std::vector<std::string>& in_argv,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void RestartJobAsync(
      const dbus::FileDescriptor& in_cred_fd,
      const std::vector<std::string>& in_argv,
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool StartDeviceWipe(
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void StartDeviceWipeAsync(
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool SetFlagsForUser(
      const std::string& in_user_email,
      const std::vector<std::string>& in_flags,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void SetFlagsForUserAsync(
      const std::string& in_user_email,
      const std::vector<std::string>& in_flags,
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool GetServerBackedStateKeys(
      std::vector<std::vector<uint8_t>>* out_state_keys,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void GetServerBackedStateKeysAsync(
      const base::Callback<void(const std::vector<std::vector<uint8_t>>& /*state_keys*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual bool InitMachineInfo(
      const std::string& in_data,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void InitMachineInfoAsync(
      const std::string& in_data,
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;

  virtual void RegisterLoginPromptVisibleSignalHandler(
      const base::Closure& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;

  virtual void RegisterSessionStateChangedSignalHandler(
      const base::Callback<void(const std::string&)>& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;

  virtual void RegisterSetOwnerKeyCompleteSignalHandler(
      const base::Callback<void(const std::string&)>& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;

  virtual void RegisterPropertyChangeCompleteSignalHandler(
      const base::Callback<void(const std::string&)>& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;

  virtual void RegisterScreenIsLockedSignalHandler(
      const base::Closure& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;

  virtual void RegisterScreenIsUnlockedSignalHandler(
      const base::Closure& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
};

}  // namespace chromium
}  // namespace org

namespace org {
namespace chromium {

// Interface proxy for org::chromium::SessionManagerInterface.
class SessionManagerInterfaceProxy final : public SessionManagerInterfaceProxyInterface {
 public:
  SessionManagerInterfaceProxy(const scoped_refptr<dbus::Bus>& bus) :
      bus_{bus},
      dbus_object_proxy_{
          bus_->GetObjectProxy(service_name_, object_path_)} {
  }

  ~SessionManagerInterfaceProxy() override {
    bus_->RemoveObjectProxy(
        service_name_, object_path_, base::Bind(&base::DoNothing));
  }

  void RegisterLoginPromptVisibleSignalHandler(
      const base::Closure& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
    brillo::dbus_utils::ConnectToSignal(
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "LoginPromptVisible",
        signal_callback,
        on_connected_callback);
  }

  void RegisterSessionStateChangedSignalHandler(
      const base::Callback<void(const std::string&)>& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
    brillo::dbus_utils::ConnectToSignal(
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "SessionStateChanged",
        signal_callback,
        on_connected_callback);
  }

  void RegisterSetOwnerKeyCompleteSignalHandler(
      const base::Callback<void(const std::string&)>& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
    brillo::dbus_utils::ConnectToSignal(
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "SetOwnerKeyComplete",
        signal_callback,
        on_connected_callback);
  }

  void RegisterPropertyChangeCompleteSignalHandler(
      const base::Callback<void(const std::string&)>& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
    brillo::dbus_utils::ConnectToSignal(
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "PropertyChangeComplete",
        signal_callback,
        on_connected_callback);
  }

  void RegisterScreenIsLockedSignalHandler(
      const base::Closure& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
    brillo::dbus_utils::ConnectToSignal(
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "ScreenIsLocked",
        signal_callback,
        on_connected_callback);
  }

  void RegisterScreenIsUnlockedSignalHandler(
      const base::Closure& signal_callback,
      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
    brillo::dbus_utils::ConnectToSignal(
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "ScreenIsUnlocked",
        signal_callback,
        on_connected_callback);
  }

  void ReleaseObjectProxy(const base::Closure& callback) {
    bus_->RemoveObjectProxy(service_name_, object_path_, callback);
  }

  const dbus::ObjectPath& GetObjectPath() const {
    return object_path_;
  }

  dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }

  bool EmitLoginPromptVisible(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "EmitLoginPromptVisible",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error);
  }

  void EmitLoginPromptVisibleAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "EmitLoginPromptVisible",
        success_callback,
        error_callback);
  }

  bool EnableChromeTesting(
      bool in_force_relaunch,
      const std::vector<std::string>& in_extra_arguments,
      std::string* out_filepath,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "EnableChromeTesting",
        error,
        in_force_relaunch,
        in_extra_arguments);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_filepath);
  }

  void EnableChromeTestingAsync(
      bool in_force_relaunch,
      const std::vector<std::string>& in_extra_arguments,
      const base::Callback<void(const std::string& /*filepath*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "EnableChromeTesting",
        success_callback,
        error_callback,
        in_force_relaunch,
        in_extra_arguments);
  }

  bool StartSession(
      const std::string& in_email_address,
      const std::string& in_unique_identifier,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StartSession",
        error,
        in_email_address,
        in_unique_identifier);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_done);
  }

  void StartSessionAsync(
      const std::string& in_email_address,
      const std::string& in_unique_identifier,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StartSession",
        success_callback,
        error_callback,
        in_email_address,
        in_unique_identifier);
  }

  bool StopSession(
      const std::string& in_unique_identifier,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StopSession",
        error,
        in_unique_identifier);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_done);
  }

  void StopSessionAsync(
      const std::string& in_unique_identifier,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StopSession",
        success_callback,
        error_callback,
        in_unique_identifier);
  }

  bool StorePolicy(
      const std::vector<uint8_t>& in_policy_blob,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StorePolicy",
        error,
        in_policy_blob);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_done);
  }

  void StorePolicyAsync(
      const std::vector<uint8_t>& in_policy_blob,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StorePolicy",
        success_callback,
        error_callback,
        in_policy_blob);
  }

  bool RetrievePolicy(
      std::vector<uint8_t>* out_policy_blob,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrievePolicy",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_policy_blob);
  }

  void RetrievePolicyAsync(
      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrievePolicy",
        success_callback,
        error_callback);
  }

  bool StorePolicyForUser(
      const std::string& in_user_email,
      const std::vector<uint8_t>& in_policy_blob,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StorePolicyForUser",
        error,
        in_user_email,
        in_policy_blob);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_done);
  }

  void StorePolicyForUserAsync(
      const std::string& in_user_email,
      const std::vector<uint8_t>& in_policy_blob,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StorePolicyForUser",
        success_callback,
        error_callback,
        in_user_email,
        in_policy_blob);
  }

  bool RetrievePolicyForUser(
      const std::string& in_user_email,
      std::vector<uint8_t>* out_policy_blob,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrievePolicyForUser",
        error,
        in_user_email);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_policy_blob);
  }

  void RetrievePolicyForUserAsync(
      const std::string& in_user_email,
      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrievePolicyForUser",
        success_callback,
        error_callback,
        in_user_email);
  }

  bool StoreDeviceLocalAccountPolicy(
      const std::string& in_account_id,
      const std::vector<uint8_t>& in_policy_blob,
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StoreDeviceLocalAccountPolicy",
        error,
        in_account_id,
        in_policy_blob);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_done);
  }

  void StoreDeviceLocalAccountPolicyAsync(
      const std::string& in_account_id,
      const std::vector<uint8_t>& in_policy_blob,
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StoreDeviceLocalAccountPolicy",
        success_callback,
        error_callback,
        in_account_id,
        in_policy_blob);
  }

  bool RetrieveDeviceLocalAccountPolicy(
      const std::string& in_account_id,
      std::vector<uint8_t>* out_policy_blob,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrieveDeviceLocalAccountPolicy",
        error,
        in_account_id);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_policy_blob);
  }

  void RetrieveDeviceLocalAccountPolicyAsync(
      const std::string& in_account_id,
      const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrieveDeviceLocalAccountPolicy",
        success_callback,
        error_callback,
        in_account_id);
  }

  bool RetrieveSessionState(
      std::string* out_state,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrieveSessionState",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_state);
  }

  void RetrieveSessionStateAsync(
      const base::Callback<void(const std::string& /*state*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrieveSessionState",
        success_callback,
        error_callback);
  }

  bool RetrieveActiveSessions(
      std::map<std::string, std::string>* out_sessions,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrieveActiveSessions",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_sessions);
  }

  void RetrieveActiveSessionsAsync(
      const base::Callback<void(const std::map<std::string, std::string>& /*sessions*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RetrieveActiveSessions",
        success_callback,
        error_callback);
  }

  bool HandleSupervisedUserCreationStarting(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "HandleSupervisedUserCreationStarting",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error);
  }

  void HandleSupervisedUserCreationStartingAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "HandleSupervisedUserCreationStarting",
        success_callback,
        error_callback);
  }

  bool HandleSupervisedUserCreationFinished(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "HandleSupervisedUserCreationFinished",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error);
  }

  void HandleSupervisedUserCreationFinishedAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "HandleSupervisedUserCreationFinished",
        success_callback,
        error_callback);
  }

  bool LockScreen(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "LockScreen",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error);
  }

  void LockScreenAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "LockScreen",
        success_callback,
        error_callback);
  }

  bool HandleLockScreenShown(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "HandleLockScreenShown",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error);
  }

  void HandleLockScreenShownAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "HandleLockScreenShown",
        success_callback,
        error_callback);
  }

  bool HandleLockScreenDismissed(
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "HandleLockScreenDismissed",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error);
  }

  void HandleLockScreenDismissedAsync(
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "HandleLockScreenDismissed",
        success_callback,
        error_callback);
  }

  bool RestartJob(
      const dbus::FileDescriptor& in_cred_fd,
      const std::vector<std::string>& in_argv,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RestartJob",
        error,
        in_cred_fd,
        in_argv);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error);
  }

  void RestartJobAsync(
      const dbus::FileDescriptor& in_cred_fd,
      const std::vector<std::string>& in_argv,
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "RestartJob",
        success_callback,
        error_callback,
        in_cred_fd,
        in_argv);
  }

  bool StartDeviceWipe(
      bool* out_done,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StartDeviceWipe",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_done);
  }

  void StartDeviceWipeAsync(
      const base::Callback<void(bool /*done*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "StartDeviceWipe",
        success_callback,
        error_callback);
  }

  bool SetFlagsForUser(
      const std::string& in_user_email,
      const std::vector<std::string>& in_flags,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "SetFlagsForUser",
        error,
        in_user_email,
        in_flags);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error);
  }

  void SetFlagsForUserAsync(
      const std::string& in_user_email,
      const std::vector<std::string>& in_flags,
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "SetFlagsForUser",
        success_callback,
        error_callback,
        in_user_email,
        in_flags);
  }

  bool GetServerBackedStateKeys(
      std::vector<std::vector<uint8_t>>* out_state_keys,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "GetServerBackedStateKeys",
        error);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error, out_state_keys);
  }

  void GetServerBackedStateKeysAsync(
      const base::Callback<void(const std::vector<std::vector<uint8_t>>& /*state_keys*/)>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "GetServerBackedStateKeys",
        success_callback,
        error_callback);
  }

  bool InitMachineInfo(
      const std::string& in_data,
      brillo::ErrorPtr* error,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "InitMachineInfo",
        error,
        in_data);
    return response && brillo::dbus_utils::ExtractMethodCallResults(
        response.get(), error);
  }

  void InitMachineInfoAsync(
      const std::string& in_data,
      const base::Callback<void()>& success_callback,
      const base::Callback<void(brillo::Error*)>& error_callback,
      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
    brillo::dbus_utils::CallMethodWithTimeout(
        timeout_ms,
        dbus_object_proxy_,
        "org.chromium.SessionManagerInterface",
        "InitMachineInfo",
        success_callback,
        error_callback,
        in_data);
  }

 private:
  scoped_refptr<dbus::Bus> bus_;
  const std::string service_name_{"org.chromium.SessionManager"};
  const dbus::ObjectPath object_path_{"/org/chromium/SessionManager"};
  dbus::ObjectProxy* dbus_object_proxy_;

  DISALLOW_COPY_AND_ASSIGN(SessionManagerInterfaceProxy);
};

}  // namespace chromium
}  // namespace org

#endif  // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXIES_H