diff --git a/buffet/buffet.gyp b/buffet/buffet.gyp
index 7870fc7..6254e56 100644
--- a/buffet/buffet.gyp
+++ b/buffet/buffet.gyp
@@ -43,7 +43,6 @@
         'error.cc',
         'error_codes.cc',
         'exported_object_manager.cc',
-        'exported_property_set.cc',
         'http_request.cc',
         'http_connection_curl.cc',
         'http_transport_curl.cc',
@@ -99,7 +98,6 @@
         'device_registration_info_unittest.cc',
         'error_unittest.cc',
         'exported_object_manager_unittest.cc',
-        'exported_property_set_unittest.cc',
         'http_connection_fake.cc',
         'http_transport_fake.cc',
         'http_utils_unittest.cc',
diff --git a/buffet/dbus_utils.cc b/buffet/dbus_utils.cc
index 5c02fb3..099abc1 100644
--- a/buffet/dbus_utils.cc
+++ b/buffet/dbus_utils.cc
@@ -4,6 +4,8 @@
 
 #include "buffet/dbus_utils.h"
 
+#include <string>
+
 #include <base/bind.h>
 #include <base/logging.h>
 
@@ -29,14 +31,6 @@
 
 }  // namespace
 
-scoped_ptr<dbus::Response> GetBadArgsError(dbus::MethodCall* method_call,
-                                           const std::string& message) {
-  LOG(ERROR) << "Error while handling DBus call: " << message;
-  scoped_ptr<dbus::ErrorResponse> resp(dbus::ErrorResponse::FromMethodCall(
-      method_call, "org.freedesktop.DBus.Error.InvalidArgs", message));
-  return scoped_ptr<dbus::Response>(resp.release());
-}
-
 scoped_ptr<dbus::Response> GetDBusError(dbus::MethodCall* method_call,
                                         const Error* error) {
   std::string message;
diff --git a/buffet/dbus_utils.h b/buffet/dbus_utils.h
index 6314531..ed4a76c 100644
--- a/buffet/dbus_utils.h
+++ b/buffet/dbus_utils.h
@@ -5,8 +5,6 @@
 #ifndef BUFFET_DBUS_UTILS_H_
 #define BUFFET_DBUS_UTILS_H_
 
-#include <string>
-
 #include <base/memory/scoped_ptr.h>
 #include <dbus/exported_object.h>
 #include <dbus/message.h>
@@ -17,13 +15,9 @@
 
 namespace dbus_utils {
 
-scoped_ptr<dbus::Response> GetBadArgsError(dbus::MethodCall* method_call,
-                                           const std::string& message);
-
 scoped_ptr<dbus::Response> GetDBusError(dbus::MethodCall* method_call,
                                         const Error* error);
 
-
 dbus::ExportedObject::MethodCallCallback GetExportableDBusMethod(
     base::Callback<scoped_ptr<dbus::Response>(dbus::MethodCall*)> handler);
 
diff --git a/buffet/exported_object_manager.h b/buffet/exported_object_manager.h
index d483db0..212609e 100644
--- a/buffet/exported_object_manager.h
+++ b/buffet/exported_object_manager.h
@@ -11,10 +11,9 @@
 #include <base/memory/weak_ptr.h>
 #include <dbus/bus.h>
 #include <dbus/exported_object.h>
+#include <dbus/message.h>
 #include <dbus/object_path.h>
 
-#include "buffet/exported_property_set.h"
-
 namespace buffet {
 
 namespace dbus_utils {
diff --git a/buffet/exported_property_set.cc b/buffet/exported_property_set.cc
deleted file mode 100644
index 3ab3c2d..0000000
--- a/buffet/exported_property_set.cc
+++ /dev/null
@@ -1,340 +0,0 @@
-// Copyright 2014 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.
-
-#include "buffet/exported_property_set.h"
-
-#include <base/bind.h>
-#include <chromeos/async_event_sequencer.h>
-#include <dbus/bus.h>  // For kPropertyInterface
-#include <dbus/property.h>  // For kPropertyInterface
-
-#include "buffet/dbus_utils.h"
-
-using chromeos::dbus_utils::AsyncEventSequencer;
-
-namespace buffet {
-
-namespace dbus_utils {
-
-namespace {
-const char kExportFailedMessage[] = "Failed to register DBus method.";
-}  // namespace
-
-ExportedPropertySet::ExportedPropertySet(dbus::Bus* bus,
-                                         const dbus::ObjectPath& path)
-    : bus_(bus), exported_object_(bus->GetExportedObject(path)),
-      weak_ptr_factory_(this) { }
-
-void ExportedPropertySet::Init(const OnInitFinish& cb) {
-  bus_->AssertOnOriginThread();
-  scoped_refptr<AsyncEventSequencer> sequencer(new AsyncEventSequencer());
-  exported_object_->ExportMethod(
-      dbus::kPropertiesInterface, dbus::kPropertiesGetAll,
-      base::Bind(&ExportedPropertySet::HandleGetAll,
-                 weak_ptr_factory_.GetWeakPtr()),
-      sequencer->GetExportHandler(
-          dbus::kPropertiesInterface, dbus::kPropertiesGetAll,
-          kExportFailedMessage, false));
-  exported_object_->ExportMethod(
-      dbus::kPropertiesInterface, dbus::kPropertiesGet,
-      base::Bind(&ExportedPropertySet::HandleGet,
-                 weak_ptr_factory_.GetWeakPtr()),
-      sequencer->GetExportHandler(
-          dbus::kPropertiesInterface, dbus::kPropertiesGet,
-          kExportFailedMessage, false));
-  exported_object_->ExportMethod(
-      dbus::kPropertiesInterface, dbus::kPropertiesSet,
-      base::Bind(&ExportedPropertySet::HandleSet,
-                 weak_ptr_factory_.GetWeakPtr()),
-      sequencer->GetExportHandler(
-          dbus::kPropertiesInterface, dbus::kPropertiesSet,
-          kExportFailedMessage, false));
-  sequencer->OnAllTasksCompletedCall({cb});
-}
-
-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,
-    const std::string& property_name,
-    ExportedPropertyBase* exported_property) {
-  bus_->AssertOnOriginThread();
-  properties_[interface_name][property_name] = exported_property;
-  // Technically, the property set exists longer than the properties themselves,
-  // so we could use Unretained here rather than a weak pointer.
-  ExportedPropertyBase::OnUpdateCallback cb = base::Bind(
-      &ExportedPropertySet::HandlePropertyUpdated,
-      weak_ptr_factory_.GetWeakPtr(),
-      interface_name, property_name);
-  exported_property->SetUpdateCallback(cb);
-}
-
-void ExportedPropertySet::HandleGetAll(
-    dbus::MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
-  bus_->AssertOnOriginThread();
-  dbus::MessageReader reader(method_call);
-  std::string interface_name;
-  if (!reader.PopString(&interface_name)) {
-    response_sender.Run(
-        GetBadArgsError(method_call, "No interface name specified."));
-    return;
-  }
-  if (reader.HasMoreData()) {
-    response_sender.Run(
-        GetBadArgsError(method_call, "Too many arguments to GetAll."));
-    return;
-  }
-  scoped_ptr<dbus::Response> response(
-      dbus::Response::FromMethodCall(method_call));
-  dbus::MessageWriter resp_writer(response.get());
-  WritePropertiesDictToMessage(interface_name, &resp_writer);
-  response_sender.Run(response.Pass());
-}
-
-void ExportedPropertySet::WritePropertiesDictToMessage(
-    const std::string& interface_name,
-    dbus::MessageWriter* writer) {
-  dbus::MessageWriter dict_writer(nullptr);
-  writer->OpenArray("{sv}", &dict_writer);
-  auto property_map_itr = properties_.find(interface_name);
-  if (property_map_itr != properties_.end()) {
-    for (const auto& kv : property_map_itr->second) {
-      dbus::MessageWriter entry_writer(nullptr);
-      dict_writer.OpenDictEntry(&entry_writer);
-      entry_writer.AppendString(kv.first);
-      kv.second->AppendValueToWriter(&entry_writer);
-      dict_writer.CloseContainer(&entry_writer);
-    }
-  } else {
-    LOG(WARNING) << "No properties found for interface interface_name";
-  }
-  writer->CloseContainer(&dict_writer);
-}
-
-void ExportedPropertySet::HandleGet(
-    dbus::MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
-  bus_->AssertOnOriginThread();
-  dbus::MessageReader reader(method_call);
-  std::string interface_name, property_name;
-  if (!reader.PopString(&interface_name)) {
-    response_sender.Run(
-        GetBadArgsError(method_call, "No interface name specified."));
-    return;
-  }
-  if (!reader.PopString(&property_name)) {
-    response_sender.Run(
-        GetBadArgsError(method_call, "No property name specified."));
-    return;
-  }
-  if (reader.HasMoreData()) {
-    response_sender.Run(
-        GetBadArgsError(method_call, "Too many arguments to Get."));
-    return;
-  }
-  auto property_map_itr = properties_.find(interface_name);
-  if (property_map_itr == properties_.end()) {
-    response_sender.Run(
-        GetBadArgsError(method_call, "No such interface on object."));
-    return;
-  }
-  LOG(ERROR) << "Looking for " << property_name << " on " << interface_name;
-  auto property_itr = property_map_itr->second.find(property_name);
-  if (property_itr == property_map_itr->second.end()) {
-    response_sender.Run(
-        GetBadArgsError(method_call, "No such property on interface."));
-    return;
-  }
-  scoped_ptr<dbus::Response> response(
-      dbus::Response::FromMethodCall(method_call));
-  dbus::MessageWriter resp_writer(response.get());
-  property_itr->second->AppendValueToWriter(&resp_writer);
-  response_sender.Run(response.Pass());
-}
-
-void ExportedPropertySet::HandleSet(
-    dbus::MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
-  bus_->AssertOnOriginThread();
-  scoped_ptr<dbus::ErrorResponse> error_resp(
-      dbus::ErrorResponse::FromMethodCall(
-          method_call, "org.freedesktop.DBus.Error.NotSupported", ""));
-  scoped_ptr<dbus::Response> response(error_resp.release());
-  response_sender.Run(response.Pass());
-}
-
-void ExportedPropertySet::HandlePropertyUpdated(
-    const std::string& interface,
-    const std::string& name,
-    const ExportedPropertyBase* property) {
-  bus_->AssertOnOriginThread();
-  dbus::Signal signal(dbus::kPropertiesInterface, dbus::kPropertiesChanged);
-  dbus::MessageWriter writer(&signal);
-  dbus::MessageWriter array_writer(nullptr);
-  dbus::MessageWriter dict_writer(nullptr);
-  writer.AppendString(interface);
-  writer.OpenArray("{sv}", &array_writer);
-  array_writer.OpenDictEntry(&dict_writer);
-  dict_writer.AppendString(name);
-  property->AppendValueToWriter(&dict_writer);
-  array_writer.CloseContainer(&dict_writer);
-  writer.CloseContainer(&array_writer);
-  // The interface specification tells us to include this list of properties
-  // which have changed, but for whom no value is conveyed.  Currently, we
-  // don't do anything interesting here.
-  writer.OpenArray("s", &array_writer);
-  writer.CloseContainer(&array_writer);
-  // This sends the signal asyncronously.  However, the raw message inside
-  // the signal object is ref-counted, so we're fine to allocate the Signal
-  // object on our local stack.
-  exported_object_->SendSignal(&signal);
-}
-
-template <typename T>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const T& value);
-
-template <>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const bool& value) {
-  writer->AppendVariantOfBool(value);
-}
-
-template <>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const uint8& value) {
-  writer->AppendVariantOfByte(value);
-}
-
-template <>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const int16& value) {
-  writer->AppendVariantOfInt16(value);
-}
-
-template <>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const uint16& value) {
-  writer->AppendVariantOfUint16(value);
-}
-
-template <>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const int32& value) {
-  writer->AppendVariantOfInt32(value);
-}
-
-template <>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const uint32& value) {
-  writer->AppendVariantOfUint32(value);
-}
-
-template <>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const int64& value) {
-  writer->AppendVariantOfInt64(value);
-}
-
-template <>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const uint64& value) {
-  writer->AppendVariantOfUint64(value);
-}
-
-template <>
-void AppendPropertyToWriter(dbus::MessageWriter* writer, const double& value) {
-  writer->AppendVariantOfDouble(value);
-}
-
-template <>
-void AppendPropertyToWriter(
-    dbus::MessageWriter* writer, const std::string& value) {
-  writer->AppendVariantOfString(value);
-}
-
-template <>
-void AppendPropertyToWriter(
-    dbus::MessageWriter* writer, const dbus::ObjectPath& value) {
-  writer->AppendVariantOfObjectPath(value);
-}
-
-template <>
-void AppendPropertyToWriter(
-    dbus::MessageWriter* writer, const std::vector<std::string>& value) {
-  dbus::MessageWriter variant_writer(nullptr);
-  writer->OpenVariant("as", &variant_writer);
-  variant_writer.AppendArrayOfStrings(value);
-  writer->CloseContainer(&variant_writer);
-}
-
-template <>
-void AppendPropertyToWriter(
-    dbus::MessageWriter* writer, const std::vector<dbus::ObjectPath>& value) {
-  dbus::MessageWriter variant_writer(nullptr);
-  writer->OpenVariant("ao", &variant_writer);
-  variant_writer.AppendArrayOfObjectPaths(value);
-  writer->CloseContainer(&variant_writer);
-}
-
-template <>
-void AppendPropertyToWriter(
-    dbus::MessageWriter* writer, const std::vector<uint8>& value) {
-  dbus::MessageWriter variant_writer(nullptr);
-  writer->OpenVariant("ay", &variant_writer);
-  variant_writer.AppendArrayOfBytes(value.data(), value.size());
-  writer->CloseContainer(&variant_writer);
-}
-
-template <typename T>
-ExportedProperty<T>::ExportedProperty() {}
-
-template <typename T>
-ExportedProperty<T>::~ExportedProperty() {}
-
-template <typename T>
-const T& ExportedProperty<T>::value() const { return value_; }
-
-template <typename T>
-void ExportedProperty<T>::SetValue(const T& new_value) {
-  if (value_ == new_value) {
-    return;
-  }
-  value_ = new_value;
-  // These is a brief period after the construction of an ExportedProperty
-  // when this callback is not initialized because the property has not
-  // been registered with the parent ExportedPropertySet.  During this period
-  // users should be initializing values via SetValue, and no notifications
-  // should be triggered by the ExportedPropertySet.
-  if (!on_update_.is_null()) {
-    on_update_.Run(this);
-  }
-}
-
-template <typename T>
-void ExportedProperty<T>::SetUpdateCallback(const OnUpdateCallback& cb) {
-  on_update_ = cb;
-}
-
-template <typename T>
-void ExportedProperty<T>::AppendValueToWriter(
-    dbus::MessageWriter* writer) const {
-  AppendPropertyToWriter(writer, value_);
-}
-
-template class ExportedProperty<bool>;
-template class ExportedProperty<uint8>;
-template class ExportedProperty<int16>;
-template class ExportedProperty<uint16>;
-template class ExportedProperty<int32>;
-template class ExportedProperty<uint32>;
-template class ExportedProperty<int64>;
-template class ExportedProperty<uint64>;
-template class ExportedProperty<double>;
-template class ExportedProperty<std::string>;
-template class ExportedProperty<dbus::ObjectPath>;
-template class ExportedProperty<std::vector<std::string>>;
-template class ExportedProperty<std::vector<dbus::ObjectPath>>;
-template class ExportedProperty<std::vector<uint8>>;
-
-}  // namespace dbus_utils
-
-}  // namespace buffet
diff --git a/buffet/exported_property_set.h b/buffet/exported_property_set.h
deleted file mode 100644
index d91415f..0000000
--- a/buffet/exported_property_set.h
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright 2014 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 BUFFET_EXPORTED_PROPERTY_SET_H_
-#define BUFFET_EXPORTED_PROPERTY_SET_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include <base/memory/weak_ptr.h>
-#include <dbus/exported_object.h>
-#include <dbus/message.h>
-
-namespace buffet {
-
-namespace dbus_utils {
-
-// This class may be used to implement the org.freedesktop.DBus.Properties
-// interface.  It sends the update signal on property updates:
-//
-//   org.freedesktop.DBus.Properties.PropertiesChanged (
-//       STRING interface_name,
-//       DICT<STRING,VARIANT> changed_properties,
-//       ARRAY<STRING> invalidated_properties);
-//
-//
-// and implements the required methods of the interface:
-//
-//   org.freedesktop.DBus.Properties.Get(in STRING interface_name,
-//                                       in STRING property_name,
-//                                       out VARIANT value);
-//   org.freedesktop.DBus.Properties.Set(in STRING interface_name,
-//                                       in STRING property_name,
-//                                       in VARIANT value);
-//   org.freedesktop.DBus.Properties.GetAll(in STRING interface_name,
-//                                          out DICT<STRING,VARIANT> props);
-//
-//  This class is very similar to the PropertySet class in Chrome, except that
-//  it allows objects to expose properties rather than to consume them.
-//
-//  Example usage:
-//
-//   class ExampleObjectExportingProperties {
-//    public:
-//     ExampleObjectExportingProperties(ExportedObject* exported_object)
-//         : p_(exported_object) {
-//       // Initialize properties appropriately.  Do this before
-//       // claiming the Properties interface so that daemons watching
-//       // this object don't see partial or inaccurate state.
-//       p_.ClaimPropertiesInterface();
-//     }
-//
-//    private:
-//     struct Properties : public buffet::dbus::ExportedPropertySet {
-//      public:
-//       buffet::dbus::ExportedProperty<std::string> name_;
-//       buffet::dbus::ExportedProperty<uint16> version_;
-//       buffet::dbus::ExportedProperty<dbus::ObjectPath> parent_;
-//       buffet::dbus::ExportedProperty<std::vector<std::string>> children_;
-//
-//       Properties(dbus::ExportedObject* exported_object)
-//           : buffet::dbus::ExportedPropertySet(exported_object) {
-//         RegisterProperty(kExampleInterfaceName, "Name", &name_);
-//         RegisterProperty(kExampleInterfaceName, "Version", &version_);
-//         RegisterProperty(kExampleInterfaceName, "Parent", &parent_);
-//         RegisterProperty(kExampleInterfaceName, "Children", &children_);
-//       }
-//       virtual ~Properties() {}
-//     };
-//
-//     Properties p_;
-//   };
-
-class ExportedPropertyBase {
- public:
-  ExportedPropertyBase() {}
-  virtual ~ExportedPropertyBase() {}
-
-  typedef base::Callback<void(const ExportedPropertyBase*)> OnUpdateCallback;
-
-  // Called by ExportedPropertySet to register a callback.  This callback
-  // triggers ExportedPropertySet to send a signal from the properties
-  // interface of the exported object.
-  virtual void SetUpdateCallback(const OnUpdateCallback& cb) = 0;
-
-  // Appends a variant of the contained value to the writer.  This is
-  // needed to write out properties to Get and GetAll methods implemented
-  // by the ExportedPropertySet since it doesn't actually know the type
-  // of each property.
-  virtual void AppendValueToWriter(dbus::MessageWriter* writer) const = 0;
-};
-
-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() = default;
-
-  // Claims the method associated with the org.freedesktop.DBus.Properties
-  // interface.  This needs to be done after all properties are initialized to
-  // appropriate values.  This method will call |cb| when all methods
-  // are exported to the DBus object.  |cb| will be called on the origin
-  // thread.
-  void Init(const OnInitFinish& cb);
-
-  // 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,
-                        const std::string& property_name,
-                        ExportedPropertyBase* exported_property);
-
- private:
-  // Used to write the dictionary of string->variant to a message.
-  // This dictionary represents the property name/value pairs for the
-  // given interface.
-  void WritePropertiesDictToMessage(const std::string& interface_name,
-                                    dbus::MessageWriter* writer);
-  void HandleGetAll(dbus::MethodCall* method_call,
-                    dbus::ExportedObject::ResponseSender response_sender);
-  void HandleGet(dbus::MethodCall* method_call,
-                 dbus::ExportedObject::ResponseSender response_sender);
-  // While Properties.Set has a handler to complete the interface,  we don't
-  // support writable properties.  This is almost a feature, since bindings for
-  // many languages don't support errors coming back from invalid writes.
-  // Instead, use setters in exposed interfaces.
-  void HandleSet(dbus::MethodCall* method_call,
-                 dbus::ExportedObject::ResponseSender response_sender);
-  void HandlePropertyUpdated(const std::string& interface,
-                             const std::string& name,
-                             const ExportedPropertyBase* property);
-
-  dbus::Bus* bus_;
-  dbus::ExportedObject* exported_object_;  // weak; owned by the Bus object.
-  // This is a map from interface name -> property name -> pointer to property.
-  std::map<std::string,
-           std::map<std::string, ExportedPropertyBase*>> properties_;
-
-  // D-Bus callbacks may last longer the property set exporting those methods.
-  base::WeakPtrFactory<ExportedPropertySet> weak_ptr_factory_;
-
-  friend class ExportedPropertySetTest;
-  DISALLOW_COPY_AND_ASSIGN(ExportedPropertySet);
-};
-
-template <typename T>
-class ExportedProperty : public ExportedPropertyBase {
- public:
-  ExportedProperty();
-  virtual ~ExportedProperty() override;
-
-  // Retrieves the current value.
-  const T& value() const;
-
-  // Set the value exposed to remote applications.  This triggers notifications
-  // of changes over the Properties interface.
-  void SetValue(const T& new_value);
-
-  // Called by ExportedPropertySet.  This update callback triggers
-  // ExportedPropertySet to send a signal from the properties interface of the
-  // exported object.
-  virtual void SetUpdateCallback(const OnUpdateCallback& cb) override;
-
-  // Implementation provided by specialization.
-  virtual void AppendValueToWriter(dbus::MessageWriter* writer) const override;
-
- private:
-  OnUpdateCallback on_update_;
-  T value_{};
-
-  DISALLOW_COPY_AND_ASSIGN(ExportedProperty);
-};
-
-extern template class ExportedProperty<bool>;
-extern template class ExportedProperty<uint8>;
-extern template class ExportedProperty<int16>;
-extern template class ExportedProperty<uint16>;
-extern template class ExportedProperty<int32>;
-extern template class ExportedProperty<uint32>;
-extern template class ExportedProperty<int64>;
-extern template class ExportedProperty<uint64>;
-extern template class ExportedProperty<double>;
-extern template class ExportedProperty<std::string>;
-extern template class ExportedProperty<dbus::ObjectPath>;
-extern template class ExportedProperty<std::vector<std::string>>;
-extern template class ExportedProperty<std::vector<dbus::ObjectPath>>;
-extern template class ExportedProperty<std::vector<uint8>>;
-
-}  // namespace dbus_utils
-
-}  // namespace buffet
-
-#endif  // BUFFET_EXPORTED_PROPERTY_SET_H_
diff --git a/buffet/exported_property_set_unittest.cc b/buffet/exported_property_set_unittest.cc
deleted file mode 100644
index ce8a3fe..0000000
--- a/buffet/exported_property_set_unittest.cc
+++ /dev/null
@@ -1,506 +0,0 @@
-// Copyright 2014 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.
-
-#include "buffet/exported_property_set.h"
-
-#include <string>
-#include <vector>
-
-#include <base/basictypes.h>
-#include <base/bind.h>
-#include <dbus/message.h>
-#include <dbus/property.h>
-#include <dbus/object_path.h>
-#include <dbus/mock_bus.h>
-#include <dbus/mock_exported_object.h>
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-using ::testing::AnyNumber;
-using ::testing::Return;
-using ::testing::Invoke;
-using ::testing::_;
-
-namespace buffet {
-
-namespace dbus_utils {
-
-namespace {
-
-const char kBoolPropName[] = "BoolProp";
-const char kUint8PropName[] = "Uint8Prop";
-const char kInt16PropName[] = "Int16Prop";
-const char kUint16PropName[] = "Uint16Prop";
-const char kInt32PropName[] = "Int32Prop";
-const char kUint32PropName[] = "Uint32Prop";
-const char kInt64PropName[] = "Int64Prop";
-const char kUint64PropName[] = "Uint64Prop";
-const char kDoublePropName[] = "DoubleProp";
-const char kStringPropName[] = "StringProp";
-const char kPathPropName[] = "PathProp";
-const char kStringListPropName[] = "StringListProp";
-const char kPathListPropName[] = "PathListProp";
-const char kUint8ListPropName[] = "Uint8ListProp";
-
-const char kTestInterface1[] = "org.chromium.TestInterface1";
-const char kTestInterface2[] = "org.chromium.TestInterface2";
-const char kTestInterface3[] = "org.chromium.TestInterface3";
-
-const std::string kTestString("lies");
-const dbus::ObjectPath kMethodsExportedOnPath(std::string("/export"));
-const dbus::ObjectPath kTestObjectPathInit(std::string("/path_init"));
-const dbus::ObjectPath kTestObjectPathUpdate(std::string("/path_update"));
-
-}  // namespace
-
-class ExportedPropertySetTest : public ::testing::Test {
- public:
-  struct Properties : public ExportedPropertySet {
-   public:
-    ExportedProperty<bool> bool_prop_;
-    ExportedProperty<uint8> uint8_prop_;
-    ExportedProperty<int16> int16_prop_;
-    ExportedProperty<uint16> uint16_prop_;
-    ExportedProperty<int32> int32_prop_;
-    ExportedProperty<uint32> uint32_prop_;
-    ExportedProperty<int64> int64_prop_;
-    ExportedProperty<uint64> uint64_prop_;
-    ExportedProperty<double> double_prop_;
-    ExportedProperty<std::string> string_prop_;
-    ExportedProperty<dbus::ObjectPath> path_prop_;
-    ExportedProperty<std::vector<std::string>> stringlist_prop_;
-    ExportedProperty<std::vector<dbus::ObjectPath>> pathlist_prop_;
-    ExportedProperty<std::vector<uint8>> uint8list_prop_;
-
-    Properties(dbus::Bus* bus, const dbus::ObjectPath& path)
-        : ExportedPropertySet(bus, path) {
-      // The empty string is not a valid value for an ObjectPath.
-      path_prop_.SetValue(kTestObjectPathInit);
-      RegisterProperty(kTestInterface1, kBoolPropName, &bool_prop_);
-      RegisterProperty(kTestInterface1, kUint8PropName, &uint8_prop_);
-      RegisterProperty(kTestInterface1, kInt16PropName, &int16_prop_);
-      // I chose this weird grouping because N=2 is about all the permutations
-      // of GetAll that I want to anticipate.
-      RegisterProperty(kTestInterface2, kUint16PropName, &uint16_prop_);
-      RegisterProperty(kTestInterface2, kInt32PropName, &int32_prop_);
-      RegisterProperty(kTestInterface3, kUint32PropName, &uint32_prop_);
-      RegisterProperty(kTestInterface3, kInt64PropName, &int64_prop_);
-      RegisterProperty(kTestInterface3, kUint64PropName, &uint64_prop_);
-      RegisterProperty(kTestInterface3, kDoublePropName, &double_prop_);
-      RegisterProperty(kTestInterface3, kStringPropName, &string_prop_);
-      RegisterProperty(kTestInterface3, kPathPropName, &path_prop_);
-      RegisterProperty(kTestInterface3, kStringListPropName, &stringlist_prop_);
-      RegisterProperty(kTestInterface3, kPathListPropName, &pathlist_prop_);
-      RegisterProperty(kTestInterface3, kUint8ListPropName, &uint8list_prop_);
-    }
-    virtual ~Properties() {}
-
-    void CallHandleGetAll(
-        dbus::MethodCall* method_call,
-        dbus::ExportedObject::ResponseSender response_sender) {
-      HandleGetAll(method_call, response_sender);
-    }
-
-    void CallHandleGet(dbus::MethodCall* method_call,
-                       dbus::ExportedObject::ResponseSender response_sender) {
-      HandleGet(method_call, response_sender);
-    }
-
-    void CallHandleSet(dbus::MethodCall* method_call,
-                       dbus::ExportedObject::ResponseSender response_sender) {
-      HandleSet(method_call, response_sender);
-    }
-  };
-
-  virtual void SetUp() {
-    dbus::Bus::Options options;
-    options.bus_type = dbus::Bus::SYSTEM;
-    bus_ = new dbus::MockBus(options);
-    // By default, don't worry about threading assertions.
-    EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
-    EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
-    // Use a mock exported object.
-    mock_exported_object_ = new dbus::MockExportedObject(
-        bus_.get(), kMethodsExportedOnPath);
-    EXPECT_CALL(*bus_, GetExportedObject(kMethodsExportedOnPath))
-        .Times(1).WillOnce(Return(mock_exported_object_.get()));
-    p_.reset(new Properties(bus_.get(), kMethodsExportedOnPath));
-  }
-
-  void StoreResponse(scoped_ptr<dbus::Response> method_response) {
-    last_response_.reset(method_response.release());
-  }
-
-  void AssertGetAllReturnsError(dbus::MethodCall* method_call) {
-    auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
-                                      base::Unretained(this));
-    method_call->SetSerial(123);
-    p_->CallHandleGetAll(method_call, response_sender);
-    ASSERT_NE(dynamic_cast<dbus::ErrorResponse*>(last_response_.get()),
-              nullptr);
-  }
-
-  void AssertGetReturnsError(dbus::MethodCall* method_call) {
-    auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
-                                      base::Unretained(this));
-    method_call->SetSerial(123);
-    p_->CallHandleGet(method_call, response_sender);
-    ASSERT_NE(dynamic_cast<dbus::ErrorResponse*>(last_response_.get()),
-              nullptr);
-  }
-
-  scoped_ptr<dbus::Response> GetPropertyOnInterface(
-      const std::string& interface_name, const std::string& property_name) {
-    dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                                 dbus::kPropertiesGet);
-    method_call.SetSerial(123);
-    dbus::MessageWriter writer(&method_call);
-    writer.AppendString(interface_name);
-    writer.AppendString(property_name);
-    auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
-                                      base::Unretained(this));
-    p_->CallHandleGet(&method_call, response_sender);
-    return last_response_.Pass();
-  }
-
-  scoped_ptr<dbus::Response> last_response_;
-  scoped_refptr<dbus::MockBus> bus_;
-  scoped_refptr<dbus::MockExportedObject> mock_exported_object_;
-  scoped_ptr<Properties> p_;
-};
-
-TEST_F(ExportedPropertySetTest, UpdateNotifications) {
-  EXPECT_CALL(*mock_exported_object_, SendSignal(_)).Times(14);
-  p_->bool_prop_.SetValue(true);
-  p_->uint8_prop_.SetValue(1);
-  p_->int16_prop_.SetValue(1);
-  p_->uint16_prop_.SetValue(1);
-  p_->int32_prop_.SetValue(1);
-  p_->uint32_prop_.SetValue(1);
-  p_->int64_prop_.SetValue(1);
-  p_->uint64_prop_.SetValue(1);
-  p_->double_prop_.SetValue(1.0);
-  p_->string_prop_.SetValue(kTestString);
-  p_->path_prop_.SetValue(kTestObjectPathUpdate);
-  p_->stringlist_prop_.SetValue({kTestString});
-  p_->pathlist_prop_.SetValue({kTestObjectPathUpdate});
-  p_->uint8list_prop_.SetValue({1});
-}
-
-TEST_F(ExportedPropertySetTest, UpdateToSameValue) {
-  EXPECT_CALL(*mock_exported_object_, SendSignal(_)).Times(1);
-  p_->bool_prop_.SetValue(true);
-  p_->bool_prop_.SetValue(true);
-}
-
-TEST_F(ExportedPropertySetTest, GetAllNoArgs) {
-  dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                               dbus::kPropertiesGetAll);
-  AssertGetAllReturnsError(&method_call);
-}
-
-TEST_F(ExportedPropertySetTest, GetAllInvalidInterface) {
-  dbus::MethodCall method_call(
-      dbus::kPropertiesInterface, dbus::kPropertiesGetAll);
-  method_call.SetSerial(123);
-  dbus::MessageWriter writer(&method_call);
-  writer.AppendString("org.chromium.BadInterface");
-  auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
-                                    base::Unretained(this));
-  p_->CallHandleGetAll(&method_call, response_sender);
-  dbus::MessageReader response_reader(last_response_.get());
-  dbus::MessageReader dict_reader(nullptr);
-  ASSERT_TRUE(response_reader.PopArray(&dict_reader));
-  // The response should just be a an empty array, since there are no properties
-  // on this interface.  The spec doesn't say much about error conditions here,
-  // so I'm going to assume this is a valid implementation.
-  ASSERT_FALSE(dict_reader.HasMoreData());
-  ASSERT_FALSE(response_reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetAllExtraArgs) {
-  dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                               dbus::kPropertiesGetAll);
-  dbus::MessageWriter writer(&method_call);
-  writer.AppendString(kTestInterface1);
-  writer.AppendString(kTestInterface1);
-  AssertGetAllReturnsError(&method_call);
-}
-
-TEST_F(ExportedPropertySetTest, GetAllCorrectness) {
-  dbus::MethodCall method_call(
-      dbus::kPropertiesInterface, dbus::kPropertiesGetAll);
-  method_call.SetSerial(123);
-  dbus::MessageWriter writer(&method_call);
-  writer.AppendString(kTestInterface2);
-  auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
-                                    base::Unretained(this));
-  p_->CallHandleGetAll(&method_call, response_sender);
-  dbus::MessageReader response_reader(last_response_.get());
-  dbus::MessageReader dict_reader(nullptr);
-  dbus::MessageReader entry_reader(nullptr);
-  ASSERT_TRUE(response_reader.PopArray(&dict_reader));
-  ASSERT_TRUE(dict_reader.PopDictEntry(&entry_reader));
-  std::string property_name;
-  ASSERT_TRUE(entry_reader.PopString(&property_name));
-  uint16 value16;
-  int32 value32;
-  if (property_name.compare(kUint16PropName) == 0) {
-    ASSERT_TRUE(entry_reader.PopVariantOfUint16(&value16));
-    ASSERT_FALSE(entry_reader.HasMoreData());
-    ASSERT_TRUE(dict_reader.PopDictEntry(&entry_reader));
-    ASSERT_TRUE(entry_reader.PopString(&property_name));
-    ASSERT_EQ(property_name.compare(kInt32PropName), 0);
-    ASSERT_TRUE(entry_reader.PopVariantOfInt32(&value32));
-  } else {
-    ASSERT_EQ(property_name.compare(kInt32PropName), 0);
-    ASSERT_TRUE(entry_reader.PopVariantOfInt32(&value32));
-    ASSERT_FALSE(entry_reader.HasMoreData());
-    ASSERT_TRUE(dict_reader.PopDictEntry(&entry_reader));
-    ASSERT_TRUE(entry_reader.PopString(&property_name));
-    ASSERT_EQ(property_name.compare(kUint16PropName), 0);
-    ASSERT_TRUE(entry_reader.PopVariantOfUint16(&value16));
-  }
-  ASSERT_FALSE(entry_reader.HasMoreData());
-  ASSERT_FALSE(dict_reader.HasMoreData());
-  ASSERT_FALSE(response_reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetNoArgs) {
-  dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                               dbus::kPropertiesGet);
-  AssertGetReturnsError(&method_call);
-}
-
-TEST_F(ExportedPropertySetTest, GetInvalidInterface) {
-  dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                               dbus::kPropertiesGet);
-  dbus::MessageWriter writer(&method_call);
-  writer.AppendString("org.chromium.BadInterface");
-  writer.AppendString(kInt16PropName);
-  AssertGetReturnsError(&method_call);
-}
-
-TEST_F(ExportedPropertySetTest, GetBadPropertyName) {
-  dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                               dbus::kPropertiesGet);
-  dbus::MessageWriter writer(&method_call);
-  writer.AppendString(kTestInterface1);
-  writer.AppendString("IAmNotAProperty");
-  AssertGetReturnsError(&method_call);
-}
-
-TEST_F(ExportedPropertySetTest, GetPropIfMismatch) {
-  dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                               dbus::kPropertiesGet);
-  dbus::MessageWriter writer(&method_call);
-  writer.AppendString(kTestInterface1);
-  writer.AppendString(kStringPropName);
-  AssertGetReturnsError(&method_call);
-}
-
-TEST_F(ExportedPropertySetTest, GetNoPropertyName) {
-  dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                               dbus::kPropertiesGet);
-  dbus::MessageWriter writer(&method_call);
-  writer.AppendString(kTestInterface1);
-  AssertGetReturnsError(&method_call);
-}
-
-TEST_F(ExportedPropertySetTest, GetExtraArgs) {
-  dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                               dbus::kPropertiesGet);
-  dbus::MessageWriter writer(&method_call);
-  writer.AppendString(kTestInterface1);
-  writer.AppendString(kBoolPropName);
-  writer.AppendString("Extra param");
-  AssertGetReturnsError(&method_call);
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithBool) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface1, kBoolPropName);
-  dbus::MessageReader reader(response.get());
-  bool value;
-  ASSERT_TRUE(reader.PopVariantOfBool(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithUint8) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface1, kUint8PropName);
-  dbus::MessageReader reader(response.get());
-  uint8 value;
-  ASSERT_TRUE(reader.PopVariantOfByte(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithInt16) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface1, kInt16PropName);
-  dbus::MessageReader reader(response.get());
-  int16 value;
-  ASSERT_TRUE(reader.PopVariantOfInt16(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithUint16) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface2, kUint16PropName);
-  dbus::MessageReader reader(response.get());
-  uint16 value;
-  ASSERT_TRUE(reader.PopVariantOfUint16(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithInt32) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface2, kInt32PropName);
-  dbus::MessageReader reader(response.get());
-  int32 value;
-  ASSERT_TRUE(reader.PopVariantOfInt32(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithUint32) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface3, kUint32PropName);
-  dbus::MessageReader reader(response.get());
-  uint32 value;
-  ASSERT_TRUE(reader.PopVariantOfUint32(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithInt64) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface3, kInt64PropName);
-  dbus::MessageReader reader(response.get());
-  int64 value;
-  ASSERT_TRUE(reader.PopVariantOfInt64(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithUint64) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface3, kUint64PropName);
-  dbus::MessageReader reader(response.get());
-  uint64 value;
-  ASSERT_TRUE(reader.PopVariantOfUint64(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithDouble) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface3, kDoublePropName);
-  dbus::MessageReader reader(response.get());
-  double value;
-  ASSERT_TRUE(reader.PopVariantOfDouble(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithString) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface3, kStringPropName);
-  dbus::MessageReader reader(response.get());
-  std::string value;
-  ASSERT_TRUE(reader.PopVariantOfString(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithPath) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface3, kPathPropName);
-  dbus::MessageReader reader(response.get());
-  dbus::ObjectPath value;
-  ASSERT_TRUE(reader.PopVariantOfObjectPath(&value));
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithStringList) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface3, kStringListPropName);
-  dbus::MessageReader reader(response.get());
-  dbus::MessageReader variant_reader(nullptr);
-  std::vector<std::string> value;
-  ASSERT_TRUE(reader.PopVariant(&variant_reader));
-  ASSERT_TRUE(variant_reader.PopArrayOfStrings(&value));
-  ASSERT_FALSE(variant_reader.HasMoreData());
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithPathList) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface3, kPathListPropName);
-  dbus::MessageReader reader(response.get());
-  dbus::MessageReader variant_reader(nullptr);
-  std::vector<dbus::ObjectPath> value;
-  ASSERT_TRUE(reader.PopVariant(&variant_reader));
-  ASSERT_TRUE(variant_reader.PopArrayOfObjectPaths(&value));
-  ASSERT_FALSE(variant_reader.HasMoreData());
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, GetWorksWithUint8List) {
-  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
-      kTestInterface3, kPathListPropName);
-  dbus::MessageReader reader(response.get());
-  dbus::MessageReader variant_reader(nullptr);
-  const uint8* buffer;
-  size_t buffer_len;
-  ASSERT_TRUE(reader.PopVariant(&variant_reader));
-  // |buffer| remains under the control of the MessageReader.
-  ASSERT_TRUE(variant_reader.PopArrayOfBytes(&buffer, &buffer_len));
-  ASSERT_FALSE(variant_reader.HasMoreData());
-  ASSERT_FALSE(reader.HasMoreData());
-}
-
-TEST_F(ExportedPropertySetTest, SetFailsGracefully) {
-  dbus::MethodCall method_call(dbus::kPropertiesInterface,
-                               dbus::kPropertiesSet);
-  method_call.SetSerial(123);
-  auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
-                                    base::Unretained(this));
-  p_->CallHandleSet(&method_call, response_sender);
-  ASSERT_TRUE(
-      dynamic_cast<dbus::ErrorResponse*>(last_response_.get()) != nullptr);
-}
-
-namespace {
-
-void VerifySignal(dbus::Signal* signal) {
-  ASSERT_NE(signal, nullptr);
-  std::string interface_name;
-  std::string property_name;
-  uint8 value;
-  dbus::MessageReader reader(signal);
-  dbus::MessageReader array_reader(signal);
-  dbus::MessageReader dict_reader(signal);
-  ASSERT_TRUE(reader.PopString(&interface_name));
-  ASSERT_TRUE(reader.PopArray(&array_reader));
-  ASSERT_TRUE(array_reader.PopDictEntry(&dict_reader));
-  ASSERT_TRUE(dict_reader.PopString(&property_name));
-  ASSERT_TRUE(dict_reader.PopVariantOfByte(&value));
-  ASSERT_FALSE(dict_reader.HasMoreData());
-  ASSERT_FALSE(array_reader.HasMoreData());
-  ASSERT_TRUE(reader.HasMoreData());
-  // Read the (empty) list of invalidated property names.
-  ASSERT_TRUE(reader.PopArray(&array_reader));
-  ASSERT_FALSE(array_reader.HasMoreData());
-  ASSERT_FALSE(reader.HasMoreData());
-  ASSERT_EQ(value, 57);
-  ASSERT_EQ(property_name, std::string(kUint8PropName));
-  ASSERT_EQ(interface_name, std::string(kTestInterface1));
-}
-
-}  // namespace
-
-TEST_F(ExportedPropertySetTest, SignalsAreParsable) {
-  EXPECT_CALL(*mock_exported_object_, SendSignal(_))
-      .Times(1).WillOnce(Invoke(&VerifySignal));
-  p_->uint8_prop_.SetValue(57);
-}
-
-}  // namespace dbus_utils
-
-}  // namespace buffet
diff --git a/buffet/manager.cc b/buffet/manager.cc
index 0a6af31..39ccf7d 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -11,6 +11,7 @@
 #include <base/bind_helpers.h>
 #include <base/json/json_writer.h>
 #include <chromeos/async_event_sequencer.h>
