diff --git a/buffet/device_registration_info.cc b/buffet/device_registration_info.cc
index c6aef06..800cfa0 100644
--- a/buffet/device_registration_info.cc
+++ b/buffet/device_registration_info.cc
@@ -53,7 +53,7 @@
     FILE_PATH_LITERAL("/var/lib/buffet/device_reg_info");
 
 bool GetParamValue(
-    const std::map<std::string, std::shared_ptr<base::Value>>& params,
+    const std::map<std::string, std::unique_ptr<base::Value>>& params,
     const std::string& param_name,
     std::string* param_value) {
   auto p = params.find(param_name);
@@ -335,7 +335,7 @@
 }
 
 std::string DeviceRegistrationInfo::StartRegistration(
-    const std::map<std::string, std::shared_ptr<base::Value>>& params,
+    const std::map<std::string, std::unique_ptr<base::Value>>& params,
     chromeos::ErrorPtr* error) {
   GetParamValue(params, storage_keys::kClientId, &client_id_);
   GetParamValue(params, storage_keys::kClientSecret, &client_secret_);
diff --git a/buffet/device_registration_info.h b/buffet/device_registration_info.h
index df23e36..1985bb6 100644
--- a/buffet/device_registration_info.h
+++ b/buffet/device_registration_info.h
@@ -96,7 +96,7 @@
   // and so on. If a particular key-value pair is omitted, a default value
   // is used when possible. Returns a device claim ID on success.
   std::string StartRegistration(
-    const std::map<std::string, std::shared_ptr<base::Value>>& params,
+    const std::map<std::string, std::unique_ptr<base::Value>>& params,
     chromeos::ErrorPtr* error);
 
   // Finalizes the device registration. If |user_auth_code| is provided, then
diff --git a/buffet/device_registration_info_unittest.cc b/buffet/device_registration_info_unittest.cc
index 553a118..635b539 100644
--- a/buffet/device_registration_info_unittest.cc
+++ b/buffet/device_registration_info_unittest.cc
@@ -325,7 +325,7 @@
   transport_->AddHandler(dev_reg_->GetServiceURL("registrationTickets"),
                          request_type::kPost,
                          base::Bind(create_ticket));
-  std::map<std::string, std::shared_ptr<base::Value>> params;
+  std::map<std::string, std::unique_ptr<base::Value>> params;
   std::string json_resp = dev_reg_->StartRegistration(params, nullptr);
   auto json = std::unique_ptr<base::Value>(base::JSONReader::Read(json_resp));
   EXPECT_NE(nullptr, json.get());
diff --git a/buffet/manager.cc b/buffet/manager.cc
index 6c258ba..749e84a 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -22,112 +22,41 @@
 #include "buffet/dbus_constants.h"
 
 using chromeos::dbus_utils::AsyncEventSequencer;
-using chromeos::dbus_utils::GetBadArgsError;
 using chromeos::dbus_utils::ExportedObjectManager;
-using chromeos::dbus_utils::GetDBusError;
 
 namespace buffet {
 
-Manager::Manager(
-    const base::WeakPtr<ExportedObjectManager>& object_manager)
-    : exported_object_(object_manager->GetBus()->GetExportedObject(
-          dbus::ObjectPath(dbus_constants::kManagerServicePath))),
-      object_manager_(object_manager) { }
+Manager::Manager(const base::WeakPtr<ExportedObjectManager>& object_manager)
+    : dbus_object_(object_manager.get(),
+                   object_manager->GetBus(),
+                   dbus::ObjectPath(dbus_constants::kManagerServicePath)) {}
 
-Manager::~Manager() {
-  object_manager_->ReleaseInterface(
-      dbus::ObjectPath(dbus_constants::kManagerServicePath),
-      dbus_constants::kManagerInterface);
-  // Prevent the properties object from making calls to the exported object.
-  properties_.reset(nullptr);
-  // Unregister ourselves from the Bus.  This prevents the bus from calling
-  // our callbacks in between the Manager's death and the bus unregistering
-  // our exported object on shutdown.  Unretained makes no promises of memory
-  // management.
-  exported_object_->Unregister();
-  exported_object_ = nullptr;
-}
-
-void Manager::Init(const OnInitFinish& cb) {
-  scoped_refptr<AsyncEventSequencer> sequencer(
-      new AsyncEventSequencer());
-  exported_object_->ExportMethod(
-      dbus_constants::kManagerInterface,
-      dbus_constants::kManagerCheckDeviceRegistered,
-      chromeos::dbus_utils::GetExportableDBusMethod(
-          base::Bind(&Manager::HandleCheckDeviceRegistered,
-          base::Unretained(this))),
-      sequencer->GetExportHandler(
-          dbus_constants::kManagerInterface,
-          dbus_constants::kManagerCheckDeviceRegistered,
-          "Failed exporting CheckDeviceRegistered method",
-          true));
-  exported_object_->ExportMethod(
-      dbus_constants::kManagerInterface,
-      dbus_constants::kManagerGetDeviceInfo,
-      chromeos::dbus_utils::GetExportableDBusMethod(
-          base::Bind(&Manager::HandleGetDeviceInfo,
-          base::Unretained(this))),
-      sequencer->GetExportHandler(
-          dbus_constants::kManagerInterface,
-          dbus_constants::kManagerGetDeviceInfo,
-          "Failed exporting GetDeviceInfo method",
-          true));
-  exported_object_->ExportMethod(
-      dbus_constants::kManagerInterface,
-      dbus_constants::kManagerStartRegisterDevice,
-      chromeos::dbus_utils::GetExportableDBusMethod(
-          base::Bind(&Manager::HandleStartRegisterDevice,
-          base::Unretained(this))),
-      sequencer->GetExportHandler(
-          dbus_constants::kManagerInterface,
-          dbus_constants::kManagerStartRegisterDevice,
-          "Failed exporting StartRegisterDevice method",
-          true));
-  exported_object_->ExportMethod(
-      dbus_constants::kManagerInterface,
-      dbus_constants::kManagerFinishRegisterDevice,
-      chromeos::dbus_utils::GetExportableDBusMethod(
-          base::Bind(&Manager::HandleFinishRegisterDevice,
-          base::Unretained(this))),
-      sequencer->GetExportHandler(
-          dbus_constants::kManagerInterface,
-          dbus_constants::kManagerFinishRegisterDevice,
-          "Failed exporting FinishRegisterDevice method",
-          true));
-  exported_object_->ExportMethod(
-      dbus_constants::kManagerInterface,
-      dbus_constants::kManagerUpdateStateMethod,
-      chromeos::dbus_utils::GetExportableDBusMethod(
-          base::Bind(&Manager::HandleUpdateState,
-          base::Unretained(this))),
-      sequencer->GetExportHandler(
-          dbus_constants::kManagerInterface,
-          dbus_constants::kManagerUpdateStateMethod,
-          "Failed exporting UpdateState method",
-          true));
-  exported_object_->ExportMethod(
-      dbus_constants::kManagerInterface, dbus_constants::kManagerTestMethod,
-      chromeos::dbus_utils::GetExportableDBusMethod(
-          base::Bind(&Manager::HandleTestMethod, base::Unretained(this))),
-      sequencer->GetExportHandler(
-          dbus_constants::kManagerInterface, dbus_constants::kManagerTestMethod,
-          "Failed exporting TestMethod method",
-          true));
-  properties_.reset(new Properties(object_manager_->GetBus()));
+void Manager::Init(const AsyncEventSequencer::CompletionAction& cb) {
+  chromeos::dbus_utils::DBusInterface* itf =
+      dbus_object_.AddOrGetInterface(dbus_constants::kManagerInterface);
+  itf->AddMethodHandler(dbus_constants::kManagerCheckDeviceRegistered,
+                        base::Unretained(this),
+                        &Manager::HandleCheckDeviceRegistered);
+  itf->AddMethodHandler(dbus_constants::kManagerGetDeviceInfo,
+                        base::Unretained(this),
+                        &Manager::HandleGetDeviceInfo);
+  itf->AddMethodHandler(dbus_constants::kManagerStartRegisterDevice,
+                        base::Unretained(this),
+                        &Manager::HandleStartRegisterDevice);
+  itf->AddMethodHandler(dbus_constants::kManagerFinishRegisterDevice,
+                        base::Unretained(this),
+                        &Manager::HandleFinishRegisterDevice);
+  itf->AddMethodHandler(dbus_constants::kManagerUpdateStateMethod,
+                        base::Unretained(this),
+                        &Manager::HandleUpdateState);
+  itf->AddMethodHandler(dbus_constants::kManagerTestMethod,
+                        base::Unretained(this),
+                        &Manager::HandleTestMethod);
+  itf->AddProperty("State", &state_);
   // TODO(wiley): Initialize all properties appropriately before claiming
   //              the properties interface.
-  properties_->state_.SetValue("{}");
-  properties_->Init(
-      sequencer->GetHandler("Manager properties export failed.", true));
-  auto claim_interface_task = sequencer->WrapCompletionTask(
-      base::Bind(&ExportedObjectManager::ClaimInterface,
-                 object_manager_->AsWeakPtr(),
-                 dbus::ObjectPath(dbus_constants::kManagerServicePath),
-                 dbus_constants::kManagerInterface,
-                 properties_->GetPropertyWriter(
-                     dbus_constants::kManagerInterface)));
-  sequencer->OnAllTasksCompletedCall({claim_interface_task, cb});
+  state_.SetValue("{}");
+  dbus_object_.RegisterAsync(cb);
   command_manager_ = std::make_shared<CommandManager>();
   command_manager_->Startup();
   device_info_ = std::unique_ptr<DeviceRegistrationInfo>(
@@ -135,177 +64,63 @@
   device_info_->Load();
 }
 
-scoped_ptr<dbus::Response> Manager::HandleCheckDeviceRegistered(
-    dbus::MethodCall* method_call) {
-  // Read the parameters to the method.
-  dbus::MessageReader reader(method_call);
-  if (reader.HasMoreData()) {
-    return GetBadArgsError(method_call,
-                           "Too many parameters to CheckDeviceRegistered");
-  }
-
+std::string Manager::HandleCheckDeviceRegistered(chromeos::ErrorPtr* error) {
   LOG(INFO) << "Received call to Manager.CheckDeviceRegistered()";
-
-  chromeos::ErrorPtr error;
-  bool registered = device_info_->CheckRegistration(&error);
+  std::string device_id;
+  bool registered = device_info_->CheckRegistration(error);
   // If it fails due to any reason other than 'device not registered',
   // treat it as a real error and report it to the caller.
   if (!registered &&
-      !error->HasError(kErrorDomainGCD, "device_not_registered")) {
-    return scoped_ptr<dbus::Response>(
-        GetDBusError(method_call, error.get()).release());
+      !(*error)->HasError(kErrorDomainGCD, "device_not_registered")) {
+    return device_id;
   }
 
-  std::string device_id;
-  if (registered) {
-    device_id = device_info_->GetDeviceId(&error);
-    if (device_id.empty())
-      return scoped_ptr<dbus::Response>(
-          GetDBusError(method_call, error.get()).release());
-  }
-  // Send back our response.
-  scoped_ptr<dbus::Response> response(
-      dbus::Response::FromMethodCall(method_call));
-  dbus::MessageWriter writer(response.get());
-  writer.AppendString(device_id);
-  return response.Pass();
+  error->reset();
+
+  if (registered)
+    device_id = device_info_->GetDeviceId(error);
+
+  return device_id;
 }
 
-scoped_ptr<dbus::Response> Manager::HandleGetDeviceInfo(
-    dbus::MethodCall* method_call) {
-  // Read the parameters to the method.
-  dbus::MessageReader reader(method_call);
-  if (reader.HasMoreData()) {
-    return GetBadArgsError(method_call,
-                           "Too many parameters to GetDeviceInfo");
-  }
-
+std::string Manager::HandleGetDeviceInfo(chromeos::ErrorPtr* error) {
   LOG(INFO) << "Received call to Manager.GetDeviceInfo()";
 
   std::string device_info_str;
-  chromeos::ErrorPtr error;
-  auto device_info = device_info_->GetDeviceInfo(&error);
+  auto device_info = device_info_->GetDeviceInfo(error);
   if (!device_info)
-    return scoped_ptr<dbus::Response>(
-        GetDBusError(method_call, error.get()).release());
+    return device_info_str;
 
   base::JSONWriter::Write(device_info.get(), &device_info_str);
-
-  // Send back our response.
-  scoped_ptr<dbus::Response> response(
-      dbus::Response::FromMethodCall(method_call));
-  dbus::MessageWriter writer(response.get());
-  writer.AppendString(device_info_str);
-  return response.Pass();
+  return device_info_str;
 }
 
-scoped_ptr<dbus::Response> Manager::HandleStartRegisterDevice(
-    dbus::MethodCall* method_call) {
-  // Read the parameters to the method.
-  dbus::MessageReader reader(method_call);
-  if (!reader.HasMoreData()) {
-    return GetBadArgsError(method_call, "No parameters to StartRegisterDevice");
-  }
-
-  dbus::MessageReader array_reader(nullptr);
-  if (!reader.PopArray(&array_reader))
-    return GetBadArgsError(method_call, "Failed to read the parameter array");
-  std::map<std::string, std::shared_ptr<base::Value>> params;
-  while (array_reader.HasMoreData()) {
-    dbus::MessageReader dict_entry_reader(nullptr);
-    if (!array_reader.PopDictEntry(&dict_entry_reader))
-      return GetBadArgsError(method_call, "Failed to get a call parameter");
-    std::string key;
-    if (!dict_entry_reader.PopString(&key))
-      return GetBadArgsError(method_call, "Failed to read parameter key");
-    base::Value* value = dbus::PopDataAsValue(&dict_entry_reader);
-    if (!value)
-      return GetBadArgsError(method_call, "Failed to read parameter value");
-    params.insert(std::make_pair(key, std::shared_ptr<base::Value>(value)));
-  }
-  if (reader.HasMoreData())
-    return GetBadArgsError(method_call,
-                           "Too many parameters to StartRegisterDevice");
-
+std::string Manager::HandleStartRegisterDevice(
+    chromeos::ErrorPtr* error,
+    const std::map<std::string,
+    std::unique_ptr<base::Value>>& params) {
   LOG(INFO) << "Received call to Manager.StartRegisterDevice()";
 
-  chromeos::ErrorPtr error;
-  std::string id = device_info_->StartRegistration(params, &error);
-  if (id.empty())
-    return scoped_ptr<dbus::Response>(
-        GetDBusError(method_call, error.get()).release());
-
-  // Send back our response.
-  scoped_ptr<dbus::Response> response(
-      dbus::Response::FromMethodCall(method_call));
-  dbus::MessageWriter writer(response.get());
-  writer.AppendString(id);
-  return response.Pass();
+  return device_info_->StartRegistration(params, error);
 }
 
-scoped_ptr<dbus::Response> Manager::HandleFinishRegisterDevice(
-  dbus::MethodCall* method_call) {
-  // Read the parameters to the method.
-  dbus::MessageReader reader(method_call);
-  if (!reader.HasMoreData()) {
-    return GetBadArgsError(method_call,
-                           "No parameters to FinishRegisterDevice");
-  }
-  std::string user_auth_code;
-  if (!reader.PopString(&user_auth_code)) {
-    return GetBadArgsError(method_call, "Failed to read UserAuthCode");
-  }
-  if (reader.HasMoreData()) {
-    return GetBadArgsError(method_call,
-                           "Too many parameters to FinishRegisterDevice");
-  }
-
+std::string Manager::HandleFinishRegisterDevice(
+    chromeos::ErrorPtr* error, const std::string& user_auth_code) {
   LOG(INFO) << "Received call to Manager.FinishRegisterDevice()";
-  chromeos::ErrorPtr error;
-  if (!device_info_->FinishRegistration(user_auth_code, &error))
-    return scoped_ptr<dbus::Response>(
-        GetDBusError(method_call, error.get()).release());
+  if (!device_info_->FinishRegistration(user_auth_code, error))
+    return std::string();
 
-  std::string device_id = device_info_->GetDeviceId(&error);
-  if (device_id.empty())
-    return scoped_ptr<dbus::Response>(
-        GetDBusError(method_call, error.get()).release());
-
-  // Send back our response.
-  scoped_ptr<dbus::Response> response(
-    dbus::Response::FromMethodCall(method_call));
-  dbus::MessageWriter writer(response.get());
-  writer.AppendString(device_id);
-  return response.Pass();
+  return device_info_->GetDeviceId(error);
 }
 
-scoped_ptr<dbus::Response> Manager::HandleUpdateState(
-    dbus::MethodCall *method_call) {
-  // Read the parameters to the method.
-  dbus::MessageReader reader(method_call);
-  if (!reader.HasMoreData()) {
-    return GetBadArgsError(method_call, "No parameters to UpdateState");
-  }
-  std::string json_state_fragment;
-  if (!reader.PopString(&json_state_fragment)) {
-    return GetBadArgsError(method_call, "Failed to read json_state_fragment");
-  }
-  if (reader.HasMoreData()) {
-    return GetBadArgsError(method_call, "Too many parameters to UpdateState");
-  }
-
-  LOG(INFO) << "Received call to Manager.UpdateState()";
+void Manager::HandleUpdateState(
+    chromeos::ErrorPtr* error, const std::string& json_state_fragment) {
   // TODO(wiley): Merge json state blobs intelligently.
-  properties_->state_.SetValue(json_state_fragment);
-
-  // Send back our response.
-  return dbus::Response::FromMethodCall(method_call);
+  state_.SetValue(json_state_fragment);
 }
 
-scoped_ptr<dbus::Response> Manager::HandleTestMethod(
-    dbus::MethodCall* method_call) {
-  LOG(INFO) << "Received call to test method.";
-  return scoped_ptr<dbus::Response>();
+void Manager::HandleTestMethod(chromeos::ErrorPtr* error) {
+  LOG(INFO) << "Received call to test method";
 }
 
 }  // namespace buffet
diff --git a/buffet/manager.h b/buffet/manager.h
index 2bb9d5f..73ed8aa 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -5,19 +5,17 @@
 #ifndef BUFFET_MANAGER_H_
 #define BUFFET_MANAGER_H_
 
+#include <map>
 #include <memory>
 #include <string>
 
 #include <base/basictypes.h>
-#include <base/memory/scoped_ptr.h>
 #include <base/memory/weak_ptr.h>
 #include <base/values.h>
+#include <chromeos/dbus/dbus_object.h>
+#include <chromeos/error.h>
 #include <chromeos/exported_property_set.h>
-#include <dbus/bus.h>
-#include <dbus/message.h>
-#include <dbus/object_path.h>
 
-#include "buffet/dbus_constants.h"
 #include "buffet/device_registration_info.h"
 
 namespace chromeos {
@@ -33,49 +31,37 @@
 // The Manager is responsible for global state of Buffet.  It exposes
 // interfaces which affect the entire device such as device registration and
 // device state.
-class Manager {
+class Manager final {
  public:
-  typedef base::Callback<void(bool success)> OnInitFinish;
-
-  Manager(const base::WeakPtr<chromeos::dbus_utils::ExportedObjectManager>&
-              object_manager);
-  ~Manager();
-  void Init(const OnInitFinish& cb);
+  explicit Manager(
+      const base::WeakPtr<chromeos::dbus_utils::ExportedObjectManager>&
+          object_manager);
+  void Init(
+      const chromeos::dbus_utils::AsyncEventSequencer::CompletionAction& cb);
 
  private:
-  struct Properties: public chromeos::dbus_utils::ExportedPropertySet {
-   public:
-    chromeos::dbus_utils::ExportedProperty<std::string> state_;
-    explicit Properties(dbus::Bus* bus)
-        : chromeos::dbus_utils::ExportedPropertySet(
-              bus, dbus::ObjectPath(dbus_constants::kManagerServicePath)) {
-      RegisterProperty(dbus_constants::kManagerInterface, "State", &state_);
-    }
-    virtual ~Properties() {}
-  };
+  // DBus properties:
+  chromeos::dbus_utils::ExportedProperty<std::string> state_;
 
+  // DBus methods:
   // Handles calls to org.chromium.Buffet.Manager.CheckDeviceRegistered().
-  scoped_ptr<dbus::Response> HandleCheckDeviceRegistered(
-      dbus::MethodCall* method_call);
+  std::string HandleCheckDeviceRegistered(chromeos::ErrorPtr* error);
   // Handles calls to org.chromium.Buffet.Manager.GetDeviceInfo().
-  scoped_ptr<dbus::Response> HandleGetDeviceInfo(
-      dbus::MethodCall* method_call);
+  std::string HandleGetDeviceInfo(chromeos::ErrorPtr* error);
   // Handles calls to org.chromium.Buffet.Manager.StartRegisterDevice().
-  scoped_ptr<dbus::Response> HandleStartRegisterDevice(
-      dbus::MethodCall* method_call);
+  std::string HandleStartRegisterDevice(chromeos::ErrorPtr* error,
+                                        const std::map<std::string,
+                                        std::unique_ptr<base::Value>>& params);
   // Handles calls to org.chromium.Buffet.Manager.FinishRegisterDevice().
-  scoped_ptr<dbus::Response> HandleFinishRegisterDevice(
-      dbus::MethodCall* method_call);
+  std::string HandleFinishRegisterDevice(chromeos::ErrorPtr* error,
+                                         const std::string& user_auth_code);
   // Handles calls to org.chromium.Buffet.Manager.UpdateState().
-  scoped_ptr<dbus::Response> HandleUpdateState(
-      dbus::MethodCall* method_call);
+  void HandleUpdateState(chromeos::ErrorPtr* error,
+                         const std::string& json_state_fragment);
   // Handles calls to org.chromium.Buffet.Manager.Test()
-  scoped_ptr<::dbus::Response> HandleTestMethod(
-      ::dbus::MethodCall* method_call);
+  void HandleTestMethod(chromeos::ErrorPtr* error);
 
-  dbus::ExportedObject* exported_object_;  // weak; owned by the Bus object.
-  base::WeakPtr<chromeos::dbus_utils::ExportedObjectManager> object_manager_;
-  scoped_ptr<Properties> properties_;
+  chromeos::dbus_utils::DBusObject dbus_object_;
 
   std::shared_ptr<CommandManager> command_manager_;
   std::unique_ptr<DeviceRegistrationInfo> device_info_;