diff --git a/include/session_manager/dbus-proxies.h b/include/session_manager/dbus-proxies.h
new file mode 100644
index 0000000..f3424f8
--- /dev/null
+++ b/include/session_manager/dbus-proxies.h
@@ -0,0 +1,1065 @@
+// 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 <chromeos/any.h>
+#include <chromeos/dbus/dbus_method_invoker.h>
+#include <chromeos/dbus/dbus_property.h>
+#include <chromeos/dbus/dbus_signal_handler.h>
+#include <chromeos/errors/error.h>
+#include <chromeos/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(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void EmitLoginPromptVisibleAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::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,
+      chromeos::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(chromeos::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,
+      chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool StopSession(
+      const std::string& in_unique_identifier,
+      bool* out_done,
+      chromeos::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(chromeos::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,
+      chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool RetrievePolicy(
+      std::vector<uint8_t>* out_policy_blob,
+      chromeos::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(chromeos::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,
+      chromeos::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(chromeos::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,
+      chromeos::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(chromeos::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,
+      chromeos::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(chromeos::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,
+      chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool RetrieveSessionState(
+      std::string* out_state,
+      chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool RetrieveActiveSessions(
+      std::map<std::string, std::string>* out_sessions,
+      chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool HandleSupervisedUserCreationStarting(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void HandleSupervisedUserCreationStartingAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool HandleSupervisedUserCreationFinished(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void HandleSupervisedUserCreationFinishedAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool LockScreen(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void LockScreenAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool HandleLockScreenShown(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void HandleLockScreenShownAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool HandleLockScreenDismissed(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void HandleLockScreenDismissedAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::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,
+      chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool StartDeviceWipe(
+      bool* out_done,
+      chromeos::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(chromeos::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,
+      chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool GetServerBackedStateKeys(
+      std::vector<std::vector<uint8_t>>* out_state_keys,
+      chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool InitMachineInfo(
+      const std::string& in_data,
+      chromeos::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(chromeos::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 {
+    chromeos::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 {
+    chromeos::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 {
+    chromeos::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 {
+    chromeos::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 {
+    chromeos::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 {
+    chromeos::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(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "EmitLoginPromptVisible",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void EmitLoginPromptVisibleAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "EnableChromeTesting",
+        error,
+        in_force_relaunch,
+        in_extra_arguments);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "StartSession",
+        error,
+        in_email_address,
+        in_unique_identifier);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "StopSession",
+        error,
+        in_unique_identifier);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "StorePolicy",
+        error,
+        in_policy_blob);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "RetrievePolicy",
+        error);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "StorePolicyForUser",
+        error,
+        in_user_email,
+        in_policy_blob);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "RetrievePolicyForUser",
+        error,
+        in_user_email);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "StoreDeviceLocalAccountPolicy",
+        error,
+        in_account_id,
+        in_policy_blob);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "RetrieveDeviceLocalAccountPolicy",
+        error,
+        in_account_id);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "RetrieveSessionState",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_state);
+  }
+
+  void RetrieveSessionStateAsync(
+      const base::Callback<void(const std::string& /*state*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "RetrieveActiveSessions",
+        error);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::dbus_utils::CallMethodWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "RetrieveActiveSessions",
+        success_callback,
+        error_callback);
+  }
+
+  bool HandleSupervisedUserCreationStarting(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "HandleSupervisedUserCreationStarting",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void HandleSupervisedUserCreationStartingAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::dbus_utils::CallMethodWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "HandleSupervisedUserCreationStarting",
+        success_callback,
+        error_callback);
+  }
+
+  bool HandleSupervisedUserCreationFinished(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "HandleSupervisedUserCreationFinished",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void HandleSupervisedUserCreationFinishedAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::dbus_utils::CallMethodWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "HandleSupervisedUserCreationFinished",
+        success_callback,
+        error_callback);
+  }
+
+  bool LockScreen(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "LockScreen",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void LockScreenAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::dbus_utils::CallMethodWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "LockScreen",
+        success_callback,
+        error_callback);
+  }
+
+  bool HandleLockScreenShown(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "HandleLockScreenShown",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void HandleLockScreenShownAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::dbus_utils::CallMethodWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "HandleLockScreenShown",
+        success_callback,
+        error_callback);
+  }
+
+  bool HandleLockScreenDismissed(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "HandleLockScreenDismissed",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void HandleLockScreenDismissedAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "RestartJob",
+        error,
+        in_cred_fd,
+        in_argv);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "StartDeviceWipe",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_done);
+  }
+
+  void StartDeviceWipeAsync(
+      const base::Callback<void(bool /*done*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "SetFlagsForUser",
+        error,
+        in_user_email,
+        in_flags);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "GetServerBackedStateKeys",
+        error);
+    return response && chromeos::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(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::dbus_utils::CallMethodWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "GetServerBackedStateKeys",
+        success_callback,
+        error_callback);
+  }
+
+  bool InitMachineInfo(
+      const std::string& in_data,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+        timeout_ms,
+        dbus_object_proxy_,
+        "org.chromium.SessionManagerInterface",
+        "InitMachineInfo",
+        error,
+        in_data);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void InitMachineInfoAsync(
+      const std::string& in_data,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
+    chromeos::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
diff --git a/include/session_manager/dbus-proxy-mocks.h b/include/session_manager/dbus-proxy-mocks.h
new file mode 100644
index 0000000..af9bcf5
--- /dev/null
+++ b/include/session_manager/dbus-proxy-mocks.h
@@ -0,0 +1,252 @@
+// Automatic generation of D-Bus interface mock proxies for:
+//  - org.chromium.SessionManagerInterface
+#ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXY_MOCKS_H
+#define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXY_MOCKS_H
+#include <string>
+#include <vector>
+
+#include <base/callback_forward.h>
+#include <base/logging.h>
+#include <base/macros.h>
+#include <chromeos/any.h>
+#include <chromeos/errors/error.h>
+#include <chromeos/variant_dictionary.h>
+#include <gmock/gmock.h>
+
+#include "session_manager/dbus-proxies.h"
+
+namespace org {
+namespace chromium {
+
+// Mock object for SessionManagerInterfaceProxyInterface.
+class SessionManagerInterfaceProxyMock : public SessionManagerInterfaceProxyInterface {
+ public:
+  SessionManagerInterfaceProxyMock() = default;
+
+  MOCK_METHOD2(EmitLoginPromptVisible,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(EmitLoginPromptVisibleAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(EnableChromeTesting,
+               bool(bool /*in_force_relaunch*/,
+                    const std::vector<std::string>& /*in_extra_arguments*/,
+                    std::string* /*out_filepath*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(EnableChromeTestingAsync,
+               void(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(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(StartSession,
+               bool(const std::string& /*in_email_address*/,
+                    const std::string& /*in_unique_identifier*/,
+                    bool* /*out_done*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(StartSessionAsync,
+               void(const std::string& /*in_email_address*/,
+                    const std::string& /*in_unique_identifier*/,
+                    const base::Callback<void(bool /*done*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(StopSession,
+               bool(const std::string& /*in_unique_identifier*/,
+                    bool* /*out_done*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(StopSessionAsync,
+               void(const std::string& /*in_unique_identifier*/,
+                    const base::Callback<void(bool /*done*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(StorePolicy,
+               bool(const std::vector<uint8_t>& /*in_policy_blob*/,
+                    bool* /*out_done*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(StorePolicyAsync,
+               void(const std::vector<uint8_t>& /*in_policy_blob*/,
+                    const base::Callback<void(bool /*done*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RetrievePolicy,
+               bool(std::vector<uint8_t>* /*out_policy_blob*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RetrievePolicyAsync,
+               void(const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(StorePolicyForUser,
+               bool(const std::string& /*in_user_email*/,
+                    const std::vector<uint8_t>& /*in_policy_blob*/,
+                    bool* /*out_done*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(StorePolicyForUserAsync,
+               void(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(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RetrievePolicyForUser,
+               bool(const std::string& /*in_user_email*/,
+                    std::vector<uint8_t>* /*out_policy_blob*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RetrievePolicyForUserAsync,
+               void(const std::string& /*in_user_email*/,
+                    const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(StoreDeviceLocalAccountPolicy,
+               bool(const std::string& /*in_account_id*/,
+                    const std::vector<uint8_t>& /*in_policy_blob*/,
+                    bool* /*out_done*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(StoreDeviceLocalAccountPolicyAsync,
+               void(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(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RetrieveDeviceLocalAccountPolicy,
+               bool(const std::string& /*in_account_id*/,
+                    std::vector<uint8_t>* /*out_policy_blob*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RetrieveDeviceLocalAccountPolicyAsync,
+               void(const std::string& /*in_account_id*/,
+                    const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RetrieveSessionState,
+               bool(std::string* /*out_state*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RetrieveSessionStateAsync,
+               void(const base::Callback<void(const std::string& /*state*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RetrieveActiveSessions,
+               bool(std::map<std::string, std::string>* /*out_sessions*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RetrieveActiveSessionsAsync,
+               void(const base::Callback<void(const std::map<std::string, std::string>& /*sessions*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(HandleSupervisedUserCreationStarting,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(HandleSupervisedUserCreationStartingAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(HandleSupervisedUserCreationFinished,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(HandleSupervisedUserCreationFinishedAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(LockScreen,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(LockScreenAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(HandleLockScreenShown,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(HandleLockScreenShownAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(HandleLockScreenDismissed,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(HandleLockScreenDismissedAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RestartJob,
+               bool(const dbus::FileDescriptor& /*in_cred_fd*/,
+                    const std::vector<std::string>& /*in_argv*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(RestartJobAsync,
+               void(const dbus::FileDescriptor& /*in_cred_fd*/,
+                    const std::vector<std::string>& /*in_argv*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(StartDeviceWipe,
+               bool(bool* /*out_done*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(StartDeviceWipeAsync,
+               void(const base::Callback<void(bool /*done*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetFlagsForUser,
+               bool(const std::string& /*in_user_email*/,
+                    const std::vector<std::string>& /*in_flags*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(SetFlagsForUserAsync,
+               void(const std::string& /*in_user_email*/,
+                    const std::vector<std::string>& /*in_flags*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetServerBackedStateKeys,
+               bool(std::vector<std::vector<uint8_t>>* /*out_state_keys*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetServerBackedStateKeysAsync,
+               void(const base::Callback<void(const std::vector<std::vector<uint8_t>>& /*state_keys*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(InitMachineInfo,
+               bool(const std::string& /*in_data*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(InitMachineInfoAsync,
+               void(const std::string& /*in_data*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RegisterLoginPromptVisibleSignalHandler,
+               void(const base::Closure& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterSessionStateChangedSignalHandler,
+               void(const base::Callback<void(const std::string&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterSetOwnerKeyCompleteSignalHandler,
+               void(const base::Callback<void(const std::string&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterPropertyChangeCompleteSignalHandler,
+               void(const base::Callback<void(const std::string&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterScreenIsLockedSignalHandler,
+               void(const base::Closure& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterScreenIsUnlockedSignalHandler,
+               void(const base::Closure& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SessionManagerInterfaceProxyMock);
+};
+}  // namespace chromium
+}  // namespace org
+
+#endif  // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXY_MOCKS_H