diff --git a/buffet/async_event_sequencer.cc b/buffet/async_event_sequencer.cc
index bf08d14..1dca62c 100644
--- a/buffet/async_event_sequencer.cc
+++ b/buffet/async_event_sequencer.cc
@@ -40,6 +40,16 @@
   PossiblyRunCompletionActions();
 }
 
+namespace {
+void IgnoreSuccess(const AsyncEventSequencer::CompletionTask& task,
+                   bool /*success*/) { task.Run(); }
+}  // namespace
+
+AsyncEventSequencer::CompletionAction AsyncEventSequencer::WrapCompletionTask(
+    const CompletionTask& task) {
+  return base::Bind(&IgnoreSuccess, task);
+}
+
 void AsyncEventSequencer::HandleFinish(int registration_number,
                                        const std::string& error_message,
                                        bool failure_is_fatal, bool success) {
diff --git a/buffet/async_event_sequencer.h b/buffet/async_event_sequencer.h
index ab5bc1a..96adad7 100644
--- a/buffet/async_event_sequencer.h
+++ b/buffet/async_event_sequencer.h
@@ -41,24 +41,32 @@
                                const std::string& method_name,
                                bool success)> ExportHandler;
   typedef base::Callback<void(bool all_succeeded)> CompletionAction;
+  typedef base::Callback<void(void)> CompletionTask;
 
   AsyncEventSequencer();
+
   // Get a Finished handler callback.  Each callback is "unique" in the sense
   // that subsequent calls to GetHandler() will create new handlers
   // which will need to be called before completion actions are run.
   Handler GetHandler(const std::string& descriptive_message,
                      bool failure_is_fatal);
+
   // Like GetHandler except with a signature tailored to
   // ExportedObject's ExportMethod callback requirements.  Will also assert
   // that the passed interface/method names from ExportedObject are correct.
   ExportHandler GetExportHandler(
       const std::string& interface_name, const std::string& method_name,
       const std::string& descriptive_message, bool failure_is_fatal);
+
   // Once all handlers obtained via GetHandler have run,
   // we'll run each CompletionAction, then discard our references.
   // No more handlers may be obtained after this call.
   void OnAllTasksCompletedCall(std::vector<CompletionAction> actions);
 
+  // Wrap a CompletionTask with a function that discards the result.
+  // This CompletionTask retains no references to the AsyncEventSequencer.
+  CompletionAction WrapCompletionTask(const CompletionTask& task);
+
  private:
   // We'll partially bind this function before giving it back via
   // GetHandler.  Note that the returned callbacks have
diff --git a/buffet/buffet_client.cc b/buffet/buffet_client.cc
index 34eb89f..a763e42 100644
--- a/buffet/buffet_client.cc
+++ b/buffet/buffet_client.cc
@@ -14,6 +14,7 @@
 #include <dbus/bus.h>
 #include <dbus/message.h>
 #include <dbus/object_proxy.h>
+#include <dbus/object_manager.h>
 #include <dbus/values_util.h>
 
 #include "buffet/dbus_constants.h"
@@ -34,6 +35,7 @@
   std::cerr << "  " << kManagerFinishRegisterDevice
                     << " device_id" << std::endl;
   std::cerr << "  " << kManagerUpdateStateMethod << std::endl;
+  std::cerr << "  " << dbus::kObjectManagerGetManagedObjects << std::endl;
 }
 
 class BuffetHelperProxy {
@@ -45,6 +47,9 @@
     manager_proxy_ = bus_->GetObjectProxy(
         kServiceName,
         dbus::ObjectPath(kManagerServicePath));
+    root_proxy_ = bus_->GetObjectProxy(
+        kServiceName,
+        dbus::ObjectPath(kRootServicePath));
     return EX_OK;
   }
 
@@ -226,9 +231,29 @@
     return EX_OK;
   }
 