+#include <chromeos/dbus_utils.h>
 #include <dbus/bus.h>
 #include <dbus/object_path.h>
 #include <dbus/values_util.h>
@@ -22,7 +23,7 @@
 #include "buffet/exported_object_manager.h"
 
 using chromeos::dbus_utils::AsyncEventSequencer;
-using buffet::dbus_utils::GetBadArgsError;
+using chromeos::dbus_utils::GetBadArgsError;
 using buffet::dbus_utils::GetDBusError;
 
 namespace buffet {
diff --git a/buffet/manager.h b/buffet/manager.h
index 6f2f8a6..08e7656 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -12,12 +12,13 @@
 #include <base/memory/scoped_ptr.h>
 #include <base/memory/weak_ptr.h>
 #include <base/values.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"
-#include "buffet/exported_property_set.h"
 
 namespace buffet {
 
@@ -40,11 +41,11 @@
   void Init(const OnInitFinish& cb);
 
  private:
-  struct Properties: public dbus_utils::ExportedPropertySet {
+  struct Properties: public chromeos::dbus_utils::ExportedPropertySet {
    public:
-    dbus_utils::ExportedProperty<std::string> state_;
+    chromeos::dbus_utils::ExportedProperty<std::string> state_;
     explicit Properties(dbus::Bus* bus)
-        : dbus_utils::ExportedPropertySet(
+        : chromeos::dbus_utils::ExportedPropertySet(
               bus, dbus::ObjectPath(dbus_constants::kManagerServicePath)) {
       RegisterProperty(dbus_constants::kManagerInterface, "State", &state_);
     }