diff --git a/include/debugd/dbus-constants.h b/include/debugd/dbus-constants.h
new file mode 100644
index 0000000..3427a99
--- /dev/null
+++ b/include/debugd/dbus-constants.h
@@ -0,0 +1,56 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SYSTEM_API_DBUS_DEBUGD_DBUS_CONSTANTS_H_
+#define SYSTEM_API_DBUS_DEBUGD_DBUS_CONSTANTS_H_
+
+namespace debugd {
+const char kDebugdInterface[] = "org.chromium.debugd";
+const char kDebugdServicePath[] = "/org/chromium/debugd";
+const char kDebugdServiceName[] = "org.chromium.debugd";
+
+// Methods.
+const char kDumpDebugLogs[] = "DumpDebugLogs";
+const char kGetDebugLogs[] = "GetDebugLogs";
+const char kGetInterfaces[] = "GetInterfaces";
+const char kGetModemStatus[] = "GetModemStatus";
+const char kGetNetworkStatus[] = "GetNetworkStatus";
+const char kGetPerfOutput[] = "GetPerfOutput";
+const char kGetRandomPerfOutput[] = "GetRandomPerfOutput";
+const char kGetRichPerfData[] = "GetRichPerfData";
+const char kGetRoutes[] = "GetRoutes";
+const char kGetWiMaxStatus[] = "GetWiMaxStatus";
+const char kSetDebugMode[] = "SetDebugMode";
+const char kSystraceStart[] = "SystraceStart";
+const char kSystraceStop[] = "SystraceStop";
+const char kSystraceStatus[] = "SystraceStatus";
+const char kGetLog[] = "GetLog";
+const char kGetAllLogs[] = "GetAllLogs";
+const char kGetUserLogFiles[] = "GetUserLogFiles";
+const char kGetFeedbackLogs[] = "GetFeedbackLogs";
+const char kTestICMP[] = "TestICMP";
+const char kTestICMPWithOptions[] = "TestICMPWithOptions";
+const char kLogKernelTaskStates[] = "LogKernelTaskStates";
+const char kUploadCrashes[] = "UploadCrashes";
+const char kRemoveRootfsVerification[] = "RemoveRootfsVerification";
+const char kEnableChromeRemoteDebugging[] = "EnableChromeRemoteDebugging";
+const char kEnableBootFromUsb[] = "EnableBootFromUsb";
+const char kConfigureSshServer[] = "ConfigureSshServer";
+const char kSetUserPassword[] = "SetUserPassword";
+const char kEnableChromeDevFeatures[] = "EnableChromeDevFeatures";
+const char kQueryDevFeatures[] = "QueryDevFeatures";
+
+// Values.
+enum DevFeatureFlag {
+  DEV_FEATURES_DISABLED = 1 << 0,
+  DEV_FEATURE_ROOTFS_VERIFICATION_REMOVED = 1 << 1,
+  DEV_FEATURE_BOOT_FROM_USB_ENABLED = 1 << 2,
+  DEV_FEATURE_SSH_SERVER_CONFIGURED = 1 << 3,
+  DEV_FEATURE_DEV_MODE_ROOT_PASSWORD_SET = 1 << 4,
+  DEV_FEATURE_SYSTEM_ROOT_PASSWORD_SET = 1 << 5,
+  DEV_FEATURE_CHROME_REMOTE_DEBUGGING_ENABLED = 1 << 6,
+};
+}  // namespace debugd
+
+#endif  // SYSTEM_API_DBUS_DEBUGD_DBUS_CONSTANTS_H_
diff --git a/include/debugd/dbus-proxies.h b/include/debugd/dbus-proxies.h
new file mode 100644
index 0000000..7bde80b
--- /dev/null
+++ b/include/debugd/dbus-proxies.h
@@ -0,0 +1,2334 @@
+// Automatic generation of D-Bus interfaces:
+//  - org.chromium.debugd
+#ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_DEBUGD_CLIENT_OUT_DEFAULT_GEN_INCLUDE_DEBUGD_DBUS_PROXIES_H
+#define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_DEBUGD_CLIENT_OUT_DEFAULT_GEN_INCLUDE_DEBUGD_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::debugd.
+class debugdProxyInterface {
+ public:
+  virtual ~debugdProxyInterface() = default;
+
+  // Starts pinging the specified hostname with the specified options, with
+  // output directed to the given output file descriptor. The returned opaque
+  // string functions as a handle for this particular ping. Multiple pings
+  // can be running at once.
+  virtual bool PingStart(
+      const dbus::FileDescriptor& in_outfd,
+      const std::string& in_destination,
+      const chromeos::VariantDictionary& in_options,
+      std::string* out_handle,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Starts pinging the specified hostname with the specified options, with
+  // output directed to the given output file descriptor. The returned opaque
+  // string functions as a handle for this particular ping. Multiple pings
+  // can be running at once.
+  virtual void PingStartAsync(
+      const dbus::FileDescriptor& in_outfd,
+      const std::string& in_destination,
+      const chromeos::VariantDictionary& in_options,
+      const base::Callback<void(const std::string& /*handle*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops a running ping.
+  virtual bool PingStop(
+      const std::string& in_handle,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops a running ping.
+  virtual void PingStopAsync(
+      const std::string& in_handle,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Start system/kernel tracing.  If tracing is already enabled it is
+  // stopped first and any collected events are discarded.  The kernel
+  // must have been configured to support tracing.
+  virtual bool SystraceStart(
+      const std::string& in_categories,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Start system/kernel tracing.  If tracing is already enabled it is
+  // stopped first and any collected events are discarded.  The kernel
+  // must have been configured to support tracing.
+  virtual void SystraceStartAsync(
+      const std::string& in_categories,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stop system/kernel tracing and write the collected event data.
+  virtual bool SystraceStop(
+      const dbus::FileDescriptor& in_outfd,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stop system/kernel tracing and write the collected event data.
+  virtual void SystraceStopAsync(
+      const dbus::FileDescriptor& in_outfd,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Return current status for system/kernel tracing including whether it
+  // is enabled, the tracing clock, and the set of events enabled.
+  virtual bool SystraceStatus(
+      std::string* out_status,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Return current status for system/kernel tracing including whether it
+  // is enabled, the tracing clock, and the set of events enabled.
+  virtual void SystraceStatusAsync(
+      const base::Callback<void(const std::string& /*status*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool TracePathStart(
+      const dbus::FileDescriptor& in_outfd,
+      const std::string& in_destination,
+      const chromeos::VariantDictionary& in_options,
+      std::string* out_handle,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void TracePathStartAsync(
+      const dbus::FileDescriptor& in_outfd,
+      const std::string& in_destination,
+      const chromeos::VariantDictionary& in_options,
+      const base::Callback<void(const std::string& /*handle*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops a running tracepath.
+  virtual bool TracePathStop(
+      const std::string& in_handle,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops a running tracepath.
+  virtual void TracePathStopAsync(
+      const std::string& in_handle,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns the routing table.
+  virtual bool GetRoutes(
+      const chromeos::VariantDictionary& in_options,
+      std::vector<std::string>* out_result,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns the routing table.
+  virtual void GetRoutesAsync(
+      const chromeos::VariantDictionary& in_options,
+      const base::Callback<void(const std::vector<std::string>& /*result*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns modem information as a JSON string. See the design document for
+  // a rationale.
+  virtual bool GetModemStatus(
+      std::string* out_status,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns modem information as a JSON string. See the design document for
+  // a rationale.
+  virtual void GetModemStatusAsync(
+      const base::Callback<void(const std::string& /*status*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs the specified command through the modem serial interface and
+  // returns the output.
+  virtual bool RunModemCommand(
+      const std::string& in_command,
+      std::string* out_status,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs the specified command through the modem serial interface and
+  // returns the output.
+  virtual void RunModemCommandAsync(
+      const std::string& in_command,
+      const base::Callback<void(const std::string& /*status*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns network information as a JSON string. See the design document
+  // for a rationale.
+  virtual bool GetNetworkStatus(
+      std::string* out_status,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns network information as a JSON string. See the design document
+  // for a rationale.
+  virtual void GetNetworkStatusAsync(
+      const base::Callback<void(const std::string& /*status*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns WiMAX information as a JSON string. See the design document for
+  // a rationale.
+  virtual bool GetWiMaxStatus(
+      std::string* out_status,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns WiMAX information as a JSON string. See the design document for
+  // a rationale.
+  virtual void GetWiMaxStatusAsync(
+      const base::Callback<void(const std::string& /*status*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs system-wide perf profiling. The profile parameters are selected by
+  // perf_args.
+  virtual bool GetPerfOutput(
+      uint32_t in_duration_sec,
+      const std::vector<std::string>& in_perf_args,
+      int32_t* out_status,
+      std::vector<uint8_t>* out_perf_data,
+      std::vector<uint8_t>* out_perf_stat,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs system-wide perf profiling. The profile parameters are selected by
+  // perf_args.
+  virtual void GetPerfOutputAsync(
+      uint32_t in_duration_sec,
+      const std::vector<std::string>& in_perf_args,
+      const base::Callback<void(int32_t /*status*/, const std::vector<uint8_t>& /*perf_data*/, const std::vector<uint8_t>& /*perf_stat*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs system-wide perf profiling. It can can profile events other than
+  // cycles (example: iTLB-misses), and can collect branch profiles. It can
+  // also return raw counter values. The exact profile or counters to be
+  // collected is chosen at random and depends on what CPU is used by the
+  // system (certain CPUs do not support certain profiling modes).
+  virtual bool GetRandomPerfOutput(
+      uint32_t in_duration_sec,
+      int32_t* out_status,
+      std::vector<uint8_t>* out_perf_data,
+      std::vector<uint8_t>* out_perf_stat,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs system-wide perf profiling. It can can profile events other than
+  // cycles (example: iTLB-misses), and can collect branch profiles. It can
+  // also return raw counter values. The exact profile or counters to be
+  // collected is chosen at random and depends on what CPU is used by the
+  // system (certain CPUs do not support certain profiling modes).
+  virtual void GetRandomPerfOutputAsync(
+      uint32_t in_duration_sec,
+      const base::Callback<void(int32_t /*status*/, const std::vector<uint8_t>& /*perf_data*/, const std::vector<uint8_t>& /*perf_stat*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns perf event data. Does systemwide profiling. It can profile
+  // events other than cycles (example: iTLB-misses), and can collect branch
+  // profiles. The exact profile to be collected is chosen at random
+  // and depends on what CPU is used by the system (certain CPUs do not
+  // support certain profiling modes).
+  virtual bool GetRichPerfData(
+      uint32_t in_duration_sec,
+      std::vector<uint8_t>* out_status,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns perf event data. Does systemwide profiling. It can profile
+  // events other than cycles (example: iTLB-misses), and can collect branch
+  // profiles. The exact profile to be collected is chosen at random
+  // and depends on what CPU is used by the system (certain CPUs do not
+  // support certain profiling modes).
+  virtual void GetRichPerfDataAsync(
+      uint32_t in_duration_sec,
+      const base::Callback<void(const std::vector<uint8_t>& /*status*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // DEPRECATED: Use DumpDebugLogs instead.
+  // Packages up system logs into a .tar.gz and returns it over the supplied
+  // file descriptor.
+  virtual bool GetDebugLogs(
+      const dbus::FileDescriptor& in_outfd,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // DEPRECATED: Use DumpDebugLogs instead.
+  // Packages up system logs into a .tar.gz and returns it over the supplied
+  // file descriptor.
+  virtual void GetDebugLogsAsync(
+      const dbus::FileDescriptor& in_outfd,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Packages up system logs into a .tar(.gz) and returns it over the
+  // supplied file descriptor.
+  virtual bool DumpDebugLogs(
+      bool in_is_compressed,
+      const dbus::FileDescriptor& in_outfd,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Packages up system logs into a .tar(.gz) and returns it over the
+  // supplied file descriptor.
+  virtual void DumpDebugLogsAsync(
+      bool in_is_compressed,
+      const dbus::FileDescriptor& in_outfd,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Enables or disables debug mode for a specified subsystem.
+  virtual bool SetDebugMode(
+      const std::string& in_subsystem,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Enables or disables debug mode for a specified subsystem.
+  virtual void SetDebugModeAsync(
+      const std::string& in_subsystem,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Fetches the contents of a single system log, identified by name. See
+  // /src/log_tool.cc for a list of valid names.
+  virtual bool GetLog(
+      const std::string& in_log,
+      std::string* out_contents,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Fetches the contents of a single system log, identified by name. See
+  // /src/log_tool.cc for a list of valid names.
+  virtual void GetLogAsync(
+      const std::string& in_log,
+      const base::Callback<void(const std::string& /*contents*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns all the system logs.
+  virtual bool GetAllLogs(
+      std::map<std::string, std::string>* out_logs,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns all the system logs.
+  virtual void GetAllLogsAsync(
+      const base::Callback<void(const std::map<std::string, std::string>& /*logs*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns system logs for feedback reports.
+  virtual bool GetFeedbackLogs(
+      std::map<std::string, std::string>* out_logs,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns system logs for feedback reports.
+  virtual void GetFeedbackLogsAsync(
+      const base::Callback<void(const std::map<std::string, std::string>& /*logs*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns list of User log file names that Chrome itself must collect.
+  // These logfiles are relative to the user's profile path and must be
+  // collected separately for each user.
+  virtual bool GetUserLogFiles(
+      std::map<std::string, std::string>* out_user_log_files,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns list of User log file names that Chrome itself must collect.
+  // These logfiles are relative to the user's profile path and must be
+  // collected separately for each user.
+  virtual void GetUserLogFilesAsync(
+      const base::Callback<void(const std::map<std::string, std::string>& /*user_log_files*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Example method. See /doc/hacking.md.
+  virtual bool GetExample(
+      std::string* out_result,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Example method. See /doc/hacking.md.
+  virtual void GetExampleAsync(
+      const base::Callback<void(const std::string& /*result*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns information about network interfaces as a JSON string.
+  virtual bool GetInterfaces(
+      std::string* out_result,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Returns information about network interfaces as a JSON string.
+  virtual void GetInterfacesAsync(
+      const base::Callback<void(const std::string& /*result*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Tests ICMP connectivity to a specified host.
+  virtual bool TestICMP(
+      const std::string& in_host,
+      std::string* out_result,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Tests ICMP connectivity to a specified host.
+  virtual void TestICMPAsync(
+      const std::string& in_host,
+      const base::Callback<void(const std::string& /*result*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Tests ICMP connectivity to a specified host (with options).
+  virtual bool TestICMPWithOptions(
+      const std::string& in_host,
+      const std::map<std::string, std::string>& in_options,
+      std::string* out_result,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Tests ICMP connectivity to a specified host (with options).
+  virtual void TestICMPWithOptionsAsync(
+      const std::string& in_host,
+      const std::map<std::string, std::string>& in_options,
+      const base::Callback<void(const std::string& /*result*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs BatteryFirmware utility.
+  virtual bool BatteryFirmware(
+      const std::string& in_option,
+      std::string* out_result,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs BatteryFirmware utility.
+  virtual void BatteryFirmwareAsync(
+      const std::string& in_option,
+      const base::Callback<void(const std::string& /*result*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs Smartctl utility.
+  virtual bool Smartctl(
+      const std::string& in_option,
+      std::string* out_result,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Runs Smartctl utility.
+  virtual void SmartctlAsync(
+      const std::string& in_option,
+      const base::Callback<void(const std::string& /*result*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Starts running memtester.
+  virtual bool MemtesterStart(
+      const dbus::FileDescriptor& in_outfd,
+      uint32_t in_memory,
+      std::string* out_status,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Starts running memtester.
+  virtual void MemtesterStartAsync(
+      const dbus::FileDescriptor& in_outfd,
+      uint32_t in_memory,
+      const base::Callback<void(const std::string& /*status*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops running memtester.
+  virtual bool MemtesterStop(
+      const std::string& in_handle,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops running memtester.
+  virtual void MemtesterStopAsync(
+      const std::string& in_handle,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Starts running badblocks test.
+  virtual bool BadblocksStart(
+      const dbus::FileDescriptor& in_outfd,
+      std::string* out_status,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Starts running badblocks test.
+  virtual void BadblocksStartAsync(
+      const dbus::FileDescriptor& in_outfd,
+      const base::Callback<void(const std::string& /*status*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops running badblocks.
+  virtual bool BadblocksStop(
+      const std::string& in_handle,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops running badblocks.
+  virtual void BadblocksStopAsync(
+      const std::string& in_handle,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Starts a packet capture with the specified options, with diagnostic
+  // status directed to the "statfd" file descriptor and packet capture
+  // data sent to the "outfd" file descriptor.  The returned opaque string
+  // functions as a handle for this particular packet capture.  Multiple
+  // captures can be running at once.  Captures can be initiated on
+  // Ethernet-like devices or WiFi devices in "client mode" (showing only
+  // Ethernet frames) by specifying the "device" parameter (see below).
+  // By specifying a channel, the script will find or create a "monitor
+  // mode" interface if one is available and produce an "over the air"
+  // packet capture.  The name of the output packet capture file is sent
+  // to the output file descriptor.
+  virtual bool PacketCaptureStart(
+      const dbus::FileDescriptor& in_statfd,
+      const dbus::FileDescriptor& in_outfd,
+      const chromeos::VariantDictionary& in_options,
+      std::string* out_handle,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Starts a packet capture with the specified options, with diagnostic
+  // status directed to the "statfd" file descriptor and packet capture
+  // data sent to the "outfd" file descriptor.  The returned opaque string
+  // functions as a handle for this particular packet capture.  Multiple
+  // captures can be running at once.  Captures can be initiated on
+  // Ethernet-like devices or WiFi devices in "client mode" (showing only
+  // Ethernet frames) by specifying the "device" parameter (see below).
+  // By specifying a channel, the script will find or create a "monitor
+  // mode" interface if one is available and produce an "over the air"
+  // packet capture.  The name of the output packet capture file is sent
+  // to the output file descriptor.
+  virtual void PacketCaptureStartAsync(
+      const dbus::FileDescriptor& in_statfd,
+      const dbus::FileDescriptor& in_outfd,
+      const chromeos::VariantDictionary& in_options,
+      const base::Callback<void(const std::string& /*handle*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops a running packet capture.
+  virtual bool PacketCaptureStop(
+      const std::string& in_handle,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Stops a running packet capture.
+  virtual void PacketCaptureStopAsync(
+      const std::string& in_handle,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Triggers show-task-states(T) SysRq.
+  // See https://www.kernel.org/doc/Documentation/sysrq.txt.
+  virtual bool LogKernelTaskStates(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Triggers show-task-states(T) SysRq.
+  // See https://www.kernel.org/doc/Documentation/sysrq.txt.
+  virtual void LogKernelTaskStatesAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Triggers uploading of system crashes (the crash_sender program).
+  virtual bool UploadCrashes(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Triggers uploading of system crashes (the crash_sender program).
+  virtual void UploadCrashesAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Removes rootfs verification. Requires a system reboot before it will
+  // take effect. Restricted to pre-owner dev mode.
+  virtual bool RemoveRootfsVerification(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Removes rootfs verification. Requires a system reboot before it will
+  // take effect. Restricted to pre-owner dev mode.
+  virtual void RemoveRootfsVerificationAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Enables OS booting from a USB image. Restricted to pre-owner dev mode.
+  virtual bool EnableBootFromUsb(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Enables OS booting from a USB image. Restricted to pre-owner dev mode.
+  virtual void EnableBootFromUsbAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Sets up sshd to provide an SSH server immediately and on future reboots.
+  // Also installs the test SSH keys to allow access by cros tools. Requires
+  // that rootfs verification has been removed. Restricted to pre-owner dev
+  // mode.
+  virtual bool ConfigureSshServer(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Sets up sshd to provide an SSH server immediately and on future reboots.
+  // Also installs the test SSH keys to allow access by cros tools. Requires
+  // that rootfs verification has been removed. Restricted to pre-owner dev
+  // mode.
+  virtual void ConfigureSshServerAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Sets both the system and dev mode password for the indicated account.
+  // Restricted to pre-owner dev mode.
+  virtual bool SetUserPassword(
+      const std::string& in_username,
+      const std::string& in_password,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Sets both the system and dev mode password for the indicated account.
+  // Restricted to pre-owner dev mode.
+  virtual void SetUserPasswordAsync(
+      const std::string& in_username,
+      const std::string& in_password,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Sets up Chrome for remote debugging. It will take effect after a reboot
+  // and using port 9222.
+  // Requires that rootfs verification has been removed. Restricted to
+  // pre-owner dev mode.
+  virtual bool EnableChromeRemoteDebugging(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Sets up Chrome for remote debugging. It will take effect after a reboot
+  // and using port 9222.
+  // Requires that rootfs verification has been removed. Restricted to
+  // pre-owner dev mode.
+  virtual void EnableChromeRemoteDebuggingAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Convenience function to enable a predefined set of tools from the Chrome
+  // UI. Equivalent to calling these functions in order:
+  //   1. EnableBootFromUsb()
+  //   2. ConfigureSshServer()
+  //   3. SetUserPassword("root", root_password)
+  // Requires that rootfs verification has been removed. If any sub-function
+  // fails, this function will exit with an error without attempting any
+  // further configuration or rollback. Restricted to pre-owner dev mode.
+  virtual bool EnableChromeDevFeatures(
+      const std::string& in_root_password,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Convenience function to enable a predefined set of tools from the Chrome
+  // UI. Equivalent to calling these functions in order:
+  //   1. EnableBootFromUsb()
+  //   2. ConfigureSshServer()
+  //   3. SetUserPassword("root", root_password)
+  // Requires that rootfs verification has been removed. If any sub-function
+  // fails, this function will exit with an error without attempting any
+  // further configuration or rollback. Restricted to pre-owner dev mode.
+  virtual void EnableChromeDevFeaturesAsync(
+      const std::string& in_root_password,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Queries which dev features have been enabled. Each dev feature will be
+  // indicated by a bit flag in the return value. Flags are defined in the
+  // DevFeatureFlag enumeration. If the dev tools are unavailable (system is
+  // not in dev mode/pre-login state), the DEV_FEATURES_DISABLED flag will be
+  // set and the rest of the bits will always be set to 0.
+  virtual bool QueryDevFeatures(
+      int32_t* out_features,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Queries which dev features have been enabled. Each dev feature will be
+  // indicated by a bit flag in the return value. Flags are defined in the
+  // DevFeatureFlag enumeration. If the dev tools are unavailable (system is
+  // not in dev mode/pre-login state), the DEV_FEATURES_DISABLED flag will be
+  // set and the rest of the bits will always be set to 0.
+  virtual void QueryDevFeaturesAsync(
+      const base::Callback<void(int32_t /*features*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Allow uploading of device coredump files.
+  virtual bool EnableDevCoredumpUpload(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Allow uploading of device coredump files.
+  virtual void EnableDevCoredumpUploadAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Disallow uploading of device coredump files.
+  virtual bool DisableDevCoredumpUpload(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // Disallow uploading of device coredump files.
+  virtual void DisableDevCoredumpUploadAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+};
+
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+
+// Interface proxy for org::chromium::debugd.
+class debugdProxy final : public debugdProxyInterface {
+ public:
+  debugdProxy(const scoped_refptr<dbus::Bus>& bus) :
+      bus_{bus},
+      dbus_object_proxy_{
+          bus_->GetObjectProxy(service_name_, object_path_)} {
+  }
+
+  ~debugdProxy() override {
+    bus_->RemoveObjectProxy(
+        service_name_, object_path_, base::Bind(&base::DoNothing));
+  }
+
+  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_; }
+
+  // Starts pinging the specified hostname with the specified options, with
+  // output directed to the given output file descriptor. The returned opaque
+  // string functions as a handle for this particular ping. Multiple pings
+  // can be running at once.
+  bool PingStart(
+      const dbus::FileDescriptor& in_outfd,
+      const std::string& in_destination,
+      const chromeos::VariantDictionary& in_options,
+      std::string* out_handle,
+      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.debugd",
+        "PingStart",
+        error,
+        in_outfd,
+        in_destination,
+        in_options);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_handle);
+  }
+
+  // Starts pinging the specified hostname with the specified options, with
+  // output directed to the given output file descriptor. The returned opaque
+  // string functions as a handle for this particular ping. Multiple pings
+  // can be running at once.
+  void PingStartAsync(
+      const dbus::FileDescriptor& in_outfd,
+      const std::string& in_destination,
+      const chromeos::VariantDictionary& in_options,
+      const base::Callback<void(const std::string& /*handle*/)>& 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.debugd",
+        "PingStart",
+        success_callback,
+        error_callback,
+        in_outfd,
+        in_destination,
+        in_options);
+  }
+
+  // Stops a running ping.
+  bool PingStop(
+      const std::string& in_handle,
+      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.debugd",
+        "PingStop",
+        error,
+        in_handle);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Stops a running ping.
+  void PingStopAsync(
+      const std::string& in_handle,
+      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.debugd",
+        "PingStop",
+        success_callback,
+        error_callback,
+        in_handle);
+  }
+
+  // Start system/kernel tracing.  If tracing is already enabled it is
+  // stopped first and any collected events are discarded.  The kernel
+  // must have been configured to support tracing.
+  bool SystraceStart(
+      const std::string& in_categories,
+      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.debugd",
+        "SystraceStart",
+        error,
+        in_categories);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Start system/kernel tracing.  If tracing is already enabled it is
+  // stopped first and any collected events are discarded.  The kernel
+  // must have been configured to support tracing.
+  void SystraceStartAsync(
+      const std::string& in_categories,
+      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.debugd",
+        "SystraceStart",
+        success_callback,
+        error_callback,
+        in_categories);
+  }
+
+  // Stop system/kernel tracing and write the collected event data.
+  bool SystraceStop(
+      const dbus::FileDescriptor& in_outfd,
+      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.debugd",
+        "SystraceStop",
+        error,
+        in_outfd);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Stop system/kernel tracing and write the collected event data.
+  void SystraceStopAsync(
+      const dbus::FileDescriptor& in_outfd,
+      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.debugd",
+        "SystraceStop",
+        success_callback,
+        error_callback,
+        in_outfd);
+  }
+
+  // Return current status for system/kernel tracing including whether it
+  // is enabled, the tracing clock, and the set of events enabled.
+  bool SystraceStatus(
+      std::string* out_status,
+      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.debugd",
+        "SystraceStatus",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status);
+  }
+
+  // Return current status for system/kernel tracing including whether it
+  // is enabled, the tracing clock, and the set of events enabled.
+  void SystraceStatusAsync(
+      const base::Callback<void(const std::string& /*status*/)>& 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.debugd",
+        "SystraceStatus",
+        success_callback,
+        error_callback);
+  }
+
+  bool TracePathStart(
+      const dbus::FileDescriptor& in_outfd,
+      const std::string& in_destination,
+      const chromeos::VariantDictionary& in_options,
+      std::string* out_handle,
+      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.debugd",
+        "TracePathStart",
+        error,
+        in_outfd,
+        in_destination,
+        in_options);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_handle);
+  }
+
+  void TracePathStartAsync(
+      const dbus::FileDescriptor& in_outfd,
+      const std::string& in_destination,
+      const chromeos::VariantDictionary& in_options,
+      const base::Callback<void(const std::string& /*handle*/)>& 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.debugd",
+        "TracePathStart",
+        success_callback,
+        error_callback,
+        in_outfd,
+        in_destination,
+        in_options);
+  }
+
+  // Stops a running tracepath.
+  bool TracePathStop(
+      const std::string& in_handle,
+      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.debugd",
+        "TracePathStop",
+        error,
+        in_handle);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Stops a running tracepath.
+  void TracePathStopAsync(
+      const std::string& in_handle,
+      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.debugd",
+        "TracePathStop",
+        success_callback,
+        error_callback,
+        in_handle);
+  }
+
+  // Returns the routing table.
+  bool GetRoutes(
+      const chromeos::VariantDictionary& in_options,
+      std::vector<std::string>* out_result,
+      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.debugd",
+        "GetRoutes",
+        error,
+        in_options);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_result);
+  }
+
+  // Returns the routing table.
+  void GetRoutesAsync(
+      const chromeos::VariantDictionary& in_options,
+      const base::Callback<void(const std::vector<std::string>& /*result*/)>& 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.debugd",
+        "GetRoutes",
+        success_callback,
+        error_callback,
+        in_options);
+  }
+
+  // Returns modem information as a JSON string. See the design document for
+  // a rationale.
+  bool GetModemStatus(
+      std::string* out_status,
+      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.debugd",
+        "GetModemStatus",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status);
+  }
+
+  // Returns modem information as a JSON string. See the design document for
+  // a rationale.
+  void GetModemStatusAsync(
+      const base::Callback<void(const std::string& /*status*/)>& 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.debugd",
+        "GetModemStatus",
+        success_callback,
+        error_callback);
+  }
+
+  // Runs the specified command through the modem serial interface and
+  // returns the output.
+  bool RunModemCommand(
+      const std::string& in_command,
+      std::string* out_status,
+      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.debugd",
+        "RunModemCommand",
+        error,
+        in_command);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status);
+  }
+
+  // Runs the specified command through the modem serial interface and
+  // returns the output.
+  void RunModemCommandAsync(
+      const std::string& in_command,
+      const base::Callback<void(const std::string& /*status*/)>& 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.debugd",
+        "RunModemCommand",
+        success_callback,
+        error_callback,
+        in_command);
+  }
+
+  // Returns network information as a JSON string. See the design document
+  // for a rationale.
+  bool GetNetworkStatus(
+      std::string* out_status,
+      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.debugd",
+        "GetNetworkStatus",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status);
+  }
+
+  // Returns network information as a JSON string. See the design document
+  // for a rationale.
+  void GetNetworkStatusAsync(
+      const base::Callback<void(const std::string& /*status*/)>& 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.debugd",
+        "GetNetworkStatus",
+        success_callback,
+        error_callback);
+  }
+
+  // Returns WiMAX information as a JSON string. See the design document for
+  // a rationale.
+  bool GetWiMaxStatus(
+      std::string* out_status,
+      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.debugd",
+        "GetWiMaxStatus",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status);
+  }
+
+  // Returns WiMAX information as a JSON string. See the design document for
+  // a rationale.
+  void GetWiMaxStatusAsync(
+      const base::Callback<void(const std::string& /*status*/)>& 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.debugd",
+        "GetWiMaxStatus",
+        success_callback,
+        error_callback);
+  }
+
+  // Runs system-wide perf profiling. The profile parameters are selected by
+  // perf_args.
+  bool GetPerfOutput(
+      uint32_t in_duration_sec,
+      const std::vector<std::string>& in_perf_args,
+      int32_t* out_status,
+      std::vector<uint8_t>* out_perf_data,
+      std::vector<uint8_t>* out_perf_stat,
+      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.debugd",
+        "GetPerfOutput",
+        error,
+        in_duration_sec,
+        in_perf_args);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status, out_perf_data, out_perf_stat);
+  }
+
+  // Runs system-wide perf profiling. The profile parameters are selected by
+  // perf_args.
+  void GetPerfOutputAsync(
+      uint32_t in_duration_sec,
+      const std::vector<std::string>& in_perf_args,
+      const base::Callback<void(int32_t /*status*/, const std::vector<uint8_t>& /*perf_data*/, const std::vector<uint8_t>& /*perf_stat*/)>& 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.debugd",
+        "GetPerfOutput",
+        success_callback,
+        error_callback,
+        in_duration_sec,
+        in_perf_args);
+  }
+
+  // Runs system-wide perf profiling. It can can profile events other than
+  // cycles (example: iTLB-misses), and can collect branch profiles. It can
+  // also return raw counter values. The exact profile or counters to be
+  // collected is chosen at random and depends on what CPU is used by the
+  // system (certain CPUs do not support certain profiling modes).
+  bool GetRandomPerfOutput(
+      uint32_t in_duration_sec,
+      int32_t* out_status,
+      std::vector<uint8_t>* out_perf_data,
+      std::vector<uint8_t>* out_perf_stat,
+      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.debugd",
+        "GetRandomPerfOutput",
+        error,
+        in_duration_sec);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status, out_perf_data, out_perf_stat);
+  }
+
+  // Runs system-wide perf profiling. It can can profile events other than
+  // cycles (example: iTLB-misses), and can collect branch profiles. It can
+  // also return raw counter values. The exact profile or counters to be
+  // collected is chosen at random and depends on what CPU is used by the
+  // system (certain CPUs do not support certain profiling modes).
+  void GetRandomPerfOutputAsync(
+      uint32_t in_duration_sec,
+      const base::Callback<void(int32_t /*status*/, const std::vector<uint8_t>& /*perf_data*/, const std::vector<uint8_t>& /*perf_stat*/)>& 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.debugd",
+        "GetRandomPerfOutput",
+        success_callback,
+        error_callback,
+        in_duration_sec);
+  }
+
+  // Returns perf event data. Does systemwide profiling. It can profile
+  // events other than cycles (example: iTLB-misses), and can collect branch
+  // profiles. The exact profile to be collected is chosen at random
+  // and depends on what CPU is used by the system (certain CPUs do not
+  // support certain profiling modes).
+  bool GetRichPerfData(
+      uint32_t in_duration_sec,
+      std::vector<uint8_t>* out_status,
+      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.debugd",
+        "GetRichPerfData",
+        error,
+        in_duration_sec);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status);
+  }
+
+  // Returns perf event data. Does systemwide profiling. It can profile
+  // events other than cycles (example: iTLB-misses), and can collect branch
+  // profiles. The exact profile to be collected is chosen at random
+  // and depends on what CPU is used by the system (certain CPUs do not
+  // support certain profiling modes).
+  void GetRichPerfDataAsync(
+      uint32_t in_duration_sec,
+      const base::Callback<void(const std::vector<uint8_t>& /*status*/)>& 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.debugd",
+        "GetRichPerfData",
+        success_callback,
+        error_callback,
+        in_duration_sec);
+  }
+
+  // DEPRECATED: Use DumpDebugLogs instead.
+  // Packages up system logs into a .tar.gz and returns it over the supplied
+  // file descriptor.
+  bool GetDebugLogs(
+      const dbus::FileDescriptor& in_outfd,
+      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.debugd",
+        "GetDebugLogs",
+        error,
+        in_outfd);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // DEPRECATED: Use DumpDebugLogs instead.
+  // Packages up system logs into a .tar.gz and returns it over the supplied
+  // file descriptor.
+  void GetDebugLogsAsync(
+      const dbus::FileDescriptor& in_outfd,
+      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.debugd",
+        "GetDebugLogs",
+        success_callback,
+        error_callback,
+        in_outfd);
+  }
+
+  // Packages up system logs into a .tar(.gz) and returns it over the
+  // supplied file descriptor.
+  bool DumpDebugLogs(
+      bool in_is_compressed,
+      const dbus::FileDescriptor& in_outfd,
+      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.debugd",
+        "DumpDebugLogs",
+        error,
+        in_is_compressed,
+        in_outfd);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Packages up system logs into a .tar(.gz) and returns it over the
+  // supplied file descriptor.
+  void DumpDebugLogsAsync(
+      bool in_is_compressed,
+      const dbus::FileDescriptor& in_outfd,
+      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.debugd",
+        "DumpDebugLogs",
+        success_callback,
+        error_callback,
+        in_is_compressed,
+        in_outfd);
+  }
+
+  // Enables or disables debug mode for a specified subsystem.
+  bool SetDebugMode(
+      const std::string& in_subsystem,
+      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.debugd",
+        "SetDebugMode",
+        error,
+        in_subsystem);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Enables or disables debug mode for a specified subsystem.
+  void SetDebugModeAsync(
+      const std::string& in_subsystem,
+      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.debugd",
+        "SetDebugMode",
+        success_callback,
+        error_callback,
+        in_subsystem);
+  }
+
+  // Fetches the contents of a single system log, identified by name. See
+  // /src/log_tool.cc for a list of valid names.
+  bool GetLog(
+      const std::string& in_log,
+      std::string* out_contents,
+      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.debugd",
+        "GetLog",
+        error,
+        in_log);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_contents);
+  }
+
+  // Fetches the contents of a single system log, identified by name. See
+  // /src/log_tool.cc for a list of valid names.
+  void GetLogAsync(
+      const std::string& in_log,
+      const base::Callback<void(const std::string& /*contents*/)>& 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.debugd",
+        "GetLog",
+        success_callback,
+        error_callback,
+        in_log);
+  }
+
+  // Returns all the system logs.
+  bool GetAllLogs(
+      std::map<std::string, std::string>* out_logs,
+      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.debugd",
+        "GetAllLogs",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_logs);
+  }
+
+  // Returns all the system logs.
+  void GetAllLogsAsync(
+      const base::Callback<void(const std::map<std::string, std::string>& /*logs*/)>& 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.debugd",
+        "GetAllLogs",
+        success_callback,
+        error_callback);
+  }
+
+  // Returns system logs for feedback reports.
+  bool GetFeedbackLogs(
+      std::map<std::string, std::string>* out_logs,
+      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.debugd",
+        "GetFeedbackLogs",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_logs);
+  }
+
+  // Returns system logs for feedback reports.
+  void GetFeedbackLogsAsync(
+      const base::Callback<void(const std::map<std::string, std::string>& /*logs*/)>& 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.debugd",
+        "GetFeedbackLogs",
+        success_callback,
+        error_callback);
+  }
+
+  // Returns list of User log file names that Chrome itself must collect.
+  // These logfiles are relative to the user's profile path and must be
+  // collected separately for each user.
+  bool GetUserLogFiles(
+      std::map<std::string, std::string>* out_user_log_files,
+      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.debugd",
+        "GetUserLogFiles",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_user_log_files);
+  }
+
+  // Returns list of User log file names that Chrome itself must collect.
+  // These logfiles are relative to the user's profile path and must be
+  // collected separately for each user.
+  void GetUserLogFilesAsync(
+      const base::Callback<void(const std::map<std::string, std::string>& /*user_log_files*/)>& 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.debugd",
+        "GetUserLogFiles",
+        success_callback,
+        error_callback);
+  }
+
+  // Example method. See /doc/hacking.md.
+  bool GetExample(
+      std::string* out_result,
+      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.debugd",
+        "GetExample",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_result);
+  }
+
+  // Example method. See /doc/hacking.md.
+  void GetExampleAsync(
+      const base::Callback<void(const std::string& /*result*/)>& 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.debugd",
+        "GetExample",
+        success_callback,
+        error_callback);
+  }
+
+  // Returns information about network interfaces as a JSON string.
+  bool GetInterfaces(
+      std::string* out_result,
+      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.debugd",
+        "GetInterfaces",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_result);
+  }
+
+  // Returns information about network interfaces as a JSON string.
+  void GetInterfacesAsync(
+      const base::Callback<void(const std::string& /*result*/)>& 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.debugd",
+        "GetInterfaces",
+        success_callback,
+        error_callback);
+  }
+
+  // Tests ICMP connectivity to a specified host.
+  bool TestICMP(
+      const std::string& in_host,
+      std::string* out_result,
+      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.debugd",
+        "TestICMP",
+        error,
+        in_host);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_result);
+  }
+
+  // Tests ICMP connectivity to a specified host.
+  void TestICMPAsync(
+      const std::string& in_host,
+      const base::Callback<void(const std::string& /*result*/)>& 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.debugd",
+        "TestICMP",
+        success_callback,
+        error_callback,
+        in_host);
+  }
+
+  // Tests ICMP connectivity to a specified host (with options).
+  bool TestICMPWithOptions(
+      const std::string& in_host,
+      const std::map<std::string, std::string>& in_options,
+      std::string* out_result,
+      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.debugd",
+        "TestICMPWithOptions",
+        error,
+        in_host,
+        in_options);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_result);
+  }
+
+  // Tests ICMP connectivity to a specified host (with options).
+  void TestICMPWithOptionsAsync(
+      const std::string& in_host,
+      const std::map<std::string, std::string>& in_options,
+      const base::Callback<void(const std::string& /*result*/)>& 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.debugd",
+        "TestICMPWithOptions",
+        success_callback,
+        error_callback,
+        in_host,
+        in_options);
+  }
+
+  // Runs BatteryFirmware utility.
+  bool BatteryFirmware(
+      const std::string& in_option,
+      std::string* out_result,
+      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.debugd",
+        "BatteryFirmware",
+        error,
+        in_option);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_result);
+  }
+
+  // Runs BatteryFirmware utility.
+  void BatteryFirmwareAsync(
+      const std::string& in_option,
+      const base::Callback<void(const std::string& /*result*/)>& 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.debugd",
+        "BatteryFirmware",
+        success_callback,
+        error_callback,
+        in_option);
+  }
+
+  // Runs Smartctl utility.
+  bool Smartctl(
+      const std::string& in_option,
+      std::string* out_result,
+      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.debugd",
+        "Smartctl",
+        error,
+        in_option);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_result);
+  }
+
+  // Runs Smartctl utility.
+  void SmartctlAsync(
+      const std::string& in_option,
+      const base::Callback<void(const std::string& /*result*/)>& 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.debugd",
+        "Smartctl",
+        success_callback,
+        error_callback,
+        in_option);
+  }
+
+  // Starts running memtester.
+  bool MemtesterStart(
+      const dbus::FileDescriptor& in_outfd,
+      uint32_t in_memory,
+      std::string* out_status,
+      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.debugd",
+        "MemtesterStart",
+        error,
+        in_outfd,
+        in_memory);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status);
+  }
+
+  // Starts running memtester.
+  void MemtesterStartAsync(
+      const dbus::FileDescriptor& in_outfd,
+      uint32_t in_memory,
+      const base::Callback<void(const std::string& /*status*/)>& 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.debugd",
+        "MemtesterStart",
+        success_callback,
+        error_callback,
+        in_outfd,
+        in_memory);
+  }
+
+  // Stops running memtester.
+  bool MemtesterStop(
+      const std::string& in_handle,
+      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.debugd",
+        "MemtesterStop",
+        error,
+        in_handle);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Stops running memtester.
+  void MemtesterStopAsync(
+      const std::string& in_handle,
+      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.debugd",
+        "MemtesterStop",
+        success_callback,
+        error_callback,
+        in_handle);
+  }
+
+  // Starts running badblocks test.
+  bool BadblocksStart(
+      const dbus::FileDescriptor& in_outfd,
+      std::string* out_status,
+      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.debugd",
+        "BadblocksStart",
+        error,
+        in_outfd);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_status);
+  }
+
+  // Starts running badblocks test.
+  void BadblocksStartAsync(
+      const dbus::FileDescriptor& in_outfd,
+      const base::Callback<void(const std::string& /*status*/)>& 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.debugd",
+        "BadblocksStart",
+        success_callback,
+        error_callback,
+        in_outfd);
+  }
+
+  // Stops running badblocks.
+  bool BadblocksStop(
+      const std::string& in_handle,
+      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.debugd",
+        "BadblocksStop",
+        error,
+        in_handle);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Stops running badblocks.
+  void BadblocksStopAsync(
+      const std::string& in_handle,
+      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.debugd",
+        "BadblocksStop",
+        success_callback,
+        error_callback,
+        in_handle);
+  }
+
+  // Starts a packet capture with the specified options, with diagnostic
+  // status directed to the "statfd" file descriptor and packet capture
+  // data sent to the "outfd" file descriptor.  The returned opaque string
+  // functions as a handle for this particular packet capture.  Multiple
+  // captures can be running at once.  Captures can be initiated on
+  // Ethernet-like devices or WiFi devices in "client mode" (showing only
+  // Ethernet frames) by specifying the "device" parameter (see below).
+  // By specifying a channel, the script will find or create a "monitor
+  // mode" interface if one is available and produce an "over the air"
+  // packet capture.  The name of the output packet capture file is sent
+  // to the output file descriptor.
+  bool PacketCaptureStart(
+      const dbus::FileDescriptor& in_statfd,
+      const dbus::FileDescriptor& in_outfd,
+      const chromeos::VariantDictionary& in_options,
+      std::string* out_handle,
+      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.debugd",
+        "PacketCaptureStart",
+        error,
+        in_statfd,
+        in_outfd,
+        in_options);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_handle);
+  }
+
+  // Starts a packet capture with the specified options, with diagnostic
+  // status directed to the "statfd" file descriptor and packet capture
+  // data sent to the "outfd" file descriptor.  The returned opaque string
+  // functions as a handle for this particular packet capture.  Multiple
+  // captures can be running at once.  Captures can be initiated on
+  // Ethernet-like devices or WiFi devices in "client mode" (showing only
+  // Ethernet frames) by specifying the "device" parameter (see below).
+  // By specifying a channel, the script will find or create a "monitor
+  // mode" interface if one is available and produce an "over the air"
+  // packet capture.  The name of the output packet capture file is sent
+  // to the output file descriptor.
+  void PacketCaptureStartAsync(
+      const dbus::FileDescriptor& in_statfd,
+      const dbus::FileDescriptor& in_outfd,
+      const chromeos::VariantDictionary& in_options,
+      const base::Callback<void(const std::string& /*handle*/)>& 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.debugd",
+        "PacketCaptureStart",
+        success_callback,
+        error_callback,
+        in_statfd,
+        in_outfd,
+        in_options);
+  }
+
+  // Stops a running packet capture.
+  bool PacketCaptureStop(
+      const std::string& in_handle,
+      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.debugd",
+        "PacketCaptureStop",
+        error,
+        in_handle);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Stops a running packet capture.
+  void PacketCaptureStopAsync(
+      const std::string& in_handle,
+      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.debugd",
+        "PacketCaptureStop",
+        success_callback,
+        error_callback,
+        in_handle);
+  }
+
+  // Triggers show-task-states(T) SysRq.
+  // See https://www.kernel.org/doc/Documentation/sysrq.txt.
+  bool LogKernelTaskStates(
+      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.debugd",
+        "LogKernelTaskStates",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Triggers show-task-states(T) SysRq.
+  // See https://www.kernel.org/doc/Documentation/sysrq.txt.
+  void LogKernelTaskStatesAsync(
+      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.debugd",
+        "LogKernelTaskStates",
+        success_callback,
+        error_callback);
+  }
+
+  // Triggers uploading of system crashes (the crash_sender program).
+  bool UploadCrashes(
+      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.debugd",
+        "UploadCrashes",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Triggers uploading of system crashes (the crash_sender program).
+  void UploadCrashesAsync(
+      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.debugd",
+        "UploadCrashes",
+        success_callback,
+        error_callback);
+  }
+
+  // Removes rootfs verification. Requires a system reboot before it will
+  // take effect. Restricted to pre-owner dev mode.
+  bool RemoveRootfsVerification(
+      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.debugd",
+        "RemoveRootfsVerification",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Removes rootfs verification. Requires a system reboot before it will
+  // take effect. Restricted to pre-owner dev mode.
+  void RemoveRootfsVerificationAsync(
+      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.debugd",
+        "RemoveRootfsVerification",
+        success_callback,
+        error_callback);
+  }
+
+  // Enables OS booting from a USB image. Restricted to pre-owner dev mode.
+  bool EnableBootFromUsb(
+      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.debugd",
+        "EnableBootFromUsb",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Enables OS booting from a USB image. Restricted to pre-owner dev mode.
+  void EnableBootFromUsbAsync(
+      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.debugd",
+        "EnableBootFromUsb",
+        success_callback,
+        error_callback);
+  }
+
+  // Sets up sshd to provide an SSH server immediately and on future reboots.
+  // Also installs the test SSH keys to allow access by cros tools. Requires
+  // that rootfs verification has been removed. Restricted to pre-owner dev
+  // mode.
+  bool ConfigureSshServer(
+      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.debugd",
+        "ConfigureSshServer",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Sets up sshd to provide an SSH server immediately and on future reboots.
+  // Also installs the test SSH keys to allow access by cros tools. Requires
+  // that rootfs verification has been removed. Restricted to pre-owner dev
+  // mode.
+  void ConfigureSshServerAsync(
+      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.debugd",
+        "ConfigureSshServer",
+        success_callback,
+        error_callback);
+  }
+
+  // Sets both the system and dev mode password for the indicated account.
+  // Restricted to pre-owner dev mode.
+  bool SetUserPassword(
+      const std::string& in_username,
+      const std::string& in_password,
+      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.debugd",
+        "SetUserPassword",
+        error,
+        in_username,
+        in_password);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Sets both the system and dev mode password for the indicated account.
+  // Restricted to pre-owner dev mode.
+  void SetUserPasswordAsync(
+      const std::string& in_username,
+      const std::string& in_password,
+      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.debugd",
+        "SetUserPassword",
+        success_callback,
+        error_callback,
+        in_username,
+        in_password);
+  }
+
+  // Sets up Chrome for remote debugging. It will take effect after a reboot
+  // and using port 9222.
+  // Requires that rootfs verification has been removed. Restricted to
+  // pre-owner dev mode.
+  bool EnableChromeRemoteDebugging(
+      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.debugd",
+        "EnableChromeRemoteDebugging",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Sets up Chrome for remote debugging. It will take effect after a reboot
+  // and using port 9222.
+  // Requires that rootfs verification has been removed. Restricted to
+  // pre-owner dev mode.
+  void EnableChromeRemoteDebuggingAsync(
+      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.debugd",
+        "EnableChromeRemoteDebugging",
+        success_callback,
+        error_callback);
+  }
+
+  // Convenience function to enable a predefined set of tools from the Chrome
+  // UI. Equivalent to calling these functions in order:
+  //   1. EnableBootFromUsb()
+  //   2. ConfigureSshServer()
+  //   3. SetUserPassword("root", root_password)
+  // Requires that rootfs verification has been removed. If any sub-function
+  // fails, this function will exit with an error without attempting any
+  // further configuration or rollback. Restricted to pre-owner dev mode.
+  bool EnableChromeDevFeatures(
+      const std::string& in_root_password,
+      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.debugd",
+        "EnableChromeDevFeatures",
+        error,
+        in_root_password);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Convenience function to enable a predefined set of tools from the Chrome
+  // UI. Equivalent to calling these functions in order:
+  //   1. EnableBootFromUsb()
+  //   2. ConfigureSshServer()
+  //   3. SetUserPassword("root", root_password)
+  // Requires that rootfs verification has been removed. If any sub-function
+  // fails, this function will exit with an error without attempting any
+  // further configuration or rollback. Restricted to pre-owner dev mode.
+  void EnableChromeDevFeaturesAsync(
+      const std::string& in_root_password,
+      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.debugd",
+        "EnableChromeDevFeatures",
+        success_callback,
+        error_callback,
+        in_root_password);
+  }
+
+  // Queries which dev features have been enabled. Each dev feature will be
+  // indicated by a bit flag in the return value. Flags are defined in the
+  // DevFeatureFlag enumeration. If the dev tools are unavailable (system is
+  // not in dev mode/pre-login state), the DEV_FEATURES_DISABLED flag will be
+  // set and the rest of the bits will always be set to 0.
+  bool QueryDevFeatures(
+      int32_t* out_features,
+      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.debugd",
+        "QueryDevFeatures",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_features);
+  }
+
+  // Queries which dev features have been enabled. Each dev feature will be
+  // indicated by a bit flag in the return value. Flags are defined in the
+  // DevFeatureFlag enumeration. If the dev tools are unavailable (system is
+  // not in dev mode/pre-login state), the DEV_FEATURES_DISABLED flag will be
+  // set and the rest of the bits will always be set to 0.
+  void QueryDevFeaturesAsync(
+      const base::Callback<void(int32_t /*features*/)>& 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.debugd",
+        "QueryDevFeatures",
+        success_callback,
+        error_callback);
+  }
+
+  // Allow uploading of device coredump files.
+  bool EnableDevCoredumpUpload(
+      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.debugd",
+        "EnableDevCoredumpUpload",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Allow uploading of device coredump files.
+  void EnableDevCoredumpUploadAsync(
+      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.debugd",
+        "EnableDevCoredumpUpload",
+        success_callback,
+        error_callback);
+  }
+
+  // Disallow uploading of device coredump files.
+  bool DisableDevCoredumpUpload(
+      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.debugd",
+        "DisableDevCoredumpUpload",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // Disallow uploading of device coredump files.
+  void DisableDevCoredumpUploadAsync(
+      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.debugd",
+        "DisableDevCoredumpUpload",
+        success_callback,
+        error_callback);
+  }
+
+ private:
+  scoped_refptr<dbus::Bus> bus_;
+  const std::string service_name_{"org.chromium.debugd"};
+  const dbus::ObjectPath object_path_{"/org/chromium/debugd"};
+  dbus::ObjectProxy* dbus_object_proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(debugdProxy);
+};
+
+}  // namespace chromium
+}  // namespace org
+
+#endif  // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_DEBUGD_CLIENT_OUT_DEFAULT_GEN_INCLUDE_DEBUGD_DBUS_PROXIES_H
diff --git a/include/debugd/dbus-proxy-mocks.h b/include/debugd/dbus-proxy-mocks.h
new file mode 100644
index 0000000..5ff234e
--- /dev/null
+++ b/include/debugd/dbus-proxy-mocks.h
@@ -0,0 +1,453 @@
+// Automatic generation of D-Bus interface mock proxies for:
+//  - org.chromium.debugd
+#ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_DEBUGD_CLIENT_OUT_DEFAULT_GEN_INCLUDE_DEBUGD_DBUS_PROXY_MOCKS_H
+#define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_DEBUGD_CLIENT_OUT_DEFAULT_GEN_INCLUDE_DEBUGD_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 "debugd/dbus-proxies.h"
+
+namespace org {
+namespace chromium {
+
+// Mock object for debugdProxyInterface.
+class debugdProxyMock : public debugdProxyInterface {
+ public:
+  debugdProxyMock() = default;
+
+  MOCK_METHOD6(PingStart,
+               bool(const dbus::FileDescriptor& /*in_outfd*/,
+                    const std::string& /*in_destination*/,
+                    const chromeos::VariantDictionary& /*in_options*/,
+                    std::string* /*out_handle*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD6(PingStartAsync,
+               void(const dbus::FileDescriptor& /*in_outfd*/,
+                    const std::string& /*in_destination*/,
+                    const chromeos::VariantDictionary& /*in_options*/,
+                    const base::Callback<void(const std::string& /*handle*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(PingStop,
+               bool(const std::string& /*in_handle*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(PingStopAsync,
+               void(const std::string& /*in_handle*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SystraceStart,
+               bool(const std::string& /*in_categories*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SystraceStartAsync,
+               void(const std::string& /*in_categories*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SystraceStop,
+               bool(const dbus::FileDescriptor& /*in_outfd*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SystraceStopAsync,
+               void(const dbus::FileDescriptor& /*in_outfd*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SystraceStatus,
+               bool(std::string* /*out_status*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SystraceStatusAsync,
+               void(const base::Callback<void(const std::string& /*status*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD6(TracePathStart,
+               bool(const dbus::FileDescriptor& /*in_outfd*/,
+                    const std::string& /*in_destination*/,
+                    const chromeos::VariantDictionary& /*in_options*/,
+                    std::string* /*out_handle*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD6(TracePathStartAsync,
+               void(const dbus::FileDescriptor& /*in_outfd*/,
+                    const std::string& /*in_destination*/,
+                    const chromeos::VariantDictionary& /*in_options*/,
+                    const base::Callback<void(const std::string& /*handle*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(TracePathStop,
+               bool(const std::string& /*in_handle*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(TracePathStopAsync,
+               void(const std::string& /*in_handle*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetRoutes,
+               bool(const chromeos::VariantDictionary& /*in_options*/,
+                    std::vector<std::string>* /*out_result*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetRoutesAsync,
+               void(const chromeos::VariantDictionary& /*in_options*/,
+                    const base::Callback<void(const std::vector<std::string>& /*result*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetModemStatus,
+               bool(std::string* /*out_status*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetModemStatusAsync,
+               void(const base::Callback<void(const std::string& /*status*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RunModemCommand,
+               bool(const std::string& /*in_command*/,
+                    std::string* /*out_status*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RunModemCommandAsync,
+               void(const std::string& /*in_command*/,
+                    const base::Callback<void(const std::string& /*status*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetNetworkStatus,
+               bool(std::string* /*out_status*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetNetworkStatusAsync,
+               void(const base::Callback<void(const std::string& /*status*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetWiMaxStatus,
+               bool(std::string* /*out_status*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetWiMaxStatusAsync,
+               void(const base::Callback<void(const std::string& /*status*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD7(GetPerfOutput,
+               bool(uint32_t /*in_duration_sec*/,
+                    const std::vector<std::string>& /*in_perf_args*/,
+                    int32_t* /*out_status*/,
+                    std::vector<uint8_t>* /*out_perf_data*/,
+                    std::vector<uint8_t>* /*out_perf_stat*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(GetPerfOutputAsync,
+               void(uint32_t /*in_duration_sec*/,
+                    const std::vector<std::string>& /*in_perf_args*/,
+                    const base::Callback<void(int32_t /*status*/, const std::vector<uint8_t>& /*perf_data*/, const std::vector<uint8_t>& /*perf_stat*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD6(GetRandomPerfOutput,
+               bool(uint32_t /*in_duration_sec*/,
+                    int32_t* /*out_status*/,
+                    std::vector<uint8_t>* /*out_perf_data*/,
+                    std::vector<uint8_t>* /*out_perf_stat*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetRandomPerfOutputAsync,
+               void(uint32_t /*in_duration_sec*/,
+                    const base::Callback<void(int32_t /*status*/, const std::vector<uint8_t>& /*perf_data*/, const std::vector<uint8_t>& /*perf_stat*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetRichPerfData,
+               bool(uint32_t /*in_duration_sec*/,
+                    std::vector<uint8_t>* /*out_status*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetRichPerfDataAsync,
+               void(uint32_t /*in_duration_sec*/,
+                    const base::Callback<void(const std::vector<uint8_t>& /*status*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetDebugLogs,
+               bool(const dbus::FileDescriptor& /*in_outfd*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetDebugLogsAsync,
+               void(const dbus::FileDescriptor& /*in_outfd*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(DumpDebugLogs,
+               bool(bool /*in_is_compressed*/,
+                    const dbus::FileDescriptor& /*in_outfd*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(DumpDebugLogsAsync,
+               void(bool /*in_is_compressed*/,
+                    const dbus::FileDescriptor& /*in_outfd*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetDebugMode,
+               bool(const std::string& /*in_subsystem*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetDebugModeAsync,
+               void(const std::string& /*in_subsystem*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetLog,
+               bool(const std::string& /*in_log*/,
+                    std::string* /*out_contents*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetLogAsync,
+               void(const std::string& /*in_log*/,
+                    const base::Callback<void(const std::string& /*contents*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetAllLogs,
+               bool(std::map<std::string, std::string>* /*out_logs*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetAllLogsAsync,
+               void(const base::Callback<void(const std::map<std::string, std::string>& /*logs*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetFeedbackLogs,
+               bool(std::map<std::string, std::string>* /*out_logs*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetFeedbackLogsAsync,
+               void(const base::Callback<void(const std::map<std::string, std::string>& /*logs*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetUserLogFiles,
+               bool(std::map<std::string, std::string>* /*out_user_log_files*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetUserLogFilesAsync,
+               void(const base::Callback<void(const std::map<std::string, std::string>& /*user_log_files*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetExample,
+               bool(std::string* /*out_result*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetExampleAsync,
+               void(const base::Callback<void(const std::string& /*result*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetInterfaces,
+               bool(std::string* /*out_result*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetInterfacesAsync,
+               void(const base::Callback<void(const std::string& /*result*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(TestICMP,
+               bool(const std::string& /*in_host*/,
+                    std::string* /*out_result*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(TestICMPAsync,
+               void(const std::string& /*in_host*/,
+                    const base::Callback<void(const std::string& /*result*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(TestICMPWithOptions,
+               bool(const std::string& /*in_host*/,
+                    const std::map<std::string, std::string>& /*in_options*/,
+                    std::string* /*out_result*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(TestICMPWithOptionsAsync,
+               void(const std::string& /*in_host*/,
+                    const std::map<std::string, std::string>& /*in_options*/,
+                    const base::Callback<void(const std::string& /*result*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(BatteryFirmware,
+               bool(const std::string& /*in_option*/,
+                    std::string* /*out_result*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(BatteryFirmwareAsync,
+               void(const std::string& /*in_option*/,
+                    const base::Callback<void(const std::string& /*result*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(Smartctl,
+               bool(const std::string& /*in_option*/,
+                    std::string* /*out_result*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SmartctlAsync,
+               void(const std::string& /*in_option*/,
+                    const base::Callback<void(const std::string& /*result*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(MemtesterStart,
+               bool(const dbus::FileDescriptor& /*in_outfd*/,
+                    uint32_t /*in_memory*/,
+                    std::string* /*out_status*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(MemtesterStartAsync,
+               void(const dbus::FileDescriptor& /*in_outfd*/,
+                    uint32_t /*in_memory*/,
+                    const base::Callback<void(const std::string& /*status*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(MemtesterStop,
+               bool(const std::string& /*in_handle*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(MemtesterStopAsync,
+               void(const std::string& /*in_handle*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(BadblocksStart,
+               bool(const dbus::FileDescriptor& /*in_outfd*/,
+                    std::string* /*out_status*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(BadblocksStartAsync,
+               void(const dbus::FileDescriptor& /*in_outfd*/,
+                    const base::Callback<void(const std::string& /*status*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(BadblocksStop,
+               bool(const std::string& /*in_handle*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(BadblocksStopAsync,
+               void(const std::string& /*in_handle*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD6(PacketCaptureStart,
+               bool(const dbus::FileDescriptor& /*in_statfd*/,
+                    const dbus::FileDescriptor& /*in_outfd*/,
+                    const chromeos::VariantDictionary& /*in_options*/,
+                    std::string* /*out_handle*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD6(PacketCaptureStartAsync,
+               void(const dbus::FileDescriptor& /*in_statfd*/,
+                    const dbus::FileDescriptor& /*in_outfd*/,
+                    const chromeos::VariantDictionary& /*in_options*/,
+                    const base::Callback<void(const std::string& /*handle*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(PacketCaptureStop,
+               bool(const std::string& /*in_handle*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(PacketCaptureStopAsync,
+               void(const std::string& /*in_handle*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(LogKernelTaskStates,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(LogKernelTaskStatesAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(UploadCrashes,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(UploadCrashesAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RemoveRootfsVerification,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RemoveRootfsVerificationAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(EnableBootFromUsb,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(EnableBootFromUsbAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(ConfigureSshServer,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ConfigureSshServerAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetUserPassword,
+               bool(const std::string& /*in_username*/,
+                    const std::string& /*in_password*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(SetUserPasswordAsync,
+               void(const std::string& /*in_username*/,
+                    const std::string& /*in_password*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(EnableChromeRemoteDebugging,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(EnableChromeRemoteDebuggingAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(EnableChromeDevFeatures,
+               bool(const std::string& /*in_root_password*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(EnableChromeDevFeaturesAsync,
+               void(const std::string& /*in_root_password*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(QueryDevFeatures,
+               bool(int32_t* /*out_features*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(QueryDevFeaturesAsync,
+               void(const base::Callback<void(int32_t /*features*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(EnableDevCoredumpUpload,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(EnableDevCoredumpUploadAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(DisableDevCoredumpUpload,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(DisableDevCoredumpUploadAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(debugdProxyMock);
+};
+}  // namespace chromium
+}  // namespace org
+
+#endif  // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_DEBUGD_CLIENT_OUT_DEFAULT_GEN_INCLUDE_DEBUGD_DBUS_PROXY_MOCKS_H
diff --git a/include/power_manager/dbus-constants.h b/include/power_manager/dbus-constants.h
new file mode 100644
index 0000000..fa42cb1
--- /dev/null
+++ b/include/power_manager/dbus-constants.h
@@ -0,0 +1,66 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SYSTEM_API_DBUS_POWER_MANAGER_DBUS_CONSTANTS_H_
+#define SYSTEM_API_DBUS_POWER_MANAGER_DBUS_CONSTANTS_H_
+
+namespace power_manager {
+// powerd
+const char kPowerManagerInterface[] = "org.chromium.PowerManager";
+const char kPowerManagerServicePath[] = "/org/chromium/PowerManager";
+const char kPowerManagerServiceName[] = "org.chromium.PowerManager";
+// Methods exposed by powerd.
+const char kDecreaseScreenBrightnessMethod[] = "DecreaseScreenBrightness";
+const char kIncreaseScreenBrightnessMethod[] = "IncreaseScreenBrightness";
+const char kGetScreenBrightnessPercentMethod[] = "GetScreenBrightnessPercent";
+const char kSetScreenBrightnessPercentMethod[] = "SetScreenBrightnessPercent";
+const char kDecreaseKeyboardBrightnessMethod[] = "DecreaseKeyboardBrightness";
+const char kIncreaseKeyboardBrightnessMethod[] = "IncreaseKeyboardBrightness";
+const char kRequestRestartMethod[] = "RequestRestart";
+const char kRequestShutdownMethod[] = "RequestShutdown";
+const char kRequestSuspendMethod[] = "RequestSuspend";
+const char kGetPowerSupplyPropertiesMethod[] = "GetPowerSupplyProperties";
+const char kHandleUserActivityMethod[] = "HandleUserActivity";
+const char kHandleVideoActivityMethod[] = "HandleVideoActivity";
+const char kSetIsProjectingMethod[] = "SetIsProjecting";
+const char kSetPolicyMethod[] = "SetPolicy";
+const char kSetPowerSourceMethod[] = "SetPowerSource";
+const char kRegisterSuspendDelayMethod[] = "RegisterSuspendDelay";
+const char kUnregisterSuspendDelayMethod[] = "UnregisterSuspendDelay";
+const char kHandleSuspendReadinessMethod[] = "HandleSuspendReadiness";
+const char kRegisterDarkSuspendDelayMethod[] = "RegisterDarkSuspendDelay";
+const char kUnregisterDarkSuspendDelayMethod[] = "UnregisterDarkSuspendDelay";
+const char kHandleDarkSuspendReadinessMethod[] = "HandleDarkSuspendReadiness";
+const char kHandlePowerButtonAcknowledgmentMethod[] =
+    "HandlePowerButtonAcknowledgment";
+const char kRecordDarkResumeWakeReasonMethod[] = "RecordDarkResumeWakeReason";
+// Signals emitted by powerd.
+const char kBrightnessChangedSignal[] = "BrightnessChanged";
+const char kKeyboardBrightnessChangedSignal[] = "KeyboardBrightnessChanged";
+const char kPeripheralBatteryStatusSignal[] = "PeripheralBatteryStatus";
+const char kPowerSupplyPollSignal[] = "PowerSupplyPoll";
+const char kSuspendImminentSignal[] = "SuspendImminent";
+const char kDarkSuspendImminentSignal[] = "DarkSuspendImminent";
+const char kSuspendDoneSignal[] = "SuspendDone";
+const char kInputEventSignal[] = "InputEvent";
+const char kIdleActionImminentSignal[] = "IdleActionImminent";
+const char kIdleActionDeferredSignal[] = "IdleActionDeferred";
+// Values
+const int kBrightnessTransitionGradual = 1;
+const int kBrightnessTransitionInstant = 2;
+enum UserActivityType {
+  USER_ACTIVITY_OTHER = 0,
+  USER_ACTIVITY_BRIGHTNESS_UP_KEY_PRESS = 1,
+  USER_ACTIVITY_BRIGHTNESS_DOWN_KEY_PRESS = 2,
+  USER_ACTIVITY_VOLUME_UP_KEY_PRESS = 3,
+  USER_ACTIVITY_VOLUME_DOWN_KEY_PRESS = 4,
+  USER_ACTIVITY_VOLUME_MUTE_KEY_PRESS = 5,
+};
+enum RequestRestartReason {
+  REQUEST_RESTART_FOR_USER = 0,
+  REQUEST_RESTART_FOR_UPDATE = 1,
+};
+}  // namespace power_manager
+
+#endif  // SYSTEM_API_DBUS_POWER_MANAGER_DBUS_CONSTANTS_H_
diff --git a/include/power_manager/dbus-proxies.h b/include/power_manager/dbus-proxies.h
new file mode 100644
index 0000000..087f0cf
--- /dev/null
+++ b/include/power_manager/dbus-proxies.h
@@ -0,0 +1,1280 @@
+// Automatic generation of D-Bus interfaces:
+//  - org.chromium.PowerManager
+#ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXIES_H
+#define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_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::PowerManager.
+class PowerManagerProxyInterface {
+ public:
+  virtual ~PowerManagerProxyInterface() = default;
+
+  virtual bool RequestShutdown(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RequestShutdownAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |reason| arg is a power_manager::RequestRestartReason value.
+  virtual bool RequestRestart(
+      int32_t in_reason,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |reason| arg is a power_manager::RequestRestartReason value.
+  virtual void RequestRestartAsync(
+      int32_t in_reason,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |external_wakeup_count| arg is optional, and it will call two
+  // different methods in the backend. This can't be expressed in the DBus
+  // Introspection XML file.
+  virtual bool RequestSuspend(
+      uint64_t in_external_wakeup_count,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |external_wakeup_count| arg is optional, and it will call two
+  // different methods in the backend. This can't be expressed in the DBus
+  // Introspection XML file.
+  virtual void RequestSuspendAsync(
+      uint64_t in_external_wakeup_count,
+      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 DecreaseScreenBrightness(
+      bool in_allow_off,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void DecreaseScreenBrightnessAsync(
+      bool in_allow_off,
+      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 IncreaseScreenBrightness(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void IncreaseScreenBrightnessAsync(
+      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 GetScreenBrightnessPercent(
+      double* out_percent,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetScreenBrightnessPercentAsync(
+      const base::Callback<void(double /*percent*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |style| arg must be one of the values:
+  //   power_manager::kBrightnessTransitionGradual or
+  //   power_manager::kBrightnessTransitionInstant.
+  virtual bool SetScreenBrightnessPercent(
+      double in_percent,
+      int32_t in_style,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |style| arg must be one of the values:
+  //   power_manager::kBrightnessTransitionGradual or
+  //   power_manager::kBrightnessTransitionInstant.
+  virtual void SetScreenBrightnessPercentAsync(
+      double in_percent,
+      int32_t in_style,
+      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 DecreaseKeyboardBrightness(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void DecreaseKeyboardBrightnessAsync(
+      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 IncreaseKeyboardBrightness(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void IncreaseKeyboardBrightnessAsync(
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::PowerSupplyProperties protobuf.
+  virtual bool GetPowerSupplyProperties(
+      std::vector<uint8_t>* out_serialized_proto,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::PowerSupplyProperties protobuf.
+  virtual void GetPowerSupplyPropertiesAsync(
+      const base::Callback<void(const std::vector<uint8_t>& /*serialized_proto*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool HandleVideoActivity(
+      bool in_fullscreen,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void HandleVideoActivityAsync(
+      bool in_fullscreen,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |type| arg is a power_manager::UserActivityType.
+  virtual bool HandleUserActivity(
+      int32_t in_type,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |type| arg is a power_manager::UserActivityType.
+  virtual void HandleUserActivityAsync(
+      int32_t in_type,
+      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 SetIsProjecting(
+      bool in_is_projecting,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetIsProjectingAsync(
+      bool in_is_projecting,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::PowerManagementPolicy protobuf.
+  virtual bool SetPolicy(
+      const std::vector<uint8_t>& in_serialized_proto,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::PowerManagementPolicy protobuf.
+  virtual void SetPolicyAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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 SetPowerSource(
+      const std::string& in_id,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetPowerSourceAsync(
+      const std::string& in_id,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |timestamp_internal| arg is represented as the return value of
+  // base::TimeTicks::ToInternalValue().
+  virtual bool HandlePowerButtonAcknowledgment(
+      int64_t in_timestamp_internal,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |timestamp_internal| arg is represented as the return value of
+  // base::TimeTicks::ToInternalValue().
+  virtual void HandlePowerButtonAcknowledgmentAsync(
+      int64_t in_timestamp_internal,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_request_proto| arg is a serialized
+  // power_manager::RegisterSuspendDelayRequest protobuf.
+  // The |serialized_reply_proto| arg is a serialized
+  // RegisterSuspendDelayReply protobuf.
+  virtual bool RegisterSuspendDelay(
+      const std::vector<uint8_t>& in_serialized_request_proto,
+      std::vector<uint8_t>* out_serialized_reply_proto,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_request_proto| arg is a serialized
+  // power_manager::RegisterSuspendDelayRequest protobuf.
+  // The |serialized_reply_proto| arg is a serialized
+  // RegisterSuspendDelayReply protobuf.
+  virtual void RegisterSuspendDelayAsync(
+      const std::vector<uint8_t>& in_serialized_request_proto,
+      const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::UnregisterSuspendDelayRequest protobuf.
+  virtual bool UnregisterSuspendDelay(
+      const std::vector<uint8_t>& in_serialized_proto,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::UnregisterSuspendDelayRequest protobuf.
+  virtual void UnregisterSuspendDelayAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::SuspendReadinessInfo protobuf.
+  virtual bool HandleSuspendReadiness(
+      const std::vector<uint8_t>& in_serialized_proto,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::SuspendReadinessInfo protobuf.
+  virtual void HandleSuspendReadinessAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_request_proto| arg is a serialized
+  // power_manager::RegisterSuspendDelayRequest protobuf.
+  // The |serialized_reply_proto| arg is a serialized
+  // RegisterSuspendDelayReply protobuf.
+  virtual bool RegisterDarkSuspendDelay(
+      const std::vector<uint8_t>& in_serialized_request_proto,
+      std::vector<uint8_t>* out_serialized_reply_proto,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_request_proto| arg is a serialized
+  // power_manager::RegisterSuspendDelayRequest protobuf.
+  // The |serialized_reply_proto| arg is a serialized
+  // RegisterSuspendDelayReply protobuf.
+  virtual void RegisterDarkSuspendDelayAsync(
+      const std::vector<uint8_t>& in_serialized_request_proto,
+      const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::UnregisterSuspendDelayRequest protobuf.
+  virtual bool UnregisterDarkSuspendDelay(
+      const std::vector<uint8_t>& in_serialized_proto,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::UnregisterSuspendDelayRequest protobuf.
+  virtual void UnregisterDarkSuspendDelayAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::SuspendReadinessInfo protobuf.
+  virtual bool HandleDarkSuspendReadiness(
+      const std::vector<uint8_t>& in_serialized_proto,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::SuspendReadinessInfo protobuf.
+  virtual void HandleDarkSuspendReadinessAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::DarkResumeWakeReason protobuf.
+  virtual bool RecordDarkResumeWakeReason(
+      const std::vector<uint8_t>& in_serialized_proto,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::DarkResumeWakeReason protobuf.
+  virtual void RecordDarkResumeWakeReasonAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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 RegisterBrightnessChangedSignalHandler(
+      const base::Callback<void(int32_t,
+                                bool)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterKeyboardBrightnessChangedSignalHandler(
+      const base::Callback<void(int32_t,
+                                bool)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterPeripheralBatteryStatusSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterPowerSupplyPollSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterSuspendImminentSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterSuspendDoneSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterDarkSuspendImminentSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterInputEventSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterIdleActionImminentSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterIdleActionDeferredSignalHandler(
+      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::PowerManager.
+class PowerManagerProxy final : public PowerManagerProxyInterface {
+ public:
+  PowerManagerProxy(const scoped_refptr<dbus::Bus>& bus) :
+      bus_{bus},
+      dbus_object_proxy_{
+          bus_->GetObjectProxy(service_name_, object_path_)} {
+  }
+
+  ~PowerManagerProxy() override {
+    bus_->RemoveObjectProxy(
+        service_name_, object_path_, base::Bind(&base::DoNothing));
+  }
+
+  void RegisterBrightnessChangedSignalHandler(
+      const base::Callback<void(int32_t,
+                                bool)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "BrightnessChanged",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterKeyboardBrightnessChangedSignalHandler(
+      const base::Callback<void(int32_t,
+                                bool)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "KeyboardBrightnessChanged",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterPeripheralBatteryStatusSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "PeripheralBatteryStatus",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterPowerSupplyPollSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "PowerSupplyPoll",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterSuspendImminentSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "SuspendImminent",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterSuspendDoneSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "SuspendDone",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterDarkSuspendImminentSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "DarkSuspendImminent",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterInputEventSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "InputEvent",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterIdleActionImminentSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "IdleActionImminent",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterIdleActionDeferredSignalHandler(
+      const base::Closure& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.PowerManager",
+        "IdleActionDeferred",
+        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 RequestShutdown(
+      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.PowerManager",
+        "RequestShutdown",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RequestShutdownAsync(
+      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.PowerManager",
+        "RequestShutdown",
+        success_callback,
+        error_callback);
+  }
+
+  // The |reason| arg is a power_manager::RequestRestartReason value.
+  bool RequestRestart(
+      int32_t in_reason,
+      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.PowerManager",
+        "RequestRestart",
+        error,
+        in_reason);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |reason| arg is a power_manager::RequestRestartReason value.
+  void RequestRestartAsync(
+      int32_t in_reason,
+      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.PowerManager",
+        "RequestRestart",
+        success_callback,
+        error_callback,
+        in_reason);
+  }
+
+  // The |external_wakeup_count| arg is optional, and it will call two
+  // different methods in the backend. This can't be expressed in the DBus
+  // Introspection XML file.
+  bool RequestSuspend(
+      uint64_t in_external_wakeup_count,
+      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.PowerManager",
+        "RequestSuspend",
+        error,
+        in_external_wakeup_count);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |external_wakeup_count| arg is optional, and it will call two
+  // different methods in the backend. This can't be expressed in the DBus
+  // Introspection XML file.
+  void RequestSuspendAsync(
+      uint64_t in_external_wakeup_count,
+      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.PowerManager",
+        "RequestSuspend",
+        success_callback,
+        error_callback,
+        in_external_wakeup_count);
+  }
+
+  bool DecreaseScreenBrightness(
+      bool in_allow_off,
+      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.PowerManager",
+        "DecreaseScreenBrightness",
+        error,
+        in_allow_off);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void DecreaseScreenBrightnessAsync(
+      bool in_allow_off,
+      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.PowerManager",
+        "DecreaseScreenBrightness",
+        success_callback,
+        error_callback,
+        in_allow_off);
+  }
+
+  bool IncreaseScreenBrightness(
+      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.PowerManager",
+        "IncreaseScreenBrightness",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void IncreaseScreenBrightnessAsync(
+      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.PowerManager",
+        "IncreaseScreenBrightness",
+        success_callback,
+        error_callback);
+  }
+
+  bool GetScreenBrightnessPercent(
+      double* out_percent,
+      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.PowerManager",
+        "GetScreenBrightnessPercent",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_percent);
+  }
+
+  void GetScreenBrightnessPercentAsync(
+      const base::Callback<void(double /*percent*/)>& 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.PowerManager",
+        "GetScreenBrightnessPercent",
+        success_callback,
+        error_callback);
+  }
+
+  // The |style| arg must be one of the values:
+  //   power_manager::kBrightnessTransitionGradual or
+  //   power_manager::kBrightnessTransitionInstant.
+  bool SetScreenBrightnessPercent(
+      double in_percent,
+      int32_t in_style,
+      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.PowerManager",
+        "SetScreenBrightnessPercent",
+        error,
+        in_percent,
+        in_style);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |style| arg must be one of the values:
+  //   power_manager::kBrightnessTransitionGradual or
+  //   power_manager::kBrightnessTransitionInstant.
+  void SetScreenBrightnessPercentAsync(
+      double in_percent,
+      int32_t in_style,
+      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.PowerManager",
+        "SetScreenBrightnessPercent",
+        success_callback,
+        error_callback,
+        in_percent,
+        in_style);
+  }
+
+  bool DecreaseKeyboardBrightness(
+      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.PowerManager",
+        "DecreaseKeyboardBrightness",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void DecreaseKeyboardBrightnessAsync(
+      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.PowerManager",
+        "DecreaseKeyboardBrightness",
+        success_callback,
+        error_callback);
+  }
+
+  bool IncreaseKeyboardBrightness(
+      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.PowerManager",
+        "IncreaseKeyboardBrightness",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void IncreaseKeyboardBrightnessAsync(
+      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.PowerManager",
+        "IncreaseKeyboardBrightness",
+        success_callback,
+        error_callback);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::PowerSupplyProperties protobuf.
+  bool GetPowerSupplyProperties(
+      std::vector<uint8_t>* out_serialized_proto,
+      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.PowerManager",
+        "GetPowerSupplyProperties",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_serialized_proto);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::PowerSupplyProperties protobuf.
+  void GetPowerSupplyPropertiesAsync(
+      const base::Callback<void(const std::vector<uint8_t>& /*serialized_proto*/)>& 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.PowerManager",
+        "GetPowerSupplyProperties",
+        success_callback,
+        error_callback);
+  }
+
+  bool HandleVideoActivity(
+      bool in_fullscreen,
+      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.PowerManager",
+        "HandleVideoActivity",
+        error,
+        in_fullscreen);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void HandleVideoActivityAsync(
+      bool in_fullscreen,
+      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.PowerManager",
+        "HandleVideoActivity",
+        success_callback,
+        error_callback,
+        in_fullscreen);
+  }
+
+  // The |type| arg is a power_manager::UserActivityType.
+  bool HandleUserActivity(
+      int32_t in_type,
+      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.PowerManager",
+        "HandleUserActivity",
+        error,
+        in_type);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |type| arg is a power_manager::UserActivityType.
+  void HandleUserActivityAsync(
+      int32_t in_type,
+      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.PowerManager",
+        "HandleUserActivity",
+        success_callback,
+        error_callback,
+        in_type);
+  }
+
+  bool SetIsProjecting(
+      bool in_is_projecting,
+      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.PowerManager",
+        "SetIsProjecting",
+        error,
+        in_is_projecting);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetIsProjectingAsync(
+      bool in_is_projecting,
+      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.PowerManager",
+        "SetIsProjecting",
+        success_callback,
+        error_callback,
+        in_is_projecting);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::PowerManagementPolicy protobuf.
+  bool SetPolicy(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "SetPolicy",
+        error,
+        in_serialized_proto);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::PowerManagementPolicy protobuf.
+  void SetPolicyAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "SetPolicy",
+        success_callback,
+        error_callback,
+        in_serialized_proto);
+  }
+
+  bool SetPowerSource(
+      const std::string& in_id,
+      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.PowerManager",
+        "SetPowerSource",
+        error,
+        in_id);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetPowerSourceAsync(
+      const std::string& in_id,
+      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.PowerManager",
+        "SetPowerSource",
+        success_callback,
+        error_callback,
+        in_id);
+  }
+
+  // The |timestamp_internal| arg is represented as the return value of
+  // base::TimeTicks::ToInternalValue().
+  bool HandlePowerButtonAcknowledgment(
+      int64_t in_timestamp_internal,
+      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.PowerManager",
+        "HandlePowerButtonAcknowledgment",
+        error,
+        in_timestamp_internal);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |timestamp_internal| arg is represented as the return value of
+  // base::TimeTicks::ToInternalValue().
+  void HandlePowerButtonAcknowledgmentAsync(
+      int64_t in_timestamp_internal,
+      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.PowerManager",
+        "HandlePowerButtonAcknowledgment",
+        success_callback,
+        error_callback,
+        in_timestamp_internal);
+  }
+
+  // The |serialized_request_proto| arg is a serialized
+  // power_manager::RegisterSuspendDelayRequest protobuf.
+  // The |serialized_reply_proto| arg is a serialized
+  // RegisterSuspendDelayReply protobuf.
+  bool RegisterSuspendDelay(
+      const std::vector<uint8_t>& in_serialized_request_proto,
+      std::vector<uint8_t>* out_serialized_reply_proto,
+      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.PowerManager",
+        "RegisterSuspendDelay",
+        error,
+        in_serialized_request_proto);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_serialized_reply_proto);
+  }
+
+  // The |serialized_request_proto| arg is a serialized
+  // power_manager::RegisterSuspendDelayRequest protobuf.
+  // The |serialized_reply_proto| arg is a serialized
+  // RegisterSuspendDelayReply protobuf.
+  void RegisterSuspendDelayAsync(
+      const std::vector<uint8_t>& in_serialized_request_proto,
+      const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& 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.PowerManager",
+        "RegisterSuspendDelay",
+        success_callback,
+        error_callback,
+        in_serialized_request_proto);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::UnregisterSuspendDelayRequest protobuf.
+  bool UnregisterSuspendDelay(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "UnregisterSuspendDelay",
+        error,
+        in_serialized_proto);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::UnregisterSuspendDelayRequest protobuf.
+  void UnregisterSuspendDelayAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "UnregisterSuspendDelay",
+        success_callback,
+        error_callback,
+        in_serialized_proto);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::SuspendReadinessInfo protobuf.
+  bool HandleSuspendReadiness(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "HandleSuspendReadiness",
+        error,
+        in_serialized_proto);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::SuspendReadinessInfo protobuf.
+  void HandleSuspendReadinessAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "HandleSuspendReadiness",
+        success_callback,
+        error_callback,
+        in_serialized_proto);
+  }
+
+  // The |serialized_request_proto| arg is a serialized
+  // power_manager::RegisterSuspendDelayRequest protobuf.
+  // The |serialized_reply_proto| arg is a serialized
+  // RegisterSuspendDelayReply protobuf.
+  bool RegisterDarkSuspendDelay(
+      const std::vector<uint8_t>& in_serialized_request_proto,
+      std::vector<uint8_t>* out_serialized_reply_proto,
+      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.PowerManager",
+        "RegisterDarkSuspendDelay",
+        error,
+        in_serialized_request_proto);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_serialized_reply_proto);
+  }
+
+  // The |serialized_request_proto| arg is a serialized
+  // power_manager::RegisterSuspendDelayRequest protobuf.
+  // The |serialized_reply_proto| arg is a serialized
+  // RegisterSuspendDelayReply protobuf.
+  void RegisterDarkSuspendDelayAsync(
+      const std::vector<uint8_t>& in_serialized_request_proto,
+      const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& 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.PowerManager",
+        "RegisterDarkSuspendDelay",
+        success_callback,
+        error_callback,
+        in_serialized_request_proto);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::UnregisterSuspendDelayRequest protobuf.
+  bool UnregisterDarkSuspendDelay(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "UnregisterDarkSuspendDelay",
+        error,
+        in_serialized_proto);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::UnregisterSuspendDelayRequest protobuf.
+  void UnregisterDarkSuspendDelayAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "UnregisterDarkSuspendDelay",
+        success_callback,
+        error_callback,
+        in_serialized_proto);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::SuspendReadinessInfo protobuf.
+  bool HandleDarkSuspendReadiness(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "HandleDarkSuspendReadiness",
+        error,
+        in_serialized_proto);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::SuspendReadinessInfo protobuf.
+  void HandleDarkSuspendReadinessAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "HandleDarkSuspendReadiness",
+        success_callback,
+        error_callback,
+        in_serialized_proto);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::DarkResumeWakeReason protobuf.
+  bool RecordDarkResumeWakeReason(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "RecordDarkResumeWakeReason",
+        error,
+        in_serialized_proto);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  // The |serialized_proto| arg is a serialized
+  // power_manager::DarkResumeWakeReason protobuf.
+  void RecordDarkResumeWakeReasonAsync(
+      const std::vector<uint8_t>& in_serialized_proto,
+      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.PowerManager",
+        "RecordDarkResumeWakeReason",
+        success_callback,
+        error_callback,
+        in_serialized_proto);
+  }
+
+ private:
+  scoped_refptr<dbus::Bus> bus_;
+  const std::string service_name_{"org.chromium.PowerManager"};
+  const dbus::ObjectPath object_path_{"/org/chromium/PowerManager"};
+  dbus::ObjectProxy* dbus_object_proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerManagerProxy);
+};
+
+}  // namespace chromium
+}  // namespace org
+
+#endif  // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXIES_H
diff --git a/include/power_manager/dbus-proxy-mocks.h b/include/power_manager/dbus-proxy-mocks.h
new file mode 100644
index 0000000..6fd4acf
--- /dev/null
+++ b/include/power_manager/dbus-proxy-mocks.h
@@ -0,0 +1,266 @@
+// Automatic generation of D-Bus interface mock proxies for:
+//  - org.chromium.PowerManager
+#ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXY_MOCKS_H
+#define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_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 "power_manager/dbus-proxies.h"
+
+namespace org {
+namespace chromium {
+
+// Mock object for PowerManagerProxyInterface.
+class PowerManagerProxyMock : public PowerManagerProxyInterface {
+ public:
+  PowerManagerProxyMock() = default;
+
+  MOCK_METHOD2(RequestShutdown,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RequestShutdownAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RequestRestart,
+               bool(int32_t /*in_reason*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RequestRestartAsync,
+               void(int32_t /*in_reason*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RequestSuspend,
+               bool(uint64_t /*in_external_wakeup_count*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RequestSuspendAsync,
+               void(uint64_t /*in_external_wakeup_count*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(DecreaseScreenBrightness,
+               bool(bool /*in_allow_off*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(DecreaseScreenBrightnessAsync,
+               void(bool /*in_allow_off*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(IncreaseScreenBrightness,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(IncreaseScreenBrightnessAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetScreenBrightnessPercent,
+               bool(double* /*out_percent*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetScreenBrightnessPercentAsync,
+               void(const base::Callback<void(double /*percent*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetScreenBrightnessPercent,
+               bool(double /*in_percent*/,
+                    int32_t /*in_style*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(SetScreenBrightnessPercentAsync,
+               void(double /*in_percent*/,
+                    int32_t /*in_style*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(DecreaseKeyboardBrightness,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(DecreaseKeyboardBrightnessAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(IncreaseKeyboardBrightness,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(IncreaseKeyboardBrightnessAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetPowerSupplyProperties,
+               bool(std::vector<uint8_t>* /*out_serialized_proto*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetPowerSupplyPropertiesAsync,
+               void(const base::Callback<void(const std::vector<uint8_t>& /*serialized_proto*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(HandleVideoActivity,
+               bool(bool /*in_fullscreen*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(HandleVideoActivityAsync,
+               void(bool /*in_fullscreen*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(HandleUserActivity,
+               bool(int32_t /*in_type*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(HandleUserActivityAsync,
+               void(int32_t /*in_type*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetIsProjecting,
+               bool(bool /*in_is_projecting*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetIsProjectingAsync,
+               void(bool /*in_is_projecting*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetPolicy,
+               bool(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetPolicyAsync,
+               void(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetPowerSource,
+               bool(const std::string& /*in_id*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetPowerSourceAsync,
+               void(const std::string& /*in_id*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(HandlePowerButtonAcknowledgment,
+               bool(int64_t /*in_timestamp_internal*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(HandlePowerButtonAcknowledgmentAsync,
+               void(int64_t /*in_timestamp_internal*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RegisterSuspendDelay,
+               bool(const std::vector<uint8_t>& /*in_serialized_request_proto*/,
+                    std::vector<uint8_t>* /*out_serialized_reply_proto*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RegisterSuspendDelayAsync,
+               void(const std::vector<uint8_t>& /*in_serialized_request_proto*/,
+                    const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(UnregisterSuspendDelay,
+               bool(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(UnregisterSuspendDelayAsync,
+               void(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(HandleSuspendReadiness,
+               bool(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(HandleSuspendReadinessAsync,
+               void(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RegisterDarkSuspendDelay,
+               bool(const std::vector<uint8_t>& /*in_serialized_request_proto*/,
+                    std::vector<uint8_t>* /*out_serialized_reply_proto*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RegisterDarkSuspendDelayAsync,
+               void(const std::vector<uint8_t>& /*in_serialized_request_proto*/,
+                    const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(UnregisterDarkSuspendDelay,
+               bool(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(UnregisterDarkSuspendDelayAsync,
+               void(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(HandleDarkSuspendReadiness,
+               bool(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(HandleDarkSuspendReadinessAsync,
+               void(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RecordDarkResumeWakeReason,
+               bool(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RecordDarkResumeWakeReasonAsync,
+               void(const std::vector<uint8_t>& /*in_serialized_proto*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RegisterBrightnessChangedSignalHandler,
+               void(const base::Callback<void(int32_t,
+                                              bool)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterKeyboardBrightnessChangedSignalHandler,
+               void(const base::Callback<void(int32_t,
+                                              bool)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterPeripheralBatteryStatusSignalHandler,
+               void(const base::Callback<void(const std::vector<uint8_t>&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterPowerSupplyPollSignalHandler,
+               void(const base::Callback<void(const std::vector<uint8_t>&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterSuspendImminentSignalHandler,
+               void(const base::Callback<void(const std::vector<uint8_t>&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterSuspendDoneSignalHandler,
+               void(const base::Callback<void(const std::vector<uint8_t>&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterDarkSuspendImminentSignalHandler,
+               void(const base::Callback<void(const std::vector<uint8_t>&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterInputEventSignalHandler,
+               void(const base::Callback<void(const std::vector<uint8_t>&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterIdleActionImminentSignalHandler,
+               void(const base::Callback<void(const std::vector<uint8_t>&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterIdleActionDeferredSignalHandler,
+               void(const base::Closure& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PowerManagerProxyMock);
+};
+}  // namespace chromium
+}  // namespace org
+
+#endif  // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXY_MOCKS_H
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
diff --git a/include/shill/dbus-constants.h b/include/shill/dbus-constants.h
new file mode 100644
index 0000000..b3ad4bc
--- /dev/null
+++ b/include/shill/dbus-constants.h
@@ -0,0 +1,710 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SYSTEM_API_DBUS_SHILL_DBUS_CONSTANTS_H_
+#define SYSTEM_API_DBUS_SHILL_DBUS_CONSTANTS_H_
+
+// TODO(benchan): Reorganize shill constants and remove deprecated ones.
+namespace shill {
+// Flimflam D-Bus service identifiers.
+const char kFlimflamManagerInterface[] = "org.chromium.flimflam.Manager";
+const char kFlimflamServiceName[] = "org.chromium.flimflam";
+const char kFlimflamServicePath[] = "/";  // crosbug.com/20135
+const char kFlimflamServiceInterface[] = "org.chromium.flimflam.Service";
+const char kFlimflamIPConfigInterface[] = "org.chromium.flimflam.IPConfig";
+const char kFlimflamDeviceInterface[] = "org.chromium.flimflam.Device";
+const char kFlimflamProfileInterface[] = "org.chromium.flimflam.Profile";
+const char kFlimflamNetworkInterface[] = "org.chromium.flimflam.Network";
+const char kFlimflamThirdPartyVpnInterface[] =
+    "org.chromium.flimflam.ThirdPartyVpn";
+
+// Flimflam function names.
+const char kGetPropertiesFunction[] = "GetProperties";
+const char kSetPropertyFunction[] = "SetProperty";
+const char kClearPropertyFunction[] = "ClearProperty";
+const char kConnectFunction[] = "Connect";
+const char kDisconnectFunction[] = "Disconnect";
+const char kRequestScanFunction[] = "RequestScan";
+const char kGetServiceFunction[] = "GetService";
+const char kGetWifiServiceFunction[] = "GetWifiService";
+const char kGetVPNServiceFunction[] = "GetVPNService";
+const char kRemoveServiceFunction[] = "Remove";
+const char kEnableTechnologyFunction[] = "EnableTechnology";
+const char kDisableTechnologyFunction[] = "DisableTechnology";
+const char kAddIPConfigFunction[] = "AddIPConfig";
+const char kRemoveConfigFunction[] = "Remove";
+const char kGetEntryFunction[] = "GetEntry";
+const char kDeleteEntryFunction[] = "DeleteEntry";
+const char kActivateCellularModemFunction[] = "ActivateCellularModem";
+const char kRequirePinFunction[] = "RequirePin";
+const char kEnterPinFunction[] = "EnterPin";
+const char kUnblockPinFunction[] = "UnblockPin";
+const char kChangePinFunction[] = "ChangePin";
+const char kProposeScanFunction[] = "ProposeScan";
+const char kRegisterFunction[] = "Register";
+const char kConfigureServiceFunction[] = "ConfigureService";
+const char kConfigureWifiServiceFunction[] = "ConfigureWifiService";
+const char kFindMatchingServiceFunction[] = "FindMatchingService";
+
+// Flimflam Service property names.
+const char kSecurityProperty[] = "Security";
+const char kPriorityProperty[] = "Priority";
+const char kPriorityWithinTechnologyProperty[] = "PriorityWithinTechnology";
+const char kPassphraseProperty[] = "Passphrase";
+const char kIdentityProperty[] = "Identity";
+const char kAuthorityPathProperty[] = "AuthorityPath";
+const char kPassphraseRequiredProperty[] = "PassphraseRequired";
+const char kSaveCredentialsProperty[] = "SaveCredentials";
+const char kSignalStrengthProperty[] = "Strength";
+const char kNameProperty[] = "Name";
+const char kGuidProperty[] = "GUID";
+const char kStateProperty[] = "State";
+const char kTypeProperty[] = "Type";
+const char kDeviceProperty[] = "Device";
+const char kProfileProperty[] = "Profile";
+const char kConnectivityStateProperty[] = "ConnectivityState";
+const char kConnectableProperty[] = "Connectable";
+const char kAutoConnectProperty[] = "AutoConnect";
+const char kIsActiveProperty[] = "IsActive";
+const char kModeProperty[] = "Mode";
+const char kErrorProperty[] = "Error";
+const char kProviderProperty[] = "Provider";
+const char kHostProperty[] = "Host";
+const char kDomainProperty[] = "Domain";
+const char kProxyConfigProperty[] = "ProxyConfig";
+const char kCheckPortalProperty[] = "CheckPortal";
+const char kSSIDProperty[] = "SSID";
+const char kConnectedProperty[] = "Connected";
+const char kUIDataProperty[] = "UIData";
+const char kConnectionIdProperty[] = "ConnectionId";
+const char kVisibleProperty[] = "Visible";
+const char kDnsAutoFallbackProperty[] = "DNSAutoFallback";
+const char kPortalDetectionFailedPhaseProperty[] =
+    "PortalDetectionFailedPhase";
+const char kPortalDetectionFailedStatusProperty[] =
+    "PortalDetectionFailedStatus";
+const char kSavedIPConfigProperty[] = "SavedIPConfig";
+const char kStaticIPConfigProperty[] = "StaticIPConfig";
+const char kLinkMonitorDisableProperty[] = "LinkMonitorDisable";
+const char kSecurityClassProperty[] = "SecurityClass";
+
+// Flimflam provider property names.
+const char kProviderHostProperty[] = "Provider.Host";
+const char kProviderNameProperty[] = "Provider.Name";
+const char kProviderTypeProperty[] = "Provider.Type";
+
+// Flimflam Wifi Service property names.
+const char kWifiBSsid[] = "WiFi.BSSID";
+const char kWifiHexSsid[] = "WiFi.HexSSID";
+const char kWifiFrequency[] = "WiFi.Frequency";
+const char kWifiHiddenSsid[] = "WiFi.HiddenSSID";
+const char kWifiPhyMode[] = "WiFi.PhyMode";
+const char kWifiAuthMode[] = "WiFi.AuthMode";
+const char kWifiChannelProperty[] = "WiFi.Channel";
+const char kWifiPreferredDeviceProperty[] = "WiFi.PreferredDevice";
+const char kWifiRoamThresholdProperty[] = "WiFi.RoamThreshold";
+
+// Flimflam EAP property names.
+const char kEapIdentityProperty[] = "EAP.Identity";
+const char kEapMethodProperty[] = "EAP.EAP";
+const char kEapPhase2AuthProperty[] = "EAP.InnerEAP";
+const char kEapAnonymousIdentityProperty[] = "EAP.AnonymousIdentity";
+const char kEapClientCertProperty[] = "EAP.ClientCert";
+const char kEapCertIdProperty[] = "EAP.CertID";
+const char kEapClientCertNssProperty[] = "EAP.ClientCertNSS";
+const char kEapPrivateKeyProperty[] = "EAP.PrivateKey";
+const char kEapPrivateKeyPasswordProperty[] = "EAP.PrivateKeyPassword";
+const char kEapKeyIdProperty[] = "EAP.KeyID";
+const char kEapCaCertProperty[] = "EAP.CACert";
+const char kEapCaCertIdProperty[] = "EAP.CACertID";
+const char kEapCaCertNssProperty[] = "EAP.CACertNSS";
+const char kEapUseSystemCasProperty[] = "EAP.UseSystemCAs";
+const char kEapUseProactiveKeyCachingProperty[] = "EAP.UseProactiveKeyCaching";
+const char kEapPinProperty[] = "EAP.PIN";
+const char kEapPasswordProperty[] = "EAP.Password";
+const char kEapKeyMgmtProperty[] = "EAP.KeyMgmt";
+
+// Flimflam Cellular Service property names.
+const char kTechnologyFamilyProperty[] = "Cellular.Family";
+const char kActivationStateProperty[] = "Cellular.ActivationState";
+const char kNetworkTechnologyProperty[] = "Cellular.NetworkTechnology";
+const char kRoamingStateProperty[] = "Cellular.RoamingState";
+const char kOperatorNameProperty[] = "Cellular.OperatorName";
+const char kOperatorCodeProperty[] = "Cellular.OperatorCode";
+const char kServingOperatorProperty[] = "Cellular.ServingOperator";
+const char kPaymentPortalProperty[] = "Cellular.Olp";
+const char kUsageURLProperty[] = "Cellular.UsageUrl";
+const char kCellularApnProperty[] = "Cellular.APN";
+const char kCellularLastGoodApnProperty[] = "Cellular.LastGoodAPN";
+const char kCellularApnListProperty[] = "Cellular.APNList";
+
+// Flimflam Manager property names.
+const char kProfilesProperty[] = "Profiles";
+const char kServicesProperty[] = "Services";
+const char kServiceWatchListProperty[] = "ServiceWatchList";
+const char kAvailableTechnologiesProperty[] = "AvailableTechnologies";
+const char kEnabledTechnologiesProperty[] = "EnabledTechnologies";
+const char kConnectedTechnologiesProperty[] = "ConnectedTechnologies";
+const char kDefaultTechnologyProperty[] = "DefaultTechnology";
+const char kOfflineModeProperty[] = "OfflineMode";
+const char kActiveProfileProperty[] = "ActiveProfile";
+const char kDevicesProperty[] = "Devices";
+const char kCheckPortalListProperty[] = "CheckPortalList";
+const char kArpGatewayProperty[] = "ArpGateway";
+const char kCountryProperty[] = "Country";
+const char kPortalURLProperty[] = "PortalURL";
+const char kConnectionStateProperty[] = "ConnectionState";
+const char kClaimedDevicesProperty[] = "ClaimedDevices";
+
+// Flimflam Profile property names.
+const char kEntriesProperty[] = "Entries";
+
+// Flimflam Device property names.
+const char kScanningProperty[] = "Scanning";
+const char kPoweredProperty[] = "Powered";
+const char kNetworksProperty[] = "Networks";
+const char kScanIntervalProperty[] = "ScanInterval";
+const char kBgscanMethodProperty[] = "BgscanMethod";
+const char kBgscanShortIntervalProperty[] = "BgscanShortInterval";
+const char kRoamThresholdProperty[] = "RoamThreshold";
+const char kDBusObjectProperty[] = "DBus.Object";
+const char kDBusServiceProperty[] = "DBus.Service";
+const char kBgscanSignalThresholdProperty[] = "BgscanSignalThreshold";
+const char kWakeToScanPeriodSecondsProperty[] = "WakeToScanPeriodSeconds";
+const char kNetDetectScanPeriodSecondsProperty[] = "NetDetectScanPeriodSeconds";
+const char kForceWakeToScanTimerProperty[] = "ForceWakeToScanTimer";
+// The name of the network interface, ie. wlan0, eth0, etc.
+const char kInterfaceProperty[] = "Interface";
+const char kSelectedServiceProperty[] = "SelectedService";
+const char kIPConfigsProperty[] = "IPConfigs";
+
+// Flimflam Cellular Device property names.
+const char kCarrierProperty[] = "Cellular.Carrier";
+const char kCellularAllowRoamingProperty[] = "Cellular.AllowRoaming";
+const char kHomeProviderProperty[] = "Cellular.HomeProvider";
+const char kMeidProperty[] = "Cellular.MEID";
+const char kImeiProperty[] = "Cellular.IMEI";
+const char kIccidProperty[] = "Cellular.ICCID";
+const char kImsiProperty[] = "Cellular.IMSI";
+const char kEsnProperty[] = "Cellular.ESN";
+const char kMdnProperty[] = "Cellular.MDN";
+const char kMinProperty[] = "Cellular.MIN";
+const char kModelIDProperty[] = "Cellular.ModelID";
+const char kManufacturerProperty[] = "Cellular.Manufacturer";
+const char kFirmwareRevisionProperty[] = "Cellular.FirmwareRevision";
+const char kHardwareRevisionProperty[] = "Cellular.HardwareRevision";
+const char kPRLVersionProperty[] = "Cellular.PRLVersion";
+const char kSelectedNetworkProperty[] = "Cellular.SelectedNetwork";
+const char kSupportNetworkScanProperty[] = "Cellular.SupportNetworkScan";
+const char kFoundNetworksProperty[] = "Cellular.FoundNetworks";
+
+// Flimflam state options.
+const char kStateIdle[] = "idle";
+const char kStateCarrier[] = "carrier";
+const char kStateAssociation[] = "association";
+const char kStateConfiguration[] = "configuration";
+const char kStateReady[] = "ready";
+const char kStatePortal[] = "portal";
+const char kStateOffline[] = "offline";
+const char kStateOnline[] = "online";
+const char kStateDisconnect[] = "disconnect";
+const char kStateFailure[] = "failure";
+const char kStateActivationFailure[] = "activation-failure";
+
+// Flimflam portal phase and status.
+const char kPortalDetectionPhaseConnection[] = "Connection";
+const char kPortalDetectionPhaseDns[] = "DNS";
+const char kPortalDetectionPhaseHttp[] = "HTTP";
+const char kPortalDetectionPhaseContent[] = "Content";
+const char kPortalDetectionPhaseUnknown[] = "Unknown";
+const char kPortalDetectionStatusFailure[] = "Failure";
+const char kPortalDetectionStatusTimeout[] = "Timeout";
+const char kPortalDetectionStatusSuccess[] = "Success";
+
+// Flimflam property names for SIMLock status.
+const char kSIMLockStatusProperty[] = "Cellular.SIMLockStatus";
+const char kSIMLockTypeProperty[] = "LockType";
+const char kSIMLockRetriesLeftProperty[] = "RetriesLeft";
+const char kSIMLockEnabledProperty[] = "LockEnabled";
+
+// Flimflam property names for Cellular.FoundNetworks.
+const char kLongNameProperty[] = "long_name";
+const char kStatusProperty[] = "status";
+const char kShortNameProperty[] = "short_name";
+const char kTechnologyProperty[] = "technology";
+const char kNetworkIdProperty[] = "network_id";
+
+// Flimflam SIMLock status types.
+const char kSIMLockPin[] = "sim-pin";
+const char kSIMLockPuk[] = "sim-puk";
+
+// APN info property names.
+const char kApnProperty[] = "apn";
+const char kApnNetworkIdProperty[] = "network_id";
+const char kApnUsernameProperty[] = "username";
+const char kApnPasswordProperty[] = "password";
+const char kApnNameProperty[] = "name";
+const char kApnLocalizedNameProperty[] = "localized_name";
+const char kApnLanguageProperty[] = "language";
+
+// Payment Portal property names.
+const char kPaymentPortalURL[] = "url";
+const char kPaymentPortalMethod[] = "method";
+const char kPaymentPortalPostData[] = "postdata";
+
+// Operator info property names.
+const char kOperatorNameKey[] = "name";
+const char kOperatorCodeKey[] = "code";
+const char kOperatorCountryKey[] = "country";
+
+// Flimflam network technology options.
+const char kNetworkTechnology1Xrtt[] = "1xRTT";
+const char kNetworkTechnologyEvdo[] = "EVDO";
+const char kNetworkTechnologyGsm[] = "GSM";
+const char kNetworkTechnologyGprs[] = "GPRS";
+const char kNetworkTechnologyEdge[] = "EDGE";
+const char kNetworkTechnologyUmts[] = "UMTS";
+const char kNetworkTechnologyHspa[] = "HSPA";
+const char kNetworkTechnologyHspaPlus[] = "HSPA+";
+const char kNetworkTechnologyLte[] = "LTE";
+const char kNetworkTechnologyLteAdvanced[] = "LTE Advanced";
+
+// Flimflam roaming state options
+const char kRoamingStateHome[] = "home";
+const char kRoamingStateRoaming[] = "roaming";
+const char kRoamingStateUnknown[] = "unknown";
+
+// Flimflam activation state options
+const char kActivationStateActivated[] = "activated";
+const char kActivationStateActivating[] = "activating";
+const char kActivationStateNotActivated[] = "not-activated";
+const char kActivationStatePartiallyActivated[] = "partially-activated";
+const char kActivationStateUnknown[] = "unknown";
+
+// Flimflam EAP method options.
+const char kEapMethodPEAP[] = "PEAP";
+const char kEapMethodTLS[] = "TLS";
+const char kEapMethodTTLS[] = "TTLS";
+const char kEapMethodLEAP[] = "LEAP";
+
+// Flimflam EAP phase 2 auth options.
+const char kEapPhase2AuthPEAPMD5[] = "auth=MD5";
+const char kEapPhase2AuthPEAPMSCHAPV2[] = "auth=MSCHAPV2";
+const char kEapPhase2AuthPEAPGTC[] = "auth=GTC";
+const char kEapPhase2AuthTTLSMD5[] = "autheap=MD5";  // crosbug/26822
+const char kEapPhase2AuthTTLSEAPMD5[] = "autheap=MD5";
+const char kEapPhase2AuthTTLSEAPMSCHAPV2[] = "autheap=MSCHAPV2";
+const char kEapPhase2AuthTTLSMSCHAPV2[] = "auth=MSCHAPV2";
+const char kEapPhase2AuthTTLSMSCHAP[] = "auth=MSCHAP";
+const char kEapPhase2AuthTTLSPAP[] = "auth=PAP";
+const char kEapPhase2AuthTTLSCHAP[] = "auth=CHAP";
+const char kEapPhase2AuthTTLSGTC[] = "auth=GTC";
+const char kEapPhase2AuthTTLSEAPGTC[] = "autheap=GTC";
+
+// Flimflam VPN provider types.
+const char kProviderL2tpIpsec[] = "l2tpipsec";
+const char kProviderOpenVpn[] = "openvpn";
+const char kProviderThirdPartyVpn[] = "thirdpartyvpn";
+
+// Flimflam VPN service properties
+const char kVPNDomainProperty[] = "VPN.Domain";
+
+// Flimflam monitored properties
+const char kMonitorPropertyChanged[] = "PropertyChanged";
+
+// Flimflam type options.
+const char kTypeEthernet[] = "ethernet";
+const char kTypeWifi[] = "wifi";
+const char kTypeWimax[] = "wimax";
+const char kTypeBluetooth[] = "bluetooth";
+const char kTypeCellular[] = "cellular";
+const char kTypeVPN[] = "vpn";
+const char kTypePPPoE[] = "pppoe";
+
+// Flimflam mode options.
+const char kModeManaged[] = "managed";
+const char kModeAdhoc[] = "adhoc";
+
+// Flimflam security options.
+const char kSecurityWpa[] = "wpa";
+const char kSecurityWep[] = "wep";
+const char kSecurityRsn[] = "rsn";
+const char kSecurity8021x[] = "802_1x";
+const char kSecurityPsk[] = "psk";
+const char kSecurityNone[] = "none";
+
+// Flimflam L2TPIPsec property names.
+const char kL2tpIpsecAuthenticationType[] = "L2TPIPsec.AuthenticationType";
+const char kL2tpIpsecCaCertNssProperty[] = "L2TPIPsec.CACertNSS";
+const char kL2tpIpsecClientCertIdProperty[] = "L2TPIPsec.ClientCertID";
+const char kL2tpIpsecClientCertSlotProperty[] = "L2TPIPsec.ClientCertSlot";
+const char kL2tpIpsecIkeVersion[] = "L2TPIPsec.IKEVersion";
+const char kL2tpIpsecPinProperty[] = "L2TPIPsec.PIN";
+const char kL2tpIpsecPskProperty[] = "L2TPIPsec.PSK";
+const char kL2tpIpsecPskRequiredProperty[] = "L2TPIPsec.PSKRequired";
+const char kL2tpIpsecUserProperty[] = "L2TPIPsec.User";
+const char kL2tpIpsecPasswordProperty[] = "L2TPIPsec.Password";
+
+// Flimflam OpenVPN property names.
+const char kOpenVPNAuthNoCacheProperty[] = "OpenVPN.AuthNoCache";
+const char kOpenVPNAuthProperty[] = "OpenVPN.Auth";
+const char kOpenVPNAuthRetryProperty[] = "OpenVPN.AuthRetry";
+const char kOpenVPNAuthUserPassProperty[] = "OpenVPN.AuthUserPass";
+const char kOpenVPNCaCertProperty[] = "OpenVPN.CACert";
+const char kOpenVPNCaCertNSSProperty[] = "OpenVPN.CACertNSS";
+const char kOpenVPNClientCertIdProperty[] = "OpenVPN.Pkcs11.ID";
+const char kOpenVPNClientCertSlotProperty[] = "OpenVPN.Pkcs11.Slot";
+const char kOpenVPNCipherProperty[] = "OpenVPN.Cipher";
+const char kOpenVPNCompLZOProperty[] = "OpenVPN.CompLZO";
+const char kOpenVPNCompNoAdaptProperty[] = "OpenVPN.CompNoAdapt";
+const char kOpenVPNIgnoreDefaultRouteProperty[] = "OpenVPN.IgnoreDefaultRoute";
+const char kOpenVPNKeyDirectionProperty[] = "OpenVPN.KeyDirection";
+const char kOpenVPNMgmtEnableProperty[] = "OpenVPN.Mgmt.Enable";
+const char kOpenVPNNsCertTypeProperty[] = "OpenVPN.NsCertType";
+const char kOpenVPNOTPProperty[] = "OpenVPN.OTP";
+const char kOpenVPNPasswordProperty[] = "OpenVPN.Password";
+const char kOpenVPNPinProperty[] = "OpenVPN.Pkcs11.PIN";
+const char kOpenVPNPortProperty[] = "OpenVPN.Port";
+const char kOpenVPNProtoProperty[] = "OpenVPN.Proto";
+const char kOpenVPNProviderProperty[] = "OpenVPN.Pkcs11.Provider";
+const char kOpenVPNPushPeerInfoProperty[] = "OpenVPN.PushPeerInfo";
+const char kOpenVPNRemoteCertEKUProperty[] = "OpenVPN.RemoteCertEKU";
+const char kOpenVPNRemoteCertKUProperty[] = "OpenVPN.RemoteCertKU";
+const char kOpenVPNRemoteCertTLSProperty[] = "OpenVPN.RemoteCertTLS";
+const char kOpenVPNRenegSecProperty[] = "OpenVPN.RenegSec";
+const char kOpenVPNServerPollTimeoutProperty[] = "OpenVPN.ServerPollTimeout";
+const char kOpenVPNShaperProperty[] = "OpenVPN.Shaper";
+const char kOpenVPNStaticChallengeProperty[] = "OpenVPN.StaticChallenge";
+const char kOpenVPNTLSAuthContentsProperty[] = "OpenVPN.TLSAuthContents";
+const char kOpenVPNTLSRemoteProperty[] = "OpenVPN.TLSRemote";
+const char kOpenVPNUserProperty[] = "OpenVPN.User";
+
+// FlimFlam PPPoE property names.
+const char kPPPoEUsernameProperty[] = "PPPoE.Username";
+const char kPPPoEPasswordProperty[] = "PPPoE.Password";
+const char kPPPoELCPEchoIntervalProperty[] = "PPPoE.LCPEchoInterval";
+const char kPPPoELCPEchoFailureProperty[] = "PPPoE.LCPEchoFailure";
+const char kPPPoEMaxAuthFailureProperty[] = "PPPoE.MaxAuthFailure";
+
+// FlimFlam technology family options
+const char kTechnologyFamilyCdma[] = "CDMA";
+const char kTechnologyFamilyGsm[] = "GSM";
+
+// IPConfig property names.
+const char kMethodProperty[] = "Method";
+const char kAddressProperty[] = "Address";
+const char kMtuProperty[] = "Mtu";
+const char kPrefixlenProperty[] = "Prefixlen";
+const char kBroadcastProperty[] = "Broadcast";
+const char kPeerAddressProperty[] = "PeerAddress";
+const char kGatewayProperty[] = "Gateway";
+const char kDomainNameProperty[] = "DomainName";
+const char kAcceptedHostnameProperty[] = "AcceptedHostname";
+const char kNameServersProperty[] = "NameServers";
+const char kDelegatedPrefixProperty[] = "DelegatedPrefix";
+const char kDelegatedPrefixLengthProperty[] = "DelegatedPrefixLength";
+
+// IPConfig type options.
+const char kTypeIPv4[] = "ipv4";
+const char kTypeIPv6[] = "ipv6";
+const char kTypeDHCP[] = "dhcp";
+const char kTypeBOOTP[] = "bootp";
+const char kTypeZeroConf[] = "zeroconf";
+const char kTypeDHCP6[] = "dhcp6";
+const char kTypePPP[] = "ppp";
+
+// Flimflam error options.
+const char kErrorAaaFailed[] = "aaa-failed";
+const char kErrorActivationFailed[] = "activation-failed";
+const char kErrorBadPassphrase[] = "bad-passphrase";
+const char kErrorBadWEPKey[] = "bad-wepkey";
+const char kErrorConnectFailed[] = "connect-failed";
+const char kErrorDNSLookupFailed[] = "dns-lookup-failed";
+const char kErrorDhcpFailed[] = "dhcp-failed";
+const char kErrorHTTPGetFailed[] = "http-get-failed";
+const char kErrorInternal[] = "internal-error";
+const char kErrorIpsecCertAuthFailed[] = "ipsec-cert-auth-failed";
+const char kErrorIpsecPskAuthFailed[] = "ipsec-psk-auth-failed";
+const char kErrorNeedEvdo[] = "need-evdo";
+const char kErrorNeedHomeNetwork[] = "need-home-network";
+const char kErrorOtaspFailed[] = "otasp-failed";
+const char kErrorOutOfRange[] = "out-of-range";
+const char kErrorPinMissing[] = "pin-missing";
+const char kErrorPppAuthFailed[] = "ppp-auth-failed";
+
+// Flimflam error result codes.
+const char kErrorResultSuccess[] = "org.chromium.flimflam.Error.Success";
+const char kErrorResultFailure[] = "org.chromium.flimflam.Error.Failure";
+const char kErrorResultAlreadyConnected[] =
+    "org.chromium.flimflam.Error.AlreadyConnected";
+const char kErrorResultAlreadyExists[] =
+    "org.chromium.flimflam.Error.AlreadyExists";
+const char kErrorResultIncorrectPin[] =
+     "org.chromium.flimflam.Error.IncorrectPin";
+const char kErrorResultInProgress[] = "org.chromium.flimflam.Error.InProgress";
+const char kErrorResultInternalError[] =
+    "org.chromium.flimflam.Error.InternalError";
+const char kErrorResultInvalidApn[] = "org.chromium.flimflam.Error.InvalidApn";
+const char kErrorResultInvalidArguments[] =
+    "org.chromium.flimflam.Error.InvalidArguments";
+const char kErrorResultInvalidNetworkName[] =
+    "org.chromium.flimflam.Error.InvalidNetworkName";
+const char kErrorResultInvalidPassphrase[] =
+    "org.chromium.flimflam.Error.InvalidPassphrase";
+const char kErrorResultInvalidProperty[] =
+    "org.chromium.flimflam.Error.InvalidProperty";
+const char kErrorResultNoCarrier[] = "org.chromium.flimflam.Error.NoCarrier";
+const char kErrorResultNotConnected[] =
+     "org.chromium.flimflam.Error.NotConnected";
+const char kErrorResultNotFound[] = "org.chromium.flimflam.Error.NotFound";
+const char kErrorResultNotImplemented[] =
+    "org.chromium.flimflam.Error.NotImplemented";
+const char kErrorResultNotOnHomeNetwork[] =
+    "org.chromium.flimflam.Error.NotOnHomeNetwork";
+const char kErrorResultNotRegistered[] =
+    "org.chromium.flimflam.Error.NotRegistered";
+const char kErrorResultNotSupported[] =
+     "org.chromium.flimflam.Error.NotSupported";
+const char kErrorResultOperationAborted[] =
+    "org.chromium.flimflam.Error.OperationAborted";
+const char kErrorResultOperationInitiated[] =
+    "org.chromium.flimflam.Error.OperationInitiated";
+const char kErrorResultOperationTimeout[] =
+    "org.chromium.flimflam.Error.OperationTimeout";
+const char kErrorResultPassphraseRequired[] =
+    "org.chromium.flimflam.Error.PassphraseRequired";
+const char kErrorResultPermissionDenied[] =
+    "org.chromium.flimflam.Error.PermissionDenied";
+const char kErrorResultPinBlocked[] = "org.chromium.flimflam.Error.PinBlocked";
+const char kErrorResultPinRequired[] =
+     "org.chromium.flimflam.Error.PinRequired";
+const char kErrorResultWrongState[] = "org.chromium.flimflam.Error.WrongState";
+
+const char kUnknownString[] = "UNKNOWN";
+
+// Function names.
+const char kClearPropertiesFunction[] = "ClearProperties";
+const char kCompleteCellularActivationFunction[] = "CompleteCellularActivation";
+const char kConfigureServiceForProfileFunction[] = "ConfigureServiceForProfile";
+const char kConnectToBestServicesFunction[] = "ConnectToBestServices";
+const char kCreateConnectivityReportFunction[] = "CreateConnectivityReport";
+const char kAddWakeOnPacketConnectionFunction[] = "AddWakeOnPacketConnection";
+const char kRemoveWakeOnPacketConnectionFunction[] =
+    "RemoveWakeOnPacketConnection";
+const char kRemoveAllWakeOnPacketConnectionsFunction[] =
+    "RemoveAllWakeOnPacketConnections";
+const char kGetLoadableProfileEntriesFunction[] = "GetLoadableProfileEntries";
+const char kGetNetworksForGeolocation[] = "GetNetworksForGeolocation";
+const char kPerformTDLSOperationFunction[] = "PerformTDLSOperation";
+const char kRefreshFunction[] = "Refresh";
+const char kResetFunction[] = "Reset";
+const char kSetCarrierFunction[] = "SetCarrier";
+const char kSetPropertiesFunction[] = "SetProperties";
+const char kVerifyAndEncryptCredentialsFunction[] =
+    "VerifyAndEncryptCredentials";
+const char kVerifyAndEncryptDataFunction[] = "VerifyAndEncryptData";
+const char kVerifyDestinationFunction[] = "VerifyDestination";
+
+// ThirdPartyVpn functions.
+const char kSetParametersFunction[] = "SetParameters";
+const char kSendPacketFunction[] = "SendPacket";
+const char kUpdateConnectionStateFunction[] = "UpdateConnectionState";
+const char kOnPacketReceivedFunction[] = "OnPacketReceived";
+const char kOnPlatformMessageFunction[] = "OnPlatformMessage";
+
+// Device property names.
+const char kEapAuthenticationCompletedProperty[] = "EapAuthenticationCompleted";
+const char kEapAuthenticatorDetectedProperty[] = "EapAuthenticatorDetected";
+const char kLinkMonitorResponseTimeProperty[] = "LinkMonitorResponseTime";
+const char kLinkUpProperty[] = "Ethernet.LinkUp";
+const char kProviderRequiresRoamingProperty[] =
+    "Cellular.ProviderRequiresRoaming";
+const char kPPPoEProperty[] = "Ethernet.PPPoE";
+const char kReceiveByteCountProperty[] = "ReceiveByteCount";
+const char kSIMPresentProperty[] = "Cellular.SIMPresent";
+const char kSupportedCarriersProperty[] = "Cellular.SupportedCarriers";
+const char kTransmitByteCountProperty[] = "TransmitByteCount";
+
+// Technology types (augments "Flimflam type options" above).
+const char kTypeEthernetEap[] = "etherneteap";
+
+// Error strings.
+const char kErrorEapAuthenticationFailed[] = "eap-authentication-failed";
+const char kErrorEapLocalTlsFailed[] = "eap-local-tls-failed";
+const char kErrorEapRemoteTlsFailed[] = "eap-remote-tls-failed";
+
+// IPConfig property names.
+const char kSearchDomainsProperty[] = "SearchDomains";
+const char kVendorEncapsulatedOptionsProperty[] = "VendorEncapsulatedOptions";
+const char kWebProxyAutoDiscoveryUrlProperty[] = "WebProxyAutoDiscoveryUrl";
+
+// Manager property names.
+const char kDefaultServiceProperty[] = "DefaultService";
+const char kDisableWiFiVHTProperty[] = "DisableWiFiVHT";
+const char kHostNameProperty[] = "HostName";
+const char kIgnoredDNSSearchPathsProperty[] = "IgnoredDNSSearchPaths";
+const char kLinkMonitorTechnologiesProperty[] =
+    "LinkMonitorTechnologies";
+const char kNoAutoConnectTechnologiesProperty[] = "NoAutoConnectTechnologies";
+const char kPortalCheckIntervalProperty[] = "PortalCheckInterval";
+const char kProhibitedTechnologiesProperty[] = "ProhibitedTechnologies";
+const char kServiceCompleteListProperty[] = "ServiceCompleteList";
+const char kShortDNSTimeoutTechnologiesProperty[] =
+    "ShortDNSTimeoutTechnologies";
+const char kUninitializedTechnologiesProperty[] = "UninitializedTechnologies";
+const char kWakeOnLanEnabledProperty[] = "WakeOnLanEnabled";
+const char kWakeOnWiFiFeaturesEnabledProperty[] = "WakeOnWiFiFeaturesEnabled";
+
+// Service property names.
+const char kActivationTypeProperty[] = "Cellular.ActivationType";
+const char kDiagnosticsDisconnectsProperty[] = "Diagnostics.Disconnects";
+const char kDiagnosticsMisconnectsProperty[] = "Diagnostics.Misconnects";
+const char kEapRemoteCertificationProperty[] = "EAP.RemoteCertification";
+const char kEapCaCertPemProperty[] = "EAP.CACertPEM";
+const char kEapSubjectMatchProperty[] = "EAP.SubjectMatch";
+const char kErrorDetailsProperty[] = "ErrorDetails";
+const char kHTTPProxyPortProperty[] = "HTTPProxyPort";
+const char kIPConfigProperty[] = "IPConfig";
+const char kL2tpIpsecCaCertPemProperty[] = "L2TPIPsec.CACertPEM";
+const char kL2tpIpsecTunnelGroupProperty[] = "L2TPIPsec.TunnelGroup";
+const char kL2tpIpsecXauthPasswordProperty[] = "L2TPIPsec.XauthPassword";
+const char kL2tpIpsecXauthUserProperty[] = "L2TPIPsec.XauthUser";
+const char kL2tpIpsecLcpEchoDisabledProperty[] = "L2TPIPsec.LCPEchoDisabled";
+const char kManagedCredentialsProperty[] = "ManagedCredentials";
+const char kOpenVPNCaCertPemProperty[] = "OpenVPN.CACertPEM";
+const char kOpenVPNCertProperty[] = "OpenVPN.Cert";
+const char kOpenVPNExtraCertPemProperty[] = "OpenVPN.ExtraCertPEM";
+const char kOpenVPNKeyProperty[] = "OpenVPN.Key";
+const char kOpenVPNPingProperty[] = "OpenVPN.Ping";
+const char kOpenVPNPingExitProperty[] = "OpenVPN.PingExit";
+const char kOpenVPNPingRestartProperty[] = "OpenVPN.PingRestart";
+const char kOpenVPNTLSAuthProperty[] = "OpenVPN.TLSAuth";
+const char kOpenVPNTokenProperty[] = "OpenVPN.Token";
+const char kOpenVPNVerbProperty[] = "OpenVPN.Verb";
+const char kOpenVPNVerifyHashProperty[] = "OpenVPN.VerifyHash";
+const char kOpenVPNVerifyX509NameProperty[] = "OpenVPN.VerifyX509Name";
+const char kOpenVPNVerifyX509TypeProperty[] = "OpenVPN.VerifyX509Type";
+const char kOutOfCreditsProperty[] = "Cellular.OutOfCredits";
+const char kPhysicalTechnologyProperty[] = "PhysicalTechnology";
+const char kPreviousErrorProperty[] = "PreviousError";
+const char kPreviousErrorSerialNumberProperty[] = "PreviousErrorSerialNumber";
+const char kStaticIPAddressProperty[] = "StaticIP.Address";
+const char kStaticIPGatewayProperty[] = "StaticIP.Gateway";
+const char kStaticIPMtuProperty[] = "StaticIP.Mtu";
+const char kStaticIPNameServersProperty[] = "StaticIP.NameServers";
+const char kStaticIPPeerAddressProperty[] = "StaticIP.PeerAddress";
+const char kStaticIPPrefixlenProperty[] = "StaticIP.Prefixlen";
+const char kSavedIPAddressProperty[] = "SavedIP.Address";
+const char kSavedIPGatewayProperty[] = "SavedIP.Gateway";
+const char kSavedIPMtuProperty[] = "SavedIP.Mtu";
+const char kSavedIPNameServersProperty[] = "SavedIP.NameServers";
+const char kSavedIPPeerAddressProperty[] = "SavedIP.PeerAddress";
+const char kSavedIPPrefixlenProperty[] = "SavedIP.Prefixlen";
+const char kTetheringProperty[] = "Tethering";
+const char kVPNMTUProperty[] = "VPN.MTU";
+const char kWifiFrequencyListProperty[] = "WiFi.FrequencyList";
+const char kWifiVendorInformationProperty[] = "WiFi.VendorInformation";
+const char kWifiProtectedManagementFrameRequiredProperty[] =
+    "WiFi.ProtectedManagementFrameRequired";
+
+// Profile property names.
+const char kUserHashProperty[] = "UserHash";
+
+// Service Tethering property values.
+const char kTetheringNotDetectedState[] = "NotDetected";
+const char kTetheringSuspectedState[] = "Suspected";
+const char kTetheringConfirmedState[] = "Confirmed";
+
+// WiFi Service Vendor Information dictionary properties.
+const char kVendorWPSManufacturerProperty[] = "Manufacturer";
+const char kVendorWPSModelNameProperty[] = "ModelName";
+const char kVendorWPSModelNumberProperty[] = "ModelNumber";
+const char kVendorWPSDeviceNameProperty[] = "DeviceName";
+const char kVendorOUIListProperty[] = "OUIList";
+
+// WiFi Device link property names.
+const char kLinkStatisticsProperty[] = "LinkStatistics";
+const char kAverageReceiveSignalDbmProperty[] = "AverageReceiveSignalDbm";
+const char kInactiveTimeMillisecondsProperty[] =
+    "InactiveTimeMilliseconds";
+const char kLastReceiveSignalDbmProperty[] = "LastReceiveSignalDbm";
+const char kPacketReceiveSuccessesProperty[] = "PacketReceiveSuccesses";
+const char kPacketTransmitFailuresProperty[] = "PacketTransmitFailures";
+const char kPacketTransmitSuccessesProperty[] = "PacketTrasmitSuccesses";
+const char kTransmitBitrateProperty[] = "TransmitBitrate";
+const char kTransmitRetriesProperty[] = "TransmitRetries";
+
+// WiFi TDLS operations.
+const char kTDLSDiscoverOperation[] = "Discover";
+const char kTDLSSetupOperation[] = "Setup";
+const char kTDLSStatusOperation[] = "Status";
+const char kTDLSTeardownOperation[] = "Teardown";
+
+// WiFi TDLS states.
+const char kTDLSConnectedState[] = "Connected";
+const char kTDLSDisabledState[] = "Disabled";
+const char kTDLSDisconnectedState[] = "Disconnected";
+const char kTDLSNonexistentState[] = "Nonexistent";
+const char kTDLSUnknownState[] = "Unknown";
+
+// Wake on WiFi features.
+const char kWakeOnWiFiFeaturesEnabledPacket[] = "packet";
+const char kWakeOnWiFiFeaturesEnabledSSID[] = "ssid";
+const char kWakeOnWiFiFeaturesEnabledPacketSSID[] = "packet_and_ssid";
+const char kWakeOnWiFiFeaturesEnabledNone[] = "none";
+const char kWakeOnWiFiFeaturesEnabledNotSupported[] = "not_supported";
+
+// Cellular service carriers.
+const char kCarrierGenericUMTS[] = "Generic UMTS";
+const char kCarrierSprint[] = "Sprint";
+const char kCarrierVerizon[] = "Verizon Wireless";
+
+// Cellular activation types.
+const char kActivationTypeNonCellular[] = "NonCellular";  // For future use
+const char kActivationTypeOMADM[] = "OMADM";  // For future use
+const char kActivationTypeOTA[] = "OTA";
+const char kActivationTypeOTASP[] = "OTASP";
+
+// Geolocation property field names.
+// Reference:
+//    https://devsite.googleplex.com/maps/documentation/business/geolocation/
+// Top level properties for a Geolocation request.
+const char kGeoHomeMobileCountryCodeProperty[] = "homeMobileCountryCode";
+const char kGeoHomeMobileNetworkCodeProperty[] = "homeMobileNetworkCode";
+const char kGeoRadioTypePropertyProperty[] = "radioType";
+const char kGeoCellTowersProperty[] = "cellTowers";
+const char kGeoWifiAccessPointsProperty[] = "wifiAccessPoints";
+// Cell tower object property names.
+const char kGeoCellIdProperty[] = "cellId";
+const char kGeoLocationAreaCodeProperty[] = "locationAreaCode";
+const char kGeoMobileCountryCodeProperty[] = "mobileCountryCode";
+const char kGeoMobileNetworkCodeProperty[] = "mobileNetworkCode";
+const char kGeoTimingAdvanceProperty[] = "timingAdvance";
+// WiFi access point property names.
+const char kGeoMacAddressProperty[] = "macAddress";
+const char kGeoChannelProperty[] = "channel";
+const char kGeoSignalToNoiseRatioProperty[] = "signalToNoiseRatio";
+// Common property names for geolocation objects.
+const char kGeoAgeProperty[] = "age";
+const char kGeoSignalStrengthProperty[] = "signalStrength";
+// ThirdPartyVpn parameters, properties and constants.
+const char kAddressParameterThirdPartyVpn[] = "address";
+const char kBroadcastAddressParameterThirdPartyVpn[] = "broadcast_address";
+const char kGatewayParameterThirdPartyVpn[] = "gateway";
+const char kBypassTunnelForIpParameterThirdPartyVpn[] = "bypass_tunnel_for_ip";
+const char kSubnetPrefixParameterThirdPartyVpn[] = "subnet_prefix";
+const char kMtuParameterThirdPartyVpn[] = "mtu";
+const char kDomainSearchParameterThirdPartyVpn[] = "domain_search";
+const char kDnsServersParameterThirdPartyVpn[] = "dns_servers";
+const char kInclusionListParameterThirdPartyVpn[] = "inclusion_list";
+const char kExclusionListParameterThirdPartyVpn[] = "exclusion_list";
+const char kObjectPathSuffixProperty[] = "ObjectPathSuffix";
+const char kExtensionNameProperty[] = "ExtensionName";
+const char kConfigurationNameProperty[] = "ConfigurationName";
+const char kObjectPathBase[] = "/thirdpartyvpn/";
+const char kNonIPDelimiter = ':';
+const char kIPDelimiter = ' ';
+}  // namespace shill
+
+#endif  // SYSTEM_API_DBUS_SHILL_DBUS_CONSTANTS_H_
diff --git a/include/shill/dbus-proxies.h b/include/shill/dbus-proxies.h
new file mode 100644
index 0000000..188322a
--- /dev/null
+++ b/include/shill/dbus-proxies.h
@@ -0,0 +1,3972 @@
+// Automatic generation of D-Bus interfaces:
+//  - org.chromium.flimflam.Device
+//  - org.chromium.flimflam.IPConfig
+//  - org.chromium.flimflam.Manager
+//  - org.chromium.flimflam.Profile
+//  - org.chromium.flimflam.Service
+//  - org.chromium.flimflam.Task
+//  - org.chromium.flimflam.ThirdPartyVpn
+#ifndef ____CHROMEOS_DBUS_BINDING___BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_SHILL_OUT_DEFAULT_GEN_INCLUDE_SHILL_DBUS_PROXIES_H
+#define ____CHROMEOS_DBUS_BINDING___BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_SHILL_OUT_DEFAULT_GEN_INCLUDE_SHILL_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 {
+namespace flimflam {
+
+// Abstract interface proxy for org::chromium::flimflam::Device.
+class DeviceProxyInterface {
+ public:
+  virtual ~DeviceProxyInterface() = default;
+
+  virtual bool AddWakeOnPacketConnection(
+      const std::string& in_ip_endpoint,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void AddWakeOnPacketConnectionAsync(
+      const std::string& in_ip_endpoint,
+      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 RemoveWakeOnPacketConnection(
+      const std::string& in_ip_endpoint,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RemoveWakeOnPacketConnectionAsync(
+      const std::string& in_ip_endpoint,
+      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 RemoveAllWakeOnPacketConnections(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RemoveAllWakeOnPacketConnectionsAsync(
+      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 GetProperties(
+      chromeos::VariantDictionary* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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 ClearProperty(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ClearPropertyAsync(
+      const std::string& in_1,
+      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 Enable(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void EnableAsync(
+      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 Disable(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void DisableAsync(
+      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 ProposeScan(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ProposeScanAsync(
+      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 AddIPConfig(
+      const std::string& in_1,
+      dbus::ObjectPath* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void AddIPConfigAsync(
+      const std::string& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool Register(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RegisterAsync(
+      const std::string& in_1,
+      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 RequirePin(
+      const std::string& in_1,
+      bool in_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RequirePinAsync(
+      const std::string& in_1,
+      bool in_2,
+      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 EnterPin(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void EnterPinAsync(
+      const std::string& in_1,
+      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 UnblockPin(
+      const std::string& in_1,
+      const std::string& in_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void UnblockPinAsync(
+      const std::string& in_1,
+      const std::string& in_2,
+      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 ChangePin(
+      const std::string& in_1,
+      const std::string& in_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ChangePinAsync(
+      const std::string& in_1,
+      const std::string& in_2,
+      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 PerformTDLSOperation(
+      const std::string& in_1,
+      const std::string& in_2,
+      std::string* out_3,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void PerformTDLSOperationAsync(
+      const std::string& in_1,
+      const std::string& in_2,
+      const base::Callback<void(const std::string&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool Reset(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ResetAsync(
+      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 ResetByteCounters(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ResetByteCountersAsync(
+      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 SetCarrier(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetCarrierAsync(
+      const std::string& in_1,
+      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 RequestRoam(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RequestRoamAsync(
+      const std::string& in_1,
+      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 RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Interface proxy for org::chromium::flimflam::Device.
+class DeviceProxy final : public DeviceProxyInterface {
+ public:
+  DeviceProxy(
+      const scoped_refptr<dbus::Bus>& bus,
+      const dbus::ObjectPath& object_path) :
+          bus_{bus},
+          object_path_{object_path},
+          dbus_object_proxy_{
+              bus_->GetObjectProxy(service_name_, object_path_)} {
+  }
+
+  ~DeviceProxy() override {
+    bus_->RemoveObjectProxy(
+        service_name_, object_path_, base::Bind(&base::DoNothing));
+  }
+
+  void RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.flimflam.Device",
+        "PropertyChanged",
+        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 AddWakeOnPacketConnection(
+      const std::string& in_ip_endpoint,
+      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.flimflam.Device",
+        "AddWakeOnPacketConnection",
+        error,
+        in_ip_endpoint);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void AddWakeOnPacketConnectionAsync(
+      const std::string& in_ip_endpoint,
+      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.flimflam.Device",
+        "AddWakeOnPacketConnection",
+        success_callback,
+        error_callback,
+        in_ip_endpoint);
+  }
+
+  bool RemoveWakeOnPacketConnection(
+      const std::string& in_ip_endpoint,
+      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.flimflam.Device",
+        "RemoveWakeOnPacketConnection",
+        error,
+        in_ip_endpoint);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RemoveWakeOnPacketConnectionAsync(
+      const std::string& in_ip_endpoint,
+      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.flimflam.Device",
+        "RemoveWakeOnPacketConnection",
+        success_callback,
+        error_callback,
+        in_ip_endpoint);
+  }
+
+  bool RemoveAllWakeOnPacketConnections(
+      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.flimflam.Device",
+        "RemoveAllWakeOnPacketConnections",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RemoveAllWakeOnPacketConnectionsAsync(
+      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.flimflam.Device",
+        "RemoveAllWakeOnPacketConnections",
+        success_callback,
+        error_callback);
+  }
+
+  bool GetProperties(
+      chromeos::VariantDictionary* out_1,
+      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.flimflam.Device",
+        "GetProperties",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& 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.flimflam.Device",
+        "GetProperties",
+        success_callback,
+        error_callback);
+  }
+
+  bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.Device",
+        "SetProperty",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.Device",
+        "SetProperty",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool ClearProperty(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "ClearProperty",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ClearPropertyAsync(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "ClearProperty",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool Enable(
+      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.flimflam.Device",
+        "Enable",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void EnableAsync(
+      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.flimflam.Device",
+        "Enable",
+        success_callback,
+        error_callback);
+  }
+
+  bool Disable(
+      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.flimflam.Device",
+        "Disable",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void DisableAsync(
+      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.flimflam.Device",
+        "Disable",
+        success_callback,
+        error_callback);
+  }
+
+  bool ProposeScan(
+      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.flimflam.Device",
+        "ProposeScan",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ProposeScanAsync(
+      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.flimflam.Device",
+        "ProposeScan",
+        success_callback,
+        error_callback);
+  }
+
+  bool AddIPConfig(
+      const std::string& in_1,
+      dbus::ObjectPath* out_2,
+      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.flimflam.Device",
+        "AddIPConfig",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void AddIPConfigAsync(
+      const std::string& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Device",
+        "AddIPConfig",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool Register(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "Register",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RegisterAsync(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "Register",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool RequirePin(
+      const std::string& in_1,
+      bool in_2,
+      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.flimflam.Device",
+        "RequirePin",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RequirePinAsync(
+      const std::string& in_1,
+      bool in_2,
+      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.flimflam.Device",
+        "RequirePin",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool EnterPin(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "EnterPin",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void EnterPinAsync(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "EnterPin",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool UnblockPin(
+      const std::string& in_1,
+      const std::string& in_2,
+      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.flimflam.Device",
+        "UnblockPin",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void UnblockPinAsync(
+      const std::string& in_1,
+      const std::string& in_2,
+      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.flimflam.Device",
+        "UnblockPin",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool ChangePin(
+      const std::string& in_1,
+      const std::string& in_2,
+      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.flimflam.Device",
+        "ChangePin",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ChangePinAsync(
+      const std::string& in_1,
+      const std::string& in_2,
+      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.flimflam.Device",
+        "ChangePin",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool PerformTDLSOperation(
+      const std::string& in_1,
+      const std::string& in_2,
+      std::string* out_3,
+      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.flimflam.Device",
+        "PerformTDLSOperation",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_3);
+  }
+
+  void PerformTDLSOperationAsync(
+      const std::string& in_1,
+      const std::string& in_2,
+      const base::Callback<void(const std::string&)>& 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.flimflam.Device",
+        "PerformTDLSOperation",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool Reset(
+      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.flimflam.Device",
+        "Reset",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ResetAsync(
+      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.flimflam.Device",
+        "Reset",
+        success_callback,
+        error_callback);
+  }
+
+  bool ResetByteCounters(
+      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.flimflam.Device",
+        "ResetByteCounters",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ResetByteCountersAsync(
+      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.flimflam.Device",
+        "ResetByteCounters",
+        success_callback,
+        error_callback);
+  }
+
+  bool SetCarrier(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "SetCarrier",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetCarrierAsync(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "SetCarrier",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool RequestRoam(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "RequestRoam",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RequestRoamAsync(
+      const std::string& in_1,
+      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.flimflam.Device",
+        "RequestRoam",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+ private:
+  scoped_refptr<dbus::Bus> bus_;
+  const std::string service_name_{"org.chromium.flimflam"};
+  dbus::ObjectPath object_path_;
+  dbus::ObjectProxy* dbus_object_proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceProxy);
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Abstract interface proxy for org::chromium::flimflam::IPConfig.
+class IPConfigProxyInterface {
+ public:
+  virtual ~IPConfigProxyInterface() = default;
+
+  virtual bool GetProperties(
+      chromeos::VariantDictionary* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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 ClearProperty(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ClearPropertyAsync(
+      const std::string& in_1,
+      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 Remove(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RemoveAsync(
+      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 Refresh(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RefreshAsync(
+      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 RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Interface proxy for org::chromium::flimflam::IPConfig.
+class IPConfigProxy final : public IPConfigProxyInterface {
+ public:
+  IPConfigProxy(
+      const scoped_refptr<dbus::Bus>& bus,
+      const dbus::ObjectPath& object_path) :
+          bus_{bus},
+          object_path_{object_path},
+          dbus_object_proxy_{
+              bus_->GetObjectProxy(service_name_, object_path_)} {
+  }
+
+  ~IPConfigProxy() override {
+    bus_->RemoveObjectProxy(
+        service_name_, object_path_, base::Bind(&base::DoNothing));
+  }
+
+  void RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.flimflam.IPConfig",
+        "PropertyChanged",
+        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 GetProperties(
+      chromeos::VariantDictionary* out_1,
+      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.flimflam.IPConfig",
+        "GetProperties",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& 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.flimflam.IPConfig",
+        "GetProperties",
+        success_callback,
+        error_callback);
+  }
+
+  bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.IPConfig",
+        "SetProperty",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.IPConfig",
+        "SetProperty",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool ClearProperty(
+      const std::string& in_1,
+      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.flimflam.IPConfig",
+        "ClearProperty",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ClearPropertyAsync(
+      const std::string& in_1,
+      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.flimflam.IPConfig",
+        "ClearProperty",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool Remove(
+      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.flimflam.IPConfig",
+        "Remove",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RemoveAsync(
+      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.flimflam.IPConfig",
+        "Remove",
+        success_callback,
+        error_callback);
+  }
+
+  bool Refresh(
+      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.flimflam.IPConfig",
+        "Refresh",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RefreshAsync(
+      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.flimflam.IPConfig",
+        "Refresh",
+        success_callback,
+        error_callback);
+  }
+
+ private:
+  scoped_refptr<dbus::Bus> bus_;
+  const std::string service_name_{"org.chromium.flimflam"};
+  dbus::ObjectPath object_path_;
+  dbus::ObjectProxy* dbus_object_proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(IPConfigProxy);
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Abstract interface proxy for org::chromium::flimflam::Manager.
+class ManagerProxyInterface {
+ public:
+  virtual ~ManagerProxyInterface() = default;
+
+  virtual bool GetProperties(
+      chromeos::VariantDictionary* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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 GetState(
+      std::string* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetStateAsync(
+      const base::Callback<void(const std::string&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool CreateProfile(
+      const std::string& in_1,
+      dbus::ObjectPath* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void CreateProfileAsync(
+      const std::string& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool RemoveProfile(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RemoveProfileAsync(
+      const std::string& in_1,
+      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 PushProfile(
+      const std::string& in_1,
+      dbus::ObjectPath* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void PushProfileAsync(
+      const std::string& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool InsertUserProfile(
+      const std::string& in_1,
+      const std::string& in_2,
+      dbus::ObjectPath* out_3,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void InsertUserProfileAsync(
+      const std::string& in_1,
+      const std::string& in_2,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool PopProfile(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void PopProfileAsync(
+      const std::string& in_1,
+      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 PopAnyProfile(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void PopAnyProfileAsync(
+      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 PopAllUserProfiles(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void PopAllUserProfilesAsync(
+      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 RecheckPortal(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RecheckPortalAsync(
+      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 RequestScan(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RequestScanAsync(
+      const std::string& in_1,
+      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 EnableTechnology(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void EnableTechnologyAsync(
+      const std::string& in_1,
+      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 DisableTechnology(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void DisableTechnologyAsync(
+      const std::string& in_1,
+      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 GetService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool GetWifiService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetWifiServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool ConfigureService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ConfigureServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool ConfigureServiceForProfile(
+      const dbus::ObjectPath& in_1,
+      const chromeos::VariantDictionary& in_2,
+      dbus::ObjectPath* out_3,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ConfigureServiceForProfileAsync(
+      const dbus::ObjectPath& in_1,
+      const chromeos::VariantDictionary& in_2,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool FindMatchingService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void FindMatchingServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool GetVPNService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetVPNServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool GetDebugLevel(
+      int32_t* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetDebugLevelAsync(
+      const base::Callback<void(int32_t)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool SetDebugLevel(
+      int32_t in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetDebugLevelAsync(
+      int32_t in_1,
+      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 GetServiceOrder(
+      std::string* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetServiceOrderAsync(
+      const base::Callback<void(const std::string&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool SetServiceOrder(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetServiceOrderAsync(
+      const std::string& in_1,
+      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 GetDebugTags(
+      std::string* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetDebugTagsAsync(
+      const base::Callback<void(const std::string&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool SetDebugTags(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetDebugTagsAsync(
+      const std::string& in_1,
+      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 ListDebugTags(
+      std::string* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ListDebugTagsAsync(
+      const base::Callback<void(const std::string&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool GetNetworksForGeolocation(
+      chromeos::VariantDictionary* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetNetworksForGeolocationAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool VerifyDestination(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      bool* out_8,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void VerifyDestinationAsync(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const base::Callback<void(bool)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool VerifyAndEncryptCredentials(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const dbus::ObjectPath& in_network,
+      std::string* out_9,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void VerifyAndEncryptCredentialsAsync(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const dbus::ObjectPath& in_network,
+      const base::Callback<void(const std::string&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool VerifyAndEncryptData(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const std::string& in_data,
+      std::string* out_9,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void VerifyAndEncryptDataAsync(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const std::string& in_data,
+      const base::Callback<void(const std::string&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool ConnectToBestServices(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ConnectToBestServicesAsync(
+      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 CreateConnectivityReport(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void CreateConnectivityReportAsync(
+      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 ClaimInterface(
+      const std::string& in_claimer_name,
+      const std::string& in_interface_name,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ClaimInterfaceAsync(
+      const std::string& in_claimer_name,
+      const std::string& in_interface_name,
+      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 ReleaseInterface(
+      const std::string& in_claimer_name,
+      const std::string& in_interface_name,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ReleaseInterfaceAsync(
+      const std::string& in_claimer_name,
+      const std::string& in_interface_name,
+      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 SetSchedScan(
+      bool in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetSchedScanAsync(
+      bool in_1,
+      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 RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterStateChangedSignalHandler(
+      const base::Callback<void(const std::string&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Interface proxy for org::chromium::flimflam::Manager.
+class ManagerProxy final : public ManagerProxyInterface {
+ public:
+  ManagerProxy(const scoped_refptr<dbus::Bus>& bus) :
+      bus_{bus},
+      dbus_object_proxy_{
+          bus_->GetObjectProxy(service_name_, object_path_)} {
+  }
+
+  ~ManagerProxy() override {
+    bus_->RemoveObjectProxy(
+        service_name_, object_path_, base::Bind(&base::DoNothing));
+  }
+
+  void RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.flimflam.Manager",
+        "PropertyChanged",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterStateChangedSignalHandler(
+      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.flimflam.Manager",
+        "StateChanged",
+        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 GetProperties(
+      chromeos::VariantDictionary* out_1,
+      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.flimflam.Manager",
+        "GetProperties",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& 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.flimflam.Manager",
+        "GetProperties",
+        success_callback,
+        error_callback);
+  }
+
+  bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.Manager",
+        "SetProperty",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.Manager",
+        "SetProperty",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool GetState(
+      std::string* out_1,
+      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.flimflam.Manager",
+        "GetState",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetStateAsync(
+      const base::Callback<void(const std::string&)>& 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.flimflam.Manager",
+        "GetState",
+        success_callback,
+        error_callback);
+  }
+
+  bool CreateProfile(
+      const std::string& in_1,
+      dbus::ObjectPath* out_2,
+      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.flimflam.Manager",
+        "CreateProfile",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void CreateProfileAsync(
+      const std::string& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Manager",
+        "CreateProfile",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool RemoveProfile(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "RemoveProfile",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RemoveProfileAsync(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "RemoveProfile",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool PushProfile(
+      const std::string& in_1,
+      dbus::ObjectPath* out_2,
+      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.flimflam.Manager",
+        "PushProfile",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void PushProfileAsync(
+      const std::string& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Manager",
+        "PushProfile",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool InsertUserProfile(
+      const std::string& in_1,
+      const std::string& in_2,
+      dbus::ObjectPath* out_3,
+      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.flimflam.Manager",
+        "InsertUserProfile",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_3);
+  }
+
+  void InsertUserProfileAsync(
+      const std::string& in_1,
+      const std::string& in_2,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Manager",
+        "InsertUserProfile",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool PopProfile(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "PopProfile",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void PopProfileAsync(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "PopProfile",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool PopAnyProfile(
+      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.flimflam.Manager",
+        "PopAnyProfile",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void PopAnyProfileAsync(
+      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.flimflam.Manager",
+        "PopAnyProfile",
+        success_callback,
+        error_callback);
+  }
+
+  bool PopAllUserProfiles(
+      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.flimflam.Manager",
+        "PopAllUserProfiles",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void PopAllUserProfilesAsync(
+      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.flimflam.Manager",
+        "PopAllUserProfiles",
+        success_callback,
+        error_callback);
+  }
+
+  bool RecheckPortal(
+      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.flimflam.Manager",
+        "RecheckPortal",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RecheckPortalAsync(
+      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.flimflam.Manager",
+        "RecheckPortal",
+        success_callback,
+        error_callback);
+  }
+
+  bool RequestScan(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "RequestScan",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RequestScanAsync(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "RequestScan",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool EnableTechnology(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "EnableTechnology",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void EnableTechnologyAsync(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "EnableTechnology",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool DisableTechnology(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "DisableTechnology",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void DisableTechnologyAsync(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "DisableTechnology",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool GetService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      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.flimflam.Manager",
+        "GetService",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void GetServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Manager",
+        "GetService",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool GetWifiService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      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.flimflam.Manager",
+        "GetWifiService",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void GetWifiServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Manager",
+        "GetWifiService",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool ConfigureService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      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.flimflam.Manager",
+        "ConfigureService",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void ConfigureServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Manager",
+        "ConfigureService",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool ConfigureServiceForProfile(
+      const dbus::ObjectPath& in_1,
+      const chromeos::VariantDictionary& in_2,
+      dbus::ObjectPath* out_3,
+      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.flimflam.Manager",
+        "ConfigureServiceForProfile",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_3);
+  }
+
+  void ConfigureServiceForProfileAsync(
+      const dbus::ObjectPath& in_1,
+      const chromeos::VariantDictionary& in_2,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Manager",
+        "ConfigureServiceForProfile",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool FindMatchingService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      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.flimflam.Manager",
+        "FindMatchingService",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void FindMatchingServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Manager",
+        "FindMatchingService",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool GetVPNService(
+      const chromeos::VariantDictionary& in_1,
+      dbus::ObjectPath* out_2,
+      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.flimflam.Manager",
+        "GetVPNService",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void GetVPNServiceAsync(
+      const chromeos::VariantDictionary& in_1,
+      const base::Callback<void(const dbus::ObjectPath&)>& 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.flimflam.Manager",
+        "GetVPNService",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool GetDebugLevel(
+      int32_t* out_1,
+      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.flimflam.Manager",
+        "GetDebugLevel",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetDebugLevelAsync(
+      const base::Callback<void(int32_t)>& 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.flimflam.Manager",
+        "GetDebugLevel",
+        success_callback,
+        error_callback);
+  }
+
+  bool SetDebugLevel(
+      int32_t in_1,
+      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.flimflam.Manager",
+        "SetDebugLevel",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetDebugLevelAsync(
+      int32_t in_1,
+      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.flimflam.Manager",
+        "SetDebugLevel",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool GetServiceOrder(
+      std::string* out_1,
+      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.flimflam.Manager",
+        "GetServiceOrder",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetServiceOrderAsync(
+      const base::Callback<void(const std::string&)>& 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.flimflam.Manager",
+        "GetServiceOrder",
+        success_callback,
+        error_callback);
+  }
+
+  bool SetServiceOrder(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "SetServiceOrder",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetServiceOrderAsync(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "SetServiceOrder",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool GetDebugTags(
+      std::string* out_1,
+      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.flimflam.Manager",
+        "GetDebugTags",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetDebugTagsAsync(
+      const base::Callback<void(const std::string&)>& 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.flimflam.Manager",
+        "GetDebugTags",
+        success_callback,
+        error_callback);
+  }
+
+  bool SetDebugTags(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "SetDebugTags",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetDebugTagsAsync(
+      const std::string& in_1,
+      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.flimflam.Manager",
+        "SetDebugTags",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool ListDebugTags(
+      std::string* out_1,
+      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.flimflam.Manager",
+        "ListDebugTags",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void ListDebugTagsAsync(
+      const base::Callback<void(const std::string&)>& 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.flimflam.Manager",
+        "ListDebugTags",
+        success_callback,
+        error_callback);
+  }
+
+  bool GetNetworksForGeolocation(
+      chromeos::VariantDictionary* out_1,
+      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.flimflam.Manager",
+        "GetNetworksForGeolocation",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetNetworksForGeolocationAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& 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.flimflam.Manager",
+        "GetNetworksForGeolocation",
+        success_callback,
+        error_callback);
+  }
+
+  bool VerifyDestination(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      bool* out_8,
+      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.flimflam.Manager",
+        "VerifyDestination",
+        error,
+        in_certificate,
+        in_public_key,
+        in_nonce,
+        in_signed_data,
+        in_destination_udn,
+        in_hotspot_ssid,
+        in_hotspot_bssid);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_8);
+  }
+
+  void VerifyDestinationAsync(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const base::Callback<void(bool)>& 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.flimflam.Manager",
+        "VerifyDestination",
+        success_callback,
+        error_callback,
+        in_certificate,
+        in_public_key,
+        in_nonce,
+        in_signed_data,
+        in_destination_udn,
+        in_hotspot_ssid,
+        in_hotspot_bssid);
+  }
+
+  bool VerifyAndEncryptCredentials(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const dbus::ObjectPath& in_network,
+      std::string* out_9,
+      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.flimflam.Manager",
+        "VerifyAndEncryptCredentials",
+        error,
+        in_certificate,
+        in_public_key,
+        in_nonce,
+        in_signed_data,
+        in_destination_udn,
+        in_hotspot_ssid,
+        in_hotspot_bssid,
+        in_network);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_9);
+  }
+
+  void VerifyAndEncryptCredentialsAsync(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const dbus::ObjectPath& in_network,
+      const base::Callback<void(const std::string&)>& 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.flimflam.Manager",
+        "VerifyAndEncryptCredentials",
+        success_callback,
+        error_callback,
+        in_certificate,
+        in_public_key,
+        in_nonce,
+        in_signed_data,
+        in_destination_udn,
+        in_hotspot_ssid,
+        in_hotspot_bssid,
+        in_network);
+  }
+
+  bool VerifyAndEncryptData(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const std::string& in_data,
+      std::string* out_9,
+      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.flimflam.Manager",
+        "VerifyAndEncryptData",
+        error,
+        in_certificate,
+        in_public_key,
+        in_nonce,
+        in_signed_data,
+        in_destination_udn,
+        in_hotspot_ssid,
+        in_hotspot_bssid,
+        in_data);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_9);
+  }
+
+  void VerifyAndEncryptDataAsync(
+      const std::string& in_certificate,
+      const std::string& in_public_key,
+      const std::string& in_nonce,
+      const std::string& in_signed_data,
+      const std::string& in_destination_udn,
+      const std::string& in_hotspot_ssid,
+      const std::string& in_hotspot_bssid,
+      const std::string& in_data,
+      const base::Callback<void(const std::string&)>& 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.flimflam.Manager",
+        "VerifyAndEncryptData",
+        success_callback,
+        error_callback,
+        in_certificate,
+        in_public_key,
+        in_nonce,
+        in_signed_data,
+        in_destination_udn,
+        in_hotspot_ssid,
+        in_hotspot_bssid,
+        in_data);
+  }
+
+  bool ConnectToBestServices(
+      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.flimflam.Manager",
+        "ConnectToBestServices",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ConnectToBestServicesAsync(
+      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.flimflam.Manager",
+        "ConnectToBestServices",
+        success_callback,
+        error_callback);
+  }
+
+  bool CreateConnectivityReport(
+      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.flimflam.Manager",
+        "CreateConnectivityReport",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void CreateConnectivityReportAsync(
+      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.flimflam.Manager",
+        "CreateConnectivityReport",
+        success_callback,
+        error_callback);
+  }
+
+  bool ClaimInterface(
+      const std::string& in_claimer_name,
+      const std::string& in_interface_name,
+      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.flimflam.Manager",
+        "ClaimInterface",
+        error,
+        in_claimer_name,
+        in_interface_name);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ClaimInterfaceAsync(
+      const std::string& in_claimer_name,
+      const std::string& in_interface_name,
+      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.flimflam.Manager",
+        "ClaimInterface",
+        success_callback,
+        error_callback,
+        in_claimer_name,
+        in_interface_name);
+  }
+
+  bool ReleaseInterface(
+      const std::string& in_claimer_name,
+      const std::string& in_interface_name,
+      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.flimflam.Manager",
+        "ReleaseInterface",
+        error,
+        in_claimer_name,
+        in_interface_name);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ReleaseInterfaceAsync(
+      const std::string& in_claimer_name,
+      const std::string& in_interface_name,
+      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.flimflam.Manager",
+        "ReleaseInterface",
+        success_callback,
+        error_callback,
+        in_claimer_name,
+        in_interface_name);
+  }
+
+  bool SetSchedScan(
+      bool in_1,
+      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.flimflam.Manager",
+        "SetSchedScan",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetSchedScanAsync(
+      bool in_1,
+      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.flimflam.Manager",
+        "SetSchedScan",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+ private:
+  scoped_refptr<dbus::Bus> bus_;
+  const std::string service_name_{"org.chromium.flimflam"};
+  const dbus::ObjectPath object_path_{"/"};
+  dbus::ObjectProxy* dbus_object_proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(ManagerProxy);
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Abstract interface proxy for org::chromium::flimflam::Profile.
+class ProfileProxyInterface {
+ public:
+  virtual ~ProfileProxyInterface() = default;
+
+  virtual bool GetProperties(
+      chromeos::VariantDictionary* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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 GetEntry(
+      const std::string& in_1,
+      chromeos::VariantDictionary* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetEntryAsync(
+      const std::string& in_1,
+      const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool DeleteEntry(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void DeleteEntryAsync(
+      const std::string& in_1,
+      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 RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Interface proxy for org::chromium::flimflam::Profile.
+class ProfileProxy final : public ProfileProxyInterface {
+ public:
+  ProfileProxy(
+      const scoped_refptr<dbus::Bus>& bus,
+      const dbus::ObjectPath& object_path) :
+          bus_{bus},
+          object_path_{object_path},
+          dbus_object_proxy_{
+              bus_->GetObjectProxy(service_name_, object_path_)} {
+  }
+
+  ~ProfileProxy() override {
+    bus_->RemoveObjectProxy(
+        service_name_, object_path_, base::Bind(&base::DoNothing));
+  }
+
+  void RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.flimflam.Profile",
+        "PropertyChanged",
+        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 GetProperties(
+      chromeos::VariantDictionary* out_1,
+      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.flimflam.Profile",
+        "GetProperties",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& 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.flimflam.Profile",
+        "GetProperties",
+        success_callback,
+        error_callback);
+  }
+
+  bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.Profile",
+        "SetProperty",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.Profile",
+        "SetProperty",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool GetEntry(
+      const std::string& in_1,
+      chromeos::VariantDictionary* out_2,
+      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.flimflam.Profile",
+        "GetEntry",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void GetEntryAsync(
+      const std::string& in_1,
+      const base::Callback<void(const chromeos::VariantDictionary&)>& 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.flimflam.Profile",
+        "GetEntry",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool DeleteEntry(
+      const std::string& in_1,
+      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.flimflam.Profile",
+        "DeleteEntry",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void DeleteEntryAsync(
+      const std::string& in_1,
+      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.flimflam.Profile",
+        "DeleteEntry",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+ private:
+  scoped_refptr<dbus::Bus> bus_;
+  const std::string service_name_{"org.chromium.flimflam"};
+  dbus::ObjectPath object_path_;
+  dbus::ObjectProxy* dbus_object_proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProfileProxy);
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Abstract interface proxy for org::chromium::flimflam::Service.
+class ServiceProxyInterface {
+ public:
+  virtual ~ServiceProxyInterface() = default;
+
+  virtual bool GetProperties(
+      chromeos::VariantDictionary* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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 SetProperties(
+      const chromeos::VariantDictionary& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetPropertiesAsync(
+      const chromeos::VariantDictionary& in_1,
+      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 ClearProperty(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ClearPropertyAsync(
+      const std::string& in_1,
+      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 ClearProperties(
+      const std::vector<std::string>& in_1,
+      std::vector<bool>* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ClearPropertiesAsync(
+      const std::vector<std::string>& in_1,
+      const base::Callback<void(const std::vector<bool>&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool Connect(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ConnectAsync(
+      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 Disconnect(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void DisconnectAsync(
+      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 Remove(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RemoveAsync(
+      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 ActivateCellularModem(
+      const std::string& in_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void ActivateCellularModemAsync(
+      const std::string& in_1,
+      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 CompleteCellularActivation(
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void CompleteCellularActivationAsync(
+      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 GetLoadableProfileEntries(
+      std::map<dbus::ObjectPath, std::string>* out_1,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void GetLoadableProfileEntriesAsync(
+      const base::Callback<void(const std::map<dbus::ObjectPath, std::string>&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Interface proxy for org::chromium::flimflam::Service.
+class ServiceProxy final : public ServiceProxyInterface {
+ public:
+  ServiceProxy(
+      const scoped_refptr<dbus::Bus>& bus,
+      const dbus::ObjectPath& object_path) :
+          bus_{bus},
+          object_path_{object_path},
+          dbus_object_proxy_{
+              bus_->GetObjectProxy(service_name_, object_path_)} {
+  }
+
+  ~ServiceProxy() override {
+    bus_->RemoveObjectProxy(
+        service_name_, object_path_, base::Bind(&base::DoNothing));
+  }
+
+  void RegisterPropertyChangedSignalHandler(
+      const base::Callback<void(const std::string&,
+                                const chromeos::Any&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.flimflam.Service",
+        "PropertyChanged",
+        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 GetProperties(
+      chromeos::VariantDictionary* out_1,
+      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.flimflam.Service",
+        "GetProperties",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetPropertiesAsync(
+      const base::Callback<void(const chromeos::VariantDictionary&)>& 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.flimflam.Service",
+        "GetProperties",
+        success_callback,
+        error_callback);
+  }
+
+  bool SetProperty(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.Service",
+        "SetProperty",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetPropertyAsync(
+      const std::string& in_1,
+      const chromeos::Any& in_2,
+      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.flimflam.Service",
+        "SetProperty",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+  bool SetProperties(
+      const chromeos::VariantDictionary& in_1,
+      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.flimflam.Service",
+        "SetProperties",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SetPropertiesAsync(
+      const chromeos::VariantDictionary& in_1,
+      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.flimflam.Service",
+        "SetProperties",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool ClearProperty(
+      const std::string& in_1,
+      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.flimflam.Service",
+        "ClearProperty",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ClearPropertyAsync(
+      const std::string& in_1,
+      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.flimflam.Service",
+        "ClearProperty",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool ClearProperties(
+      const std::vector<std::string>& in_1,
+      std::vector<bool>* out_2,
+      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.flimflam.Service",
+        "ClearProperties",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_2);
+  }
+
+  void ClearPropertiesAsync(
+      const std::vector<std::string>& in_1,
+      const base::Callback<void(const std::vector<bool>&)>& 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.flimflam.Service",
+        "ClearProperties",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool Connect(
+      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.flimflam.Service",
+        "Connect",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ConnectAsync(
+      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.flimflam.Service",
+        "Connect",
+        success_callback,
+        error_callback);
+  }
+
+  bool Disconnect(
+      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.flimflam.Service",
+        "Disconnect",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void DisconnectAsync(
+      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.flimflam.Service",
+        "Disconnect",
+        success_callback,
+        error_callback);
+  }
+
+  bool Remove(
+      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.flimflam.Service",
+        "Remove",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void RemoveAsync(
+      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.flimflam.Service",
+        "Remove",
+        success_callback,
+        error_callback);
+  }
+
+  bool ActivateCellularModem(
+      const std::string& in_1,
+      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.flimflam.Service",
+        "ActivateCellularModem",
+        error,
+        in_1);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void ActivateCellularModemAsync(
+      const std::string& in_1,
+      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.flimflam.Service",
+        "ActivateCellularModem",
+        success_callback,
+        error_callback,
+        in_1);
+  }
+
+  bool CompleteCellularActivation(
+      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.flimflam.Service",
+        "CompleteCellularActivation",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void CompleteCellularActivationAsync(
+      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.flimflam.Service",
+        "CompleteCellularActivation",
+        success_callback,
+        error_callback);
+  }
+
+  bool GetLoadableProfileEntries(
+      std::map<dbus::ObjectPath, std::string>* out_1,
+      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.flimflam.Service",
+        "GetLoadableProfileEntries",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1);
+  }
+
+  void GetLoadableProfileEntriesAsync(
+      const base::Callback<void(const std::map<dbus::ObjectPath, std::string>&)>& 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.flimflam.Service",
+        "GetLoadableProfileEntries",
+        success_callback,
+        error_callback);
+  }
+
+ private:
+  scoped_refptr<dbus::Bus> bus_;
+  const std::string service_name_{"org.chromium.flimflam"};
+  dbus::ObjectPath object_path_;
+  dbus::ObjectProxy* dbus_object_proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(ServiceProxy);
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Abstract interface proxy for org::chromium::flimflam::Task.
+class TaskProxyInterface {
+ public:
+  virtual ~TaskProxyInterface() = default;
+
+  virtual bool getsec(
+      std::string* out_1,
+      std::string* out_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void getsecAsync(
+      const base::Callback<void(const std::string&, const std::string&)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool notify(
+      const std::string& in_1,
+      const std::map<std::string, std::string>& in_2,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void notifyAsync(
+      const std::string& in_1,
+      const std::map<std::string, std::string>& in_2,
+      const base::Callback<void()>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Interface proxy for org::chromium::flimflam::Task.
+class TaskProxy final : public TaskProxyInterface {
+ public:
+  TaskProxy(
+      const scoped_refptr<dbus::Bus>& bus,
+      const dbus::ObjectPath& object_path) :
+          bus_{bus},
+          object_path_{object_path},
+          dbus_object_proxy_{
+              bus_->GetObjectProxy(service_name_, object_path_)} {
+  }
+
+  ~TaskProxy() override {
+    bus_->RemoveObjectProxy(
+        service_name_, object_path_, base::Bind(&base::DoNothing));
+  }
+
+  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 getsec(
+      std::string* out_1,
+      std::string* out_2,
+      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.flimflam.Task",
+        "getsec",
+        error);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_1, out_2);
+  }
+
+  void getsecAsync(
+      const base::Callback<void(const std::string&, const std::string&)>& 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.flimflam.Task",
+        "getsec",
+        success_callback,
+        error_callback);
+  }
+
+  bool notify(
+      const std::string& in_1,
+      const std::map<std::string, std::string>& in_2,
+      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.flimflam.Task",
+        "notify",
+        error,
+        in_1,
+        in_2);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void notifyAsync(
+      const std::string& in_1,
+      const std::map<std::string, std::string>& in_2,
+      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.flimflam.Task",
+        "notify",
+        success_callback,
+        error_callback,
+        in_1,
+        in_2);
+  }
+
+ private:
+  scoped_refptr<dbus::Bus> bus_;
+  const std::string service_name_{"org.chromium.flimflam"};
+  dbus::ObjectPath object_path_;
+  dbus::ObjectProxy* dbus_object_proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(TaskProxy);
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Abstract interface proxy for org::chromium::flimflam::ThirdPartyVpn.
+class ThirdPartyVpnProxyInterface {
+ public:
+  virtual ~ThirdPartyVpnProxyInterface() = default;
+
+  virtual bool SetParameters(
+      const std::map<std::string, std::string>& in_parameters,
+      std::string* out_warning,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SetParametersAsync(
+      const std::map<std::string, std::string>& in_parameters,
+      const base::Callback<void(const std::string& /*warning*/)>& success_callback,
+      const base::Callback<void(chromeos::Error*)>& error_callback,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual bool UpdateConnectionState(
+      uint32_t in_connection_state,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void UpdateConnectionStateAsync(
+      uint32_t in_connection_state,
+      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 SendPacket(
+      const std::vector<uint8_t>& in_ip_packet,
+      chromeos::ErrorPtr* error,
+      int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
+
+  virtual void SendPacketAsync(
+      const std::vector<uint8_t>& in_ip_packet,
+      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 RegisterOnPacketReceivedSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+
+  virtual void RegisterOnPlatformMessageSignalHandler(
+      const base::Callback<void(uint32_t)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Interface proxy for org::chromium::flimflam::ThirdPartyVpn.
+class ThirdPartyVpnProxy final : public ThirdPartyVpnProxyInterface {
+ public:
+  ThirdPartyVpnProxy(
+      const scoped_refptr<dbus::Bus>& bus,
+      const dbus::ObjectPath& object_path) :
+          bus_{bus},
+          object_path_{object_path},
+          dbus_object_proxy_{
+              bus_->GetObjectProxy(service_name_, object_path_)} {
+  }
+
+  ~ThirdPartyVpnProxy() override {
+    bus_->RemoveObjectProxy(
+        service_name_, object_path_, base::Bind(&base::DoNothing));
+  }
+
+  void RegisterOnPacketReceivedSignalHandler(
+      const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.flimflam.ThirdPartyVpn",
+        "OnPacketReceived",
+        signal_callback,
+        on_connected_callback);
+  }
+
+  void RegisterOnPlatformMessageSignalHandler(
+      const base::Callback<void(uint32_t)>& signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
+    chromeos::dbus_utils::ConnectToSignal(
+        dbus_object_proxy_,
+        "org.chromium.flimflam.ThirdPartyVpn",
+        "OnPlatformMessage",
+        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 SetParameters(
+      const std::map<std::string, std::string>& in_parameters,
+      std::string* out_warning,
+      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.flimflam.ThirdPartyVpn",
+        "SetParameters",
+        error,
+        in_parameters);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error, out_warning);
+  }
+
+  void SetParametersAsync(
+      const std::map<std::string, std::string>& in_parameters,
+      const base::Callback<void(const std::string& /*warning*/)>& 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.flimflam.ThirdPartyVpn",
+        "SetParameters",
+        success_callback,
+        error_callback,
+        in_parameters);
+  }
+
+  bool UpdateConnectionState(
+      uint32_t in_connection_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.flimflam.ThirdPartyVpn",
+        "UpdateConnectionState",
+        error,
+        in_connection_state);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void UpdateConnectionStateAsync(
+      uint32_t in_connection_state,
+      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.flimflam.ThirdPartyVpn",
+        "UpdateConnectionState",
+        success_callback,
+        error_callback,
+        in_connection_state);
+  }
+
+  bool SendPacket(
+      const std::vector<uint8_t>& in_ip_packet,
+      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.flimflam.ThirdPartyVpn",
+        "SendPacket",
+        error,
+        in_ip_packet);
+    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+        response.get(), error);
+  }
+
+  void SendPacketAsync(
+      const std::vector<uint8_t>& in_ip_packet,
+      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.flimflam.ThirdPartyVpn",
+        "SendPacket",
+        success_callback,
+        error_callback,
+        in_ip_packet);
+  }
+
+ private:
+  scoped_refptr<dbus::Bus> bus_;
+  const std::string service_name_{"org.chromium.flimflam"};
+  dbus::ObjectPath object_path_;
+  dbus::ObjectProxy* dbus_object_proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThirdPartyVpnProxy);
+};
+
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+#endif  // ____CHROMEOS_DBUS_BINDING___BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_SHILL_OUT_DEFAULT_GEN_INCLUDE_SHILL_DBUS_PROXIES_H
diff --git a/include/shill/dbus-proxy-mocks.h b/include/shill/dbus-proxy-mocks.h
new file mode 100644
index 0000000..0f2eb21
--- /dev/null
+++ b/include/shill/dbus-proxy-mocks.h
@@ -0,0 +1,946 @@
+// Automatic generation of D-Bus interface mock proxies for:
+//  - org.chromium.flimflam.Device
+//  - org.chromium.flimflam.IPConfig
+//  - org.chromium.flimflam.Manager
+//  - org.chromium.flimflam.Profile
+//  - org.chromium.flimflam.Service
+//  - org.chromium.flimflam.Task
+//  - org.chromium.flimflam.ThirdPartyVpn
+#ifndef ____CHROMEOS_DBUS_BINDING___BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_SHILL_OUT_DEFAULT_GEN_INCLUDE_SHILL_DBUS_PROXY_MOCKS_H
+#define ____CHROMEOS_DBUS_BINDING___BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_SHILL_OUT_DEFAULT_GEN_INCLUDE_SHILL_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 "shill/dbus-proxies.h"
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Mock object for DeviceProxyInterface.
+class DeviceProxyMock : public DeviceProxyInterface {
+ public:
+  DeviceProxyMock() = default;
+
+  MOCK_METHOD3(AddWakeOnPacketConnection,
+               bool(const std::string& /*in_ip_endpoint*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(AddWakeOnPacketConnectionAsync,
+               void(const std::string& /*in_ip_endpoint*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RemoveWakeOnPacketConnection,
+               bool(const std::string& /*in_ip_endpoint*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RemoveWakeOnPacketConnectionAsync,
+               void(const std::string& /*in_ip_endpoint*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RemoveAllWakeOnPacketConnections,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RemoveAllWakeOnPacketConnectionsAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetProperties,
+               bool(chromeos::VariantDictionary*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetPropertiesAsync,
+               void(const base::Callback<void(const chromeos::VariantDictionary&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetProperty,
+               bool(const std::string&,
+                    const chromeos::Any&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(SetPropertyAsync,
+               void(const std::string&,
+                    const chromeos::Any&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ClearProperty,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ClearPropertyAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(Enable,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(EnableAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(Disable,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(DisableAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(ProposeScan,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ProposeScanAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(AddIPConfig,
+               bool(const std::string&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(AddIPConfigAsync,
+               void(const std::string&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(Register,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RegisterAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RequirePin,
+               bool(const std::string&,
+                    bool,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(RequirePinAsync,
+               void(const std::string&,
+                    bool,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(EnterPin,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(EnterPinAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(UnblockPin,
+               bool(const std::string&,
+                    const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(UnblockPinAsync,
+               void(const std::string&,
+                    const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ChangePin,
+               bool(const std::string&,
+                    const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(ChangePinAsync,
+               void(const std::string&,
+                    const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(PerformTDLSOperation,
+               bool(const std::string&,
+                    const std::string&,
+                    std::string*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(PerformTDLSOperationAsync,
+               void(const std::string&,
+                    const std::string&,
+                    const base::Callback<void(const std::string&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(Reset,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ResetAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(ResetByteCounters,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ResetByteCountersAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetCarrier,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetCarrierAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RequestRoam,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RequestRoamAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RegisterPropertyChangedSignalHandler,
+               void(const base::Callback<void(const std::string&,
+                                              const chromeos::Any&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DeviceProxyMock);
+};
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Mock object for IPConfigProxyInterface.
+class IPConfigProxyMock : public IPConfigProxyInterface {
+ public:
+  IPConfigProxyMock() = default;
+
+  MOCK_METHOD3(GetProperties,
+               bool(chromeos::VariantDictionary*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetPropertiesAsync,
+               void(const base::Callback<void(const chromeos::VariantDictionary&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetProperty,
+               bool(const std::string&,
+                    const chromeos::Any&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(SetPropertyAsync,
+               void(const std::string&,
+                    const chromeos::Any&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ClearProperty,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ClearPropertyAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(Remove,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RemoveAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(Refresh,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RefreshAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RegisterPropertyChangedSignalHandler,
+               void(const base::Callback<void(const std::string&,
+                                              const chromeos::Any&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(IPConfigProxyMock);
+};
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Mock object for ManagerProxyInterface.
+class ManagerProxyMock : public ManagerProxyInterface {
+ public:
+  ManagerProxyMock() = default;
+
+  MOCK_METHOD3(GetProperties,
+               bool(chromeos::VariantDictionary*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetPropertiesAsync,
+               void(const base::Callback<void(const chromeos::VariantDictionary&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetProperty,
+               bool(const std::string&,
+                    const chromeos::Any&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(SetPropertyAsync,
+               void(const std::string&,
+                    const chromeos::Any&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetState,
+               bool(std::string*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetStateAsync,
+               void(const base::Callback<void(const std::string&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(CreateProfile,
+               bool(const std::string&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(CreateProfileAsync,
+               void(const std::string&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RemoveProfile,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RemoveProfileAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(PushProfile,
+               bool(const std::string&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(PushProfileAsync,
+               void(const std::string&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(InsertUserProfile,
+               bool(const std::string&,
+                    const std::string&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(InsertUserProfileAsync,
+               void(const std::string&,
+                    const std::string&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(PopProfile,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(PopProfileAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(PopAnyProfile,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(PopAnyProfileAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(PopAllUserProfiles,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(PopAllUserProfilesAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RecheckPortal,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RecheckPortalAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RequestScan,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(RequestScanAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(EnableTechnology,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(EnableTechnologyAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(DisableTechnology,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(DisableTechnologyAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetService,
+               bool(const chromeos::VariantDictionary&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetServiceAsync,
+               void(const chromeos::VariantDictionary&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetWifiService,
+               bool(const chromeos::VariantDictionary&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetWifiServiceAsync,
+               void(const chromeos::VariantDictionary&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ConfigureService,
+               bool(const chromeos::VariantDictionary&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ConfigureServiceAsync,
+               void(const chromeos::VariantDictionary&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(ConfigureServiceForProfile,
+               bool(const dbus::ObjectPath&,
+                    const chromeos::VariantDictionary&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(ConfigureServiceForProfileAsync,
+               void(const dbus::ObjectPath&,
+                    const chromeos::VariantDictionary&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(FindMatchingService,
+               bool(const chromeos::VariantDictionary&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(FindMatchingServiceAsync,
+               void(const chromeos::VariantDictionary&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetVPNService,
+               bool(const chromeos::VariantDictionary&,
+                    dbus::ObjectPath*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetVPNServiceAsync,
+               void(const chromeos::VariantDictionary&,
+                    const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetDebugLevel,
+               bool(int32_t*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetDebugLevelAsync,
+               void(const base::Callback<void(int32_t)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetDebugLevel,
+               bool(int32_t,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetDebugLevelAsync,
+               void(int32_t,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetServiceOrder,
+               bool(std::string*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetServiceOrderAsync,
+               void(const base::Callback<void(const std::string&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetServiceOrder,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetServiceOrderAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetDebugTags,
+               bool(std::string*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetDebugTagsAsync,
+               void(const base::Callback<void(const std::string&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetDebugTags,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetDebugTagsAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ListDebugTags,
+               bool(std::string*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ListDebugTagsAsync,
+               void(const base::Callback<void(const std::string&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetNetworksForGeolocation,
+               bool(chromeos::VariantDictionary*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetNetworksForGeolocationAsync,
+               void(const base::Callback<void(const chromeos::VariantDictionary&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD10(VerifyDestination,
+                bool(const std::string& /*in_certificate*/,
+                     const std::string& /*in_public_key*/,
+                     const std::string& /*in_nonce*/,
+                     const std::string& /*in_signed_data*/,
+                     const std::string& /*in_destination_udn*/,
+                     const std::string& /*in_hotspot_ssid*/,
+                     const std::string& /*in_hotspot_bssid*/,
+                     bool*,
+                     chromeos::ErrorPtr* /*error*/,
+                     int /*timeout_ms*/));
+  MOCK_METHOD10(VerifyDestinationAsync,
+                void(const std::string& /*in_certificate*/,
+                     const std::string& /*in_public_key*/,
+                     const std::string& /*in_nonce*/,
+                     const std::string& /*in_signed_data*/,
+                     const std::string& /*in_destination_udn*/,
+                     const std::string& /*in_hotspot_ssid*/,
+                     const std::string& /*in_hotspot_bssid*/,
+                     const base::Callback<void(bool)>& /*success_callback*/,
+                     const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                     int /*timeout_ms*/));
+  bool VerifyAndEncryptCredentials(const std::string& /*in_certificate*/,
+                                   const std::string& /*in_public_key*/,
+                                   const std::string& /*in_nonce*/,
+                                   const std::string& /*in_signed_data*/,
+                                   const std::string& /*in_destination_udn*/,
+                                   const std::string& /*in_hotspot_ssid*/,
+                                   const std::string& /*in_hotspot_bssid*/,
+                                   const dbus::ObjectPath& /*in_network*/,
+                                   std::string*,
+                                   chromeos::ErrorPtr* /*error*/,
+                                   int /*timeout_ms*/) override {
+    LOG(WARNING) << "VerifyAndEncryptCredentials(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
+    return false;
+  }
+  void VerifyAndEncryptCredentialsAsync(const std::string& /*in_certificate*/,
+                                        const std::string& /*in_public_key*/,
+                                        const std::string& /*in_nonce*/,
+                                        const std::string& /*in_signed_data*/,
+                                        const std::string& /*in_destination_udn*/,
+                                        const std::string& /*in_hotspot_ssid*/,
+                                        const std::string& /*in_hotspot_bssid*/,
+                                        const dbus::ObjectPath& /*in_network*/,
+                                        const base::Callback<void(const std::string&)>& /*success_callback*/,
+                                        const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                                        int /*timeout_ms*/) override {
+    LOG(WARNING) << "VerifyAndEncryptCredentialsAsync(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
+  }
+  bool VerifyAndEncryptData(const std::string& /*in_certificate*/,
+                            const std::string& /*in_public_key*/,
+                            const std::string& /*in_nonce*/,
+                            const std::string& /*in_signed_data*/,
+                            const std::string& /*in_destination_udn*/,
+                            const std::string& /*in_hotspot_ssid*/,
+                            const std::string& /*in_hotspot_bssid*/,
+                            const std::string& /*in_data*/,
+                            std::string*,
+                            chromeos::ErrorPtr* /*error*/,
+                            int /*timeout_ms*/) override {
+    LOG(WARNING) << "VerifyAndEncryptData(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
+    return false;
+  }
+  void VerifyAndEncryptDataAsync(const std::string& /*in_certificate*/,
+                                 const std::string& /*in_public_key*/,
+                                 const std::string& /*in_nonce*/,
+                                 const std::string& /*in_signed_data*/,
+                                 const std::string& /*in_destination_udn*/,
+                                 const std::string& /*in_hotspot_ssid*/,
+                                 const std::string& /*in_hotspot_bssid*/,
+                                 const std::string& /*in_data*/,
+                                 const base::Callback<void(const std::string&)>& /*success_callback*/,
+                                 const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                                 int /*timeout_ms*/) override {
+    LOG(WARNING) << "VerifyAndEncryptDataAsync(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
+  }
+  MOCK_METHOD2(ConnectToBestServices,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ConnectToBestServicesAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(CreateConnectivityReport,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(CreateConnectivityReportAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ClaimInterface,
+               bool(const std::string& /*in_claimer_name*/,
+                    const std::string& /*in_interface_name*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(ClaimInterfaceAsync,
+               void(const std::string& /*in_claimer_name*/,
+                    const std::string& /*in_interface_name*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ReleaseInterface,
+               bool(const std::string& /*in_claimer_name*/,
+                    const std::string& /*in_interface_name*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(ReleaseInterfaceAsync,
+               void(const std::string& /*in_claimer_name*/,
+                    const std::string& /*in_interface_name*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetSchedScan,
+               bool(bool,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetSchedScanAsync,
+               void(bool,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RegisterPropertyChangedSignalHandler,
+               void(const base::Callback<void(const std::string&,
+                                              const chromeos::Any&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterStateChangedSignalHandler,
+               void(const base::Callback<void(const std::string&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ManagerProxyMock);
+};
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Mock object for ProfileProxyInterface.
+class ProfileProxyMock : public ProfileProxyInterface {
+ public:
+  ProfileProxyMock() = default;
+
+  MOCK_METHOD3(GetProperties,
+               bool(chromeos::VariantDictionary*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetPropertiesAsync,
+               void(const base::Callback<void(const chromeos::VariantDictionary&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetProperty,
+               bool(const std::string&,
+                    const chromeos::Any&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(SetPropertyAsync,
+               void(const std::string&,
+                    const chromeos::Any&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetEntry,
+               bool(const std::string&,
+                    chromeos::VariantDictionary*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(GetEntryAsync,
+               void(const std::string&,
+                    const base::Callback<void(const chromeos::VariantDictionary&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(DeleteEntry,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(DeleteEntryAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RegisterPropertyChangedSignalHandler,
+               void(const base::Callback<void(const std::string&,
+                                              const chromeos::Any&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ProfileProxyMock);
+};
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Mock object for ServiceProxyInterface.
+class ServiceProxyMock : public ServiceProxyInterface {
+ public:
+  ServiceProxyMock() = default;
+
+  MOCK_METHOD3(GetProperties,
+               bool(chromeos::VariantDictionary*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetPropertiesAsync,
+               void(const base::Callback<void(const chromeos::VariantDictionary&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetProperty,
+               bool(const std::string&,
+                    const chromeos::Any&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(SetPropertyAsync,
+               void(const std::string&,
+                    const chromeos::Any&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SetProperties,
+               bool(const chromeos::VariantDictionary&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetPropertiesAsync,
+               void(const chromeos::VariantDictionary&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ClearProperty,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ClearPropertyAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ClearProperties,
+               bool(const std::vector<std::string>&,
+                    std::vector<bool>*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ClearPropertiesAsync,
+               void(const std::vector<std::string>&,
+                    const base::Callback<void(const std::vector<bool>&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(Connect,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ConnectAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(Disconnect,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(DisconnectAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(Remove,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(RemoveAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(ActivateCellularModem,
+               bool(const std::string&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(ActivateCellularModemAsync,
+               void(const std::string&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(CompleteCellularActivation,
+               bool(chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(CompleteCellularActivationAsync,
+               void(const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetLoadableProfileEntries,
+               bool(std::map<dbus::ObjectPath, std::string>*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(GetLoadableProfileEntriesAsync,
+               void(const base::Callback<void(const std::map<dbus::ObjectPath, std::string>&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RegisterPropertyChangedSignalHandler,
+               void(const base::Callback<void(const std::string&,
+                                              const chromeos::Any&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ServiceProxyMock);
+};
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Mock object for TaskProxyInterface.
+class TaskProxyMock : public TaskProxyInterface {
+ public:
+  TaskProxyMock() = default;
+
+  MOCK_METHOD4(getsec,
+               bool(std::string*,
+                    std::string*,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(getsecAsync,
+               void(const base::Callback<void(const std::string&, const std::string&)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(notify,
+               bool(const std::string&,
+                    const std::map<std::string, std::string>&,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD5(notifyAsync,
+               void(const std::string&,
+                    const std::map<std::string, std::string>&,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TaskProxyMock);
+};
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+namespace org {
+namespace chromium {
+namespace flimflam {
+
+// Mock object for ThirdPartyVpnProxyInterface.
+class ThirdPartyVpnProxyMock : public ThirdPartyVpnProxyInterface {
+ public:
+  ThirdPartyVpnProxyMock() = default;
+
+  MOCK_METHOD4(SetParameters,
+               bool(const std::map<std::string, std::string>& /*in_parameters*/,
+                    std::string* /*out_warning*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SetParametersAsync,
+               void(const std::map<std::string, std::string>& /*in_parameters*/,
+                    const base::Callback<void(const std::string& /*warning*/)>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(UpdateConnectionState,
+               bool(uint32_t /*in_connection_state*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(UpdateConnectionStateAsync,
+               void(uint32_t /*in_connection_state*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD3(SendPacket,
+               bool(const std::vector<uint8_t>& /*in_ip_packet*/,
+                    chromeos::ErrorPtr* /*error*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD4(SendPacketAsync,
+               void(const std::vector<uint8_t>& /*in_ip_packet*/,
+                    const base::Callback<void()>& /*success_callback*/,
+                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    int /*timeout_ms*/));
+  MOCK_METHOD2(RegisterOnPacketReceivedSignalHandler,
+               void(const base::Callback<void(const std::vector<uint8_t>&)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+  MOCK_METHOD2(RegisterOnPlatformMessageSignalHandler,
+               void(const base::Callback<void(uint32_t)>& /*signal_callback*/,
+                    dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ThirdPartyVpnProxyMock);
+};
+}  // namespace flimflam
+}  // namespace chromium
+}  // namespace org
+
+#endif  // ____CHROMEOS_DBUS_BINDING___BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_SHILL_OUT_DEFAULT_GEN_INCLUDE_SHILL_DBUS_PROXY_MOCKS_H
diff --git a/include/update_engine/dbus-constants.h b/include/update_engine/dbus-constants.h
new file mode 100644
index 0000000..94e35f1
--- /dev/null
+++ b/include/update_engine/dbus-constants.h
@@ -0,0 +1,51 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SYSTEM_API_DBUS_UPDATE_ENGINE_DBUS_CONSTANTS_H_
+#define SYSTEM_API_DBUS_UPDATE_ENGINE_DBUS_CONSTANTS_H_
+
+namespace update_engine {
+const char kUpdateEngineInterface[] = "org.chromium.UpdateEngineInterface";
+const char kUpdateEngineServicePath[] = "/org/chromium/UpdateEngine";
+const char kUpdateEngineServiceName[] = "org.chromium.UpdateEngine";
+
+// Generic UpdateEngine D-Bus error.
+static const char* const kUpdateEngineServiceErrorFailed =
+    "org.chromium.UpdateEngine.Error.Failed";
+
+// Methods.
+const char kAttemptUpdate[] = "AttemptUpdate";
+const char kGetStatus[] = "GetStatus";
+const char kRebootIfNeeded[] = "RebootIfNeeded";
+const char kSetChannel[] = "SetChannel";
+const char kGetChannel[] = "GetChannel";
+const char kAttemptRollback[] = "AttemptRollback";
+const char kCanRollback[] = "CanRollback";
+
+// Signals.
+const char kStatusUpdate[] = "StatusUpdate";
+
+// Flags used in the AttemptUpdateWithFlags() D-Bus method.
+typedef enum {
+  kAttemptUpdateFlagNonInteractive = (1<<0)
+} AttemptUpdateFlags;
+
+// Operations contained in StatusUpdate signals.
+const char kUpdateStatusIdle[] = "UPDATE_STATUS_IDLE";
+const char kUpdateStatusCheckingForUpdate[] =
+    "UPDATE_STATUS_CHECKING_FOR_UPDATE";
+const char kUpdateStatusUpdateAvailable[] = "UPDATE_STATUS_UPDATE_AVAILABLE";
+const char kUpdateStatusDownloading[] = "UPDATE_STATUS_DOWNLOADING";
+const char kUpdateStatusVerifying[] = "UPDATE_STATUS_VERIFYING";
+const char kUpdateStatusFinalizing[] = "UPDATE_STATUS_FINALIZING";
+const char kUpdateStatusUpdatedNeedReboot[] =
+    "UPDATE_STATUS_UPDATED_NEED_REBOOT";
+const char kUpdateStatusReportingErrorEvent[] =
+    "UPDATE_STATUS_REPORTING_ERROR_EVENT";
+const char kUpdateStatusAttemptingRollback[] =
+    "UPDATE_STATUS_ATTEMPTING_ROLLBACK";
+const char kUpdateStatusDisabled[] = "UPDATE_STATUS_DISABLED";
+}  // namespace update_engine
+
+#endif  // SYSTEM_API_DBUS_UPDATE_ENGINE_DBUS_CONSTANTS_H_