+  int CallRootGetManagedObjects(const CommandLine::StringVector& args) {
+    if (!args.empty()) {
+      std::cerr << "Invalid number of arguments for "
+                << dbus::kObjectManagerGetManagedObjects << std::endl;
+      usage();
+      return EX_USAGE;
+    }
+    dbus::MethodCall method_call(
+        dbus::kObjectManagerInterface, dbus::kObjectManagerGetManagedObjects);
+    scoped_ptr<dbus::Response> response(
+        root_proxy_->CallMethodAndBlock(&method_call, default_timeout_ms));
+    if (!response) {
+      std::cout << "Failed to receive a response." << std::endl;
+      return EX_UNAVAILABLE;
+    }
+    std::cout << response->ToString() << std::endl;
+    return EX_OK;
+  }
+
  private:
   scoped_refptr<dbus::Bus> bus_;
   dbus::ObjectProxy* manager_proxy_{nullptr};  // NOLINT - initializer list
+  dbus::ObjectProxy* root_proxy_{nullptr};  // NOLINT - initializer list
 };
 
 }  // namespace
@@ -270,6 +295,8 @@
   } else if (command.compare(kManagerUpdateStateMethod) == 0 ||
              command.compare("us") == 0) {
     err = helper.CallManagerUpdateState(args);
+  } else if (command.compare(dbus::kObjectManagerGetManagedObjects) == 0) {
+    err = helper.CallRootGetManagedObjects(args);
   } else {
     std::cerr << "Unknown command: " << command << std::endl;
     usage();
diff --git a/buffet/exported_object_manager.cc b/buffet/exported_object_manager.cc
index 6458128..c1403ad 100644
--- a/buffet/exported_object_manager.cc
+++ b/buffet/exported_object_manager.cc
@@ -12,10 +12,9 @@
 
 namespace dbus_utils {
 
-ExportedObjectManager::ExportedObjectManager(dbus::Bus* bus,
+ExportedObjectManager::ExportedObjectManager(scoped_refptr<dbus::Bus> bus,
                                              const dbus::ObjectPath& path)
-    : bus_(bus), exported_object_(bus->GetExportedObject(path)),
-      weak_ptr_factory_(this) {}
+    : bus_(bus), exported_object_(bus->GetExportedObject(path)) {}
 
 void ExportedObjectManager::Init(const OnInitFinish& cb) {
   bus_->AssertOnOriginThread();
@@ -25,12 +24,13 @@
       dbus::kObjectManagerInterface,
       dbus::kObjectManagerGetManagedObjects,
       base::Bind(&ExportedObjectManager::HandleGetManagedObjects,
-                 weak_ptr_factory_.GetWeakPtr()),
+                 AsWeakPtr()),
       sequencer->GetExportHandler(
           dbus::kObjectManagerInterface,
           dbus::kObjectManagerGetManagedObjects,
           "Failed exporting GetManagedObjects method of ObjectManager",
           false));
+  sequencer->OnAllTasksCompletedCall({cb});
 }
 
 void ExportedObjectManager::ClaimInterface(
diff --git a/buffet/exported_object_manager.h b/buffet/exported_object_manager.h
index e1d8884..d483db0 100644
--- a/buffet/exported_object_manager.h
+++ b/buffet/exported_object_manager.h
@@ -69,14 +69,16 @@
 //     Properties my_properties_;
 //     ExampleObjectManager* object_manager_;
 //   };
-class ExportedObjectManager {
+class ExportedObjectManager
+    : public base::SupportsWeakPtr<ExportedObjectManager> {
  public:
   // Writes a dictionary of property name to property value variants to writer.
   typedef base::Callback<void(dbus::MessageWriter* writer)> PropertyWriter;
   typedef base::Callback<void(bool success)> OnInitFinish;
   typedef std::map<std::string, PropertyWriter> InterfaceProperties;
 
-  ExportedObjectManager(dbus::Bus* bus, const dbus::ObjectPath& path);
+  ExportedObjectManager(scoped_refptr<dbus::Bus> bus,
+                        const dbus::ObjectPath& path);
 
   // Registers methods implementing the ObjectManager interface on the object
   // exported on the path given in the constructor. Must be called on the
@@ -104,9 +106,6 @@
   // Tracks all objects currently known to the ExportedObjectManager.
   std::map<dbus::ObjectPath, InterfaceProperties> registered_objects_;
 
-  // We're going to register DBus callbacks that will outlive ourselves.
-  // These callbacks get scheduled on the origin thread.
-  base::WeakPtrFactory<ExportedObjectManager> weak_ptr_factory_;
   friend class ExportedObjectManagerTest;
   DISALLOW_COPY_AND_ASSIGN(ExportedObjectManager);
 };
diff --git a/buffet/exported_property_set.cc b/buffet/exported_property_set.cc
index ba6b2c7..b1b5633 100644
--- a/buffet/exported_property_set.cc
+++ b/buffet/exported_property_set.cc
@@ -51,7 +51,12 @@
   sequencer->OnAllTasksCompletedCall({cb});
 }
 
-ExportedPropertySet::~ExportedPropertySet() { }
+ExportedPropertySet::PropertyWriter ExportedPropertySet::GetPropertyWriter(
+    const std::string& interface) {
+  return base::Bind(&ExportedPropertySet::WritePropertiesDictToMessage,
+                    weak_ptr_factory_.GetWeakPtr(),
+                    interface);
+}
 
 void ExportedPropertySet::RegisterProperty(
     const std::string& interface_name,
diff --git a/buffet/exported_property_set.h b/buffet/exported_property_set.h
index 3d7abc5..405ed7d 100644
--- a/buffet/exported_property_set.h
+++ b/buffet/exported_property_set.h
@@ -95,9 +95,10 @@
 class ExportedPropertySet {
  public:
   typedef base::Callback<void(bool success)> OnInitFinish;
+  typedef base::Callback<void(dbus::MessageWriter* writer)> PropertyWriter;
 
   ExportedPropertySet(dbus::Bus* bus, const dbus::ObjectPath& path);
-  virtual ~ExportedPropertySet();
+  virtual ~ExportedPropertySet() = default;
 
   // Claims the method associated with the org.freedesktop.DBus.Properties
   // interface.  This needs to be done after all properties are initialized to
@@ -105,8 +106,11 @@
   // are exported to the DBus object.  |cb| will be called on the origin
   // thread.
   void Init(const OnInitFinish& cb);
-  base::Callback<void(dbus::MessageWriter* writer)> GetPropertyWriter(
-      const std::string& interface);
+
+  // Return a callback that knows how to write this property set's properties
+  // to a message.  This writer retains a weak pointer to this, and must
+  // only be invoked on the same thread as the rest of ExportedPropertySet.
+  PropertyWriter GetPropertyWriter(const std::string& interface);
 
  protected:
   void RegisterProperty(const std::string& interface_name,
diff --git a/buffet/main.cc b/buffet/main.cc
index e48a1b0..43ba4ab 100644
--- a/buffet/main.cc
+++ b/buffet/main.cc
@@ -16,9 +16,12 @@
 #include <sysexits.h>
 
 #include "buffet/async_event_sequencer.h"
+#include "buffet/dbus_constants.h"
+#include "buffet/exported_object_manager.h"
 #include "buffet/manager.h"
 
 using buffet::dbus_utils::AsyncEventSequencer;
+using buffet::dbus_utils::ExportedObjectManager;
 
 namespace {
 
@@ -87,7 +90,11 @@
 void EnterMainLoop(base::MessageLoopForIO* message_loop,
                    scoped_refptr<dbus::Bus> bus) {
   scoped_refptr<AsyncEventSequencer> sequencer(new AsyncEventSequencer());
-  buffet::Manager manager(bus.get());
+  ExportedObjectManager object_manager(
+      bus, dbus::ObjectPath(buffet::dbus_constants::kRootServicePath));
+  buffet::Manager manager(bus, object_manager.AsWeakPtr());
+  object_manager.Init(
+      sequencer->GetHandler("ObjectManager.Init() failed.", true));
   manager.Init(sequencer->GetHandler("Manager.Init() failed.", true));
   sequencer->OnAllTasksCompletedCall(
       {base::Bind(&TakeServiceOwnership, bus)});
diff --git a/buffet/manager.cc b/buffet/manager.cc
index 09985b3..3639803 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -18,18 +18,26 @@
 #include "buffet/dbus_constants.h"
 #include "buffet/dbus_utils.h"
 #include "buffet/error.h"
+#include "buffet/exported_object_manager.h"
 
+using buffet::dbus_utils::AsyncEventSequencer;
 using buffet::dbus_utils::GetBadArgsError;
 using buffet::dbus_utils::GetDBusError;
 
 namespace buffet {
 
-Manager::Manager(dbus::Bus* bus)
+Manager::Manager(
+    scoped_refptr<dbus::Bus> bus,
+    base::WeakPtr<dbus_utils::ExportedObjectManager> object_manager)
     : bus_(bus),
       exported_object_(bus->GetExportedObject(
-          dbus::ObjectPath(dbus_constants::kManagerServicePath))) { }
+          dbus::ObjectPath(dbus_constants::kManagerServicePath))),
+      object_manager_(object_manager) { }
 
 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
@@ -41,8 +49,8 @@
 }
 
 void Manager::Init(const OnInitFinish& cb) {
-  scoped_refptr<dbus_utils::AsyncEventSequencer> sequencer(
-      new dbus_utils::AsyncEventSequencer());
+  scoped_refptr<AsyncEventSequencer> sequencer(
+      new AsyncEventSequencer());
   exported_object_->ExportMethod(
       dbus_constants::kManagerInterface,
       dbus_constants::kManagerCheckDeviceRegistered,
@@ -112,7 +120,14 @@
   properties_->state_.SetValue("{}");
   properties_->Init(
       sequencer->GetHandler("Manager properties export failed.", true));
-  sequencer->OnAllTasksCompletedCall({cb});
+  auto claim_interface_task = sequencer->WrapCompletionTask(
+      base::Bind(&dbus_utils::ExportedObjectManager::ClaimInterface,
+                 object_manager_->AsWeakPtr(),
+                 dbus::ObjectPath(dbus_constants::kManagerServicePath),
+                 dbus_constants::kManagerInterface,
+                 properties_->GetPropertyWriter(
+                     dbus_constants::kManagerInterface)));
+  sequencer->OnAllTasksCompletedCall({claim_interface_task, cb});
   device_info_.Load();
 }
 
diff --git a/buffet/manager.h b/buffet/manager.h
index a508d81..4498c50 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -10,6 +10,7 @@
 
 #include <base/basictypes.h>
 #include <base/memory/scoped_ptr.h>
+#include <base/memory/weak_ptr.h>
 #include <base/values.h>
 #include <dbus/message.h>
 #include <dbus/object_path.h>
@@ -20,7 +21,9 @@
 
 namespace buffet {
 
-class DBusManager;
+namespace dbus_utils {
+class ExportedObjectManager;
+}  // namespace dbus_utils
 
 // The Manager is responsible for global state of Buffet.  It exposes
 // interfaces which affect the entire device such as device registration and
@@ -29,7 +32,8 @@
  public:
   typedef base::Callback<void(bool success)> OnInitFinish;
 
-  explicit Manager(dbus::Bus* bus);
+  Manager(scoped_refptr<dbus::Bus> bus,
+          base::WeakPtr<dbus_utils::ExportedObjectManager> object_manager);
   ~Manager();
   void Init(const OnInitFinish& cb);
 
@@ -64,8 +68,9 @@
   scoped_ptr<::dbus::Response> HandleTestMethod(
       ::dbus::MethodCall* method_call);
 
-  dbus::Bus* bus_;
+  scoped_refptr<dbus::Bus> bus_;
   dbus::ExportedObject* exported_object_;  // weak; owned by the Bus object.
+  base::WeakPtr<dbus_utils::ExportedObjectManager> object_manager_;
   scoped_ptr<Properties> properties_;
 
   DeviceRegistrationInfo device_info_;