diff --git a/buffet/buffet.gyp b/buffet/buffet.gyp
index 7b92439..1716756 100644
--- a/buffet/buffet.gyp
+++ b/buffet/buffet.gyp
@@ -46,6 +46,7 @@
         '../libweave/src/commands/schema_constants.cc',
         '../libweave/src/commands/schema_utils.cc',
         '../libweave/src/commands/user_role.cc',
+        '../libweave/src/device_manager.cc',
         '../libweave/src/device_registration_info.cc',
         '../libweave/src/notification/notification_parser.cc',
         '../libweave/src/notification/pull_channel.cc',
diff --git a/buffet/main.cc b/buffet/main.cc
index 3a76046..510dd04 100644
--- a/buffet/main.cc
+++ b/buffet/main.cc
@@ -24,7 +24,7 @@
 
 class Daemon final : public DBusServiceDaemon {
  public:
-  explicit Daemon(const buffet::Manager::Options& options)
+  explicit Daemon(const weave::Device::Options& options)
       : DBusServiceDaemon(kServiceName, kRootServicePath), options_{options} {}
 
  protected:
@@ -36,7 +36,7 @@
   void OnShutdown(int* return_code) override { manager_->Stop(); }
 
  private:
-  buffet::Manager::Options options_;
+  weave::Device::Options options_;
   std::unique_ptr<buffet::Manager> manager_;
   DISALLOW_COPY_AND_ASSIGN(Daemon);
 };
@@ -80,17 +80,17 @@
   auto device_whitelist =
       chromeos::string_utils::Split(FLAGS_device_whitelist, ",", true, true);
 
-  buffet::Manager::Options options;
+  weave::Device::Options options;
   options.config_path = base::FilePath{FLAGS_config_path};
   options.state_path = base::FilePath{FLAGS_state_path};
+  options.definitions_path = base::FilePath{"/etc/buffet"};
   options.test_definitions_path = base::FilePath{FLAGS_test_definitions_path};
   options.xmpp_enabled = FLAGS_enable_xmpp;
   options.device_whitelist.insert(device_whitelist.begin(),
                                   device_whitelist.end());
-  options.privet.config_path = base::FilePath{FLAGS_config_path};
-  options.privet.disable_privet = FLAGS_disable_privet;
-  options.privet.disable_security = FLAGS_disable_security;
-  options.privet.enable_ping = FLAGS_enable_ping;
+  options.disable_privet = FLAGS_disable_privet;
+  options.disable_security = FLAGS_disable_security;
+  options.enable_ping = FLAGS_enable_ping;
 
   buffet::Daemon daemon{options};
   return daemon.Run();
diff --git a/buffet/manager.cc b/buffet/manager.cc
index f7ecc0e..3ba5f5f 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -23,34 +23,35 @@
 #include <dbus/object_path.h>
 #include <dbus/values_util.h>
 
-#include "libweave/src/base_api_handler.h"
-#include "libweave/src/commands/command_instance.h"
-#include "libweave/src/commands/schema_constants.h"
-#include "libweave/src/privet/constants.h"
-#include "libweave/src/privet/security_manager.h"
-#include "libweave/src/privet/shill_client.h"
-#include "libweave/src/privet/wifi_bootstrap_manager.h"
-#include "libweave/src/states/state_change_queue.h"
-#include "libweave/src/states/state_manager.h"
-#include "libweave/src/storage_impls.h"
-
 using chromeos::dbus_utils::AsyncEventSequencer;
 using chromeos::dbus_utils::ExportedObjectManager;
-namespace privet = weave::privet;
 
 namespace buffet {
 
 namespace {
 
-// Max of 100 state update events should be enough in the queue.
-const size_t kMaxStateChangeQueueSize = 100;
-// The number of seconds each HTTP request will be allowed before timing out.
-const int kRequestTimeoutSeconds = 30;
-
 const char kPairingSessionIdKey[] = "sessionId";
 const char kPairingModeKey[] = "mode";
 const char kPairingCodeKey[] = "code";
 
+const char kErrorDomain[] = "buffet";
+const char kNotImplemented[] = "notImplemented";
+
+std::string StatusToString(weave::RegistrationStatus status) {
+  switch (status) {
+    case weave::RegistrationStatus::kUnconfigured:
+      return "unconfigured";
+    case weave::RegistrationStatus::kConnecting:
+      return "connecting";
+    case weave::RegistrationStatus::kConnected:
+      return "connected";
+    case weave::RegistrationStatus::kInvalidCredentials:
+      return "invalid_credentials";
+  }
+  CHECK(0) << "Unknown status";
+  return "unknown";
+}
+
 }  // anonymous namespace
 
 Manager::Manager(const base::WeakPtr<ExportedObjectManager>& object_manager)
@@ -62,108 +63,57 @@
 Manager::~Manager() {
 }
 
-void Manager::Start(const Options& options, AsyncEventSequencer* sequencer) {
-  command_manager_ =
-      std::make_shared<weave::CommandManager>(dbus_object_.GetObjectManager());
-  command_manager_->AddOnCommandDefChanged(base::Bind(
+void Manager::Start(const weave::Device::Options& options,
+                    AsyncEventSequencer* sequencer) {
+  device_ = weave::Device::Create();
+  device_->Start(options, &dbus_object_, sequencer);
+
+  device_->GetCommands()->AddOnCommandDefChanged(base::Bind(
       &Manager::OnCommandDefsChanged, weak_ptr_factory_.GetWeakPtr()));
-  command_manager_->Startup(base::FilePath{"/etc/buffet"},
-                            options.test_definitions_path);
-  state_change_queue_.reset(
-      new weave::StateChangeQueue(kMaxStateChangeQueueSize));
-  state_manager_ =
-      std::make_shared<weave::StateManager>(state_change_queue_.get());
-  state_manager_->AddOnChangedCallback(
+
+  device_->GetState()->AddOnChangedCallback(
       base::Bind(&Manager::OnStateChanged, weak_ptr_factory_.GetWeakPtr()));
-  state_manager_->Startup();
 
-  std::unique_ptr<weave::BuffetConfig> config{
-      new weave::BuffetConfig{options.state_path}};
-  config->AddOnChangedCallback(
+  device_->GetConfig()->AddOnChangedCallback(
       base::Bind(&Manager::OnConfigChanged, weak_ptr_factory_.GetWeakPtr()));
-  config->Load(options.config_path);
 
-  auto transport = chromeos::http::Transport::CreateDefault();
-  transport->SetDefaultTimeout(base::TimeDelta::FromSeconds(
-      kRequestTimeoutSeconds));
-
-  shill_client_.reset(new weave::privet::ShillClient(dbus_object_.GetBus(),
-                                                     options.device_whitelist));
-
-  // TODO(avakulenko): Figure out security implications of storing
-  // device info state data unencrypted.
-  device_info_.reset(new weave::DeviceRegistrationInfo(
-      command_manager_, state_manager_, std::move(config), transport,
-      base::MessageLoop::current()->task_runner(), options.xmpp_enabled,
-      shill_client_.get()));
-  device_info_->AddOnRegistrationChangedCallback(base::Bind(
+  device_->GetCloud()->AddOnRegistrationChangedCallback(base::Bind(
       &Manager::OnRegistrationChanged, weak_ptr_factory_.GetWeakPtr()));
 
-  base_api_handler_.reset(new weave::BaseApiHandler{
-      device_info_->AsWeakPtr(), state_manager_, command_manager_});
+  device_->GetPrivet()->AddOnWifiSetupChangedCallback(base::Bind(
+      &Manager::UpdateWiFiBootstrapState, weak_ptr_factory_.GetWeakPtr()));
 
-  device_info_->Start();
+  device_->GetPrivet()->AddOnPairingChangedCallbacks(
+      base::Bind(&Manager::OnPairingStart, weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&Manager::OnPairingEnd, weak_ptr_factory_.GetWeakPtr()));
 
   dbus_adaptor_.RegisterWithDBusObject(&dbus_object_);
   dbus_object_.RegisterAsync(
       sequencer->GetHandler("Manager.RegisterAsync() failed.", true));
-
-  if (!options.privet.disable_privet)
-    StartPrivet(options.privet, sequencer);
-}
-
-void Manager::StartPrivet(const weave::privet::Manager::Options& options,
-                          AsyncEventSequencer* sequencer) {
-  privet_.reset(new weave::privet::Manager{});
-  privet_->Start(options, dbus_object_.GetBus(), shill_client_.get(),
-                 device_info_.get(), command_manager_.get(),
-                 state_manager_.get(), sequencer);
-
-  if (privet_->GetWifiBootstrapManager()) {
-    privet_->GetWifiBootstrapManager()->RegisterStateListener(base::Bind(
-        &Manager::UpdateWiFiBootstrapState, weak_ptr_factory_.GetWeakPtr()));
-  } else {
-    UpdateWiFiBootstrapState(weave::privet::WifiBootstrapManager::kDisabled);
-  }
-
-  privet_->GetSecurityManager()->RegisterPairingListeners(
-      base::Bind(&Manager::OnPairingStart, weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&Manager::OnPairingEnd, weak_ptr_factory_.GetWeakPtr()));
-  // TODO(wiley) Watch for appropriate state variables from |cloud_delegate|.
 }
 
 void Manager::Stop() {
-  if (privet_)
-    privet_->OnShutdown();
+  device_.reset();
 }
 
+// TODO(vitalybuka): Remove, it's just duplicate of property.
 void Manager::CheckDeviceRegistered(
     DBusMethodResponsePtr<std::string> response) {
   LOG(INFO) << "Received call to Manager.CheckDeviceRegistered()";
-  chromeos::ErrorPtr error;
-  bool registered = device_info_->VerifyRegistrationCredentials(&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(weave::kErrorDomainGCD, "device_not_registered")) {
-    response->ReplyWithError(error.get());
-    return;
-  }
-
-  response->Return(registered ? device_info_->GetConfig().device_id()
-                              : std::string());
+  response->Return(dbus_adaptor_.GetDeviceId());
 }
 
+// TODO(vitalybuka): Remove or rename to leave for testing.
 void Manager::GetDeviceInfo(DBusMethodResponsePtr<std::string> response) {
   LOG(INFO) << "Received call to Manager.GetDeviceInfo()";
   std::shared_ptr<DBusMethodResponse<std::string>> shared_response =
       std::move(response);
 
-  device_info_->GetDeviceInfo(
+  device_->GetCloud()->GetDeviceInfo(
       base::Bind(&Manager::OnGetDeviceInfoSuccess,
                  weak_ptr_factory_.GetWeakPtr(), shared_response),
-      base::Bind(&Manager::OnGetDeviceInfoError,
-                 weak_ptr_factory_.GetWeakPtr(), shared_response));
+      base::Bind(&Manager::OnGetDeviceInfoError, weak_ptr_factory_.GetWeakPtr(),
+                 shared_response));
 }
 
 void Manager::OnGetDeviceInfoSuccess(
@@ -186,32 +136,27 @@
   LOG(INFO) << "Received call to Manager.RegisterDevice()";
 
   chromeos::ErrorPtr error;
-  std::string device_id = device_info_->RegisterDevice(ticket_id, &error);
+  std::string device_id =
+      device_->GetCloud()->RegisterDevice(ticket_id, &error);
   if (!device_id.empty()) {
     response->Return(device_id);
     return;
   }
-  if (!error) {
-    // TODO(zeuthen): This can be changed to CHECK(error) once
-    // RegisterDevice() has been fixed to set |error| when failing.
-    chromeos::Error::AddTo(&error, FROM_HERE, weave::kErrorDomainGCD,
-                           "internal_error",
-                           "device_id empty but error not set");
-  }
+  CHECK(error);
   response->ReplyWithError(error.get());
 }
 
 void Manager::UpdateState(DBusMethodResponsePtr<> response,
                           const chromeos::VariantDictionary& property_set) {
   chromeos::ErrorPtr error;
-  if (!state_manager_->SetProperties(property_set, &error))
+  if (!device_->GetState()->SetProperties(property_set, &error))
     response->ReplyWithError(error.get());
   else
     response->Return();
 }
 
 bool Manager::GetState(chromeos::ErrorPtr* error, std::string* state) {
-  auto json = state_manager_->GetStateValuesAsJson(error);
+  auto json = device_->GetState()->GetStateValuesAsJson(error);
   if (!json)
     return false;
   base::JSONWriter::WriteWithOptions(
@@ -240,7 +185,7 @@
     return response->ReplyWithError(error.get());
 
   std::string id;
-  if (!command_manager_->AddCommand(*command, role, &id, &error))
+  if (!device_->GetCommands()->AddCommand(*command, role, &id, &error))
     return response->ReplyWithError(error.get());
 
   response->Return(id);
@@ -248,10 +193,10 @@
 
 void Manager::GetCommand(DBusMethodResponsePtr<std::string> response,
                          const std::string& id) {
-  const weave::CommandInstance* command = command_manager_->FindCommand(id);
+  const weave::CommandInstance* command =
+      device_->GetCommands()->FindCommand(id);
   if (!command) {
-    response->ReplyWithError(FROM_HERE, weave::kErrorDomainGCD,
-                             "unknown_command",
+    response->ReplyWithError(FROM_HERE, kErrorDomain, "unknown_command",
                              "Can't find command with id: " + id);
     return;
   }
@@ -270,7 +215,8 @@
     response->ReplyWithError(error.get());
     return;
   }
-  if (!command_manager_->SetCommandVisibility(in_names, visibility, &error)) {
+  if (!device_->GetCommands()->SetCommandVisibility(in_names, visibility,
+                                                    &error)) {
     response->ReplyWithError(error.get());
     return;
   }
@@ -286,15 +232,13 @@
     chromeos::ErrorPtr* error,
     const dbus::ObjectPath& in_listener_path,
     const chromeos::VariantDictionary& in_options) {
-  chromeos::Error::AddTo(error, FROM_HERE, weave::privet::errors::kDomain,
-                         weave::privet::errors::kNotImplemented,
+  chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain, kNotImplemented,
                          "Manual WiFi bootstrapping is not implemented");
   return false;
 }
 
 bool Manager::DisableWiFiBootstrapping(chromeos::ErrorPtr* error) {
-  chromeos::Error::AddTo(error, FROM_HERE, weave::privet::errors::kDomain,
-                         weave::privet::errors::kNotImplemented,
+  chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain, kNotImplemented,
                          "Manual WiFi bootstrapping is not implemented");
   return false;
 }
@@ -303,25 +247,23 @@
     chromeos::ErrorPtr* error,
     const dbus::ObjectPath& in_listener_path,
     const chromeos::VariantDictionary& in_options) {
-  chromeos::Error::AddTo(error, FROM_HERE, weave::privet::errors::kDomain,
-                         weave::privet::errors::kNotImplemented,
+  chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain, kNotImplemented,
                          "Manual GCD bootstrapping is not implemented");
   return false;
 }
 
 bool Manager::DisableGCDBootstrapping(chromeos::ErrorPtr* error) {
-  chromeos::Error::AddTo(error, FROM_HERE, weave::privet::errors::kDomain,
-                         weave::privet::errors::kNotImplemented,
+  chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain, kNotImplemented,
                          "Manual GCD bootstrapping is not implemented");
   return false;
 }
 
 bool Manager::UpdateDeviceInfo(chromeos::ErrorPtr* error,
-                               const std::string& in_name,
-                               const std::string& in_description,
-                               const std::string& in_location) {
-  return device_info_->UpdateDeviceInfo(in_name, in_description, in_location,
-                                        error);
+                               const std::string& name,
+                               const std::string& description,
+                               const std::string& location) {
+  return device_->GetCloud()->UpdateDeviceInfo(name, description, location,
+                                               error);
 }
 
 bool Manager::UpdateServiceConfig(chromeos::ErrorPtr* error,
@@ -330,17 +272,18 @@
                                   const std::string& api_key,
                                   const std::string& oauth_url,
                                   const std::string& service_url) {
-  return device_info_->UpdateServiceConfig(client_id, client_secret, api_key,
-                                           oauth_url, service_url, error);
+  return device_->GetCloud()->UpdateServiceConfig(
+      client_id, client_secret, api_key, oauth_url, service_url, error);
 }
 
 void Manager::OnCommandDefsChanged() {
   // Limit only to commands that are visible to the local clients.
-  auto commands = command_manager_->GetCommandDictionary().GetCommandsAsJson(
-      [](const weave::CommandDefinition* def) {
-        return def->GetVisibility().local;
-      },
-      true, nullptr);
+  auto commands =
+      device_->GetCommands()->GetCommandDictionary().GetCommandsAsJson(
+          [](const weave::CommandDefinition* def) {
+            return def->GetVisibility().local;
+          },
+          true, nullptr);
   CHECK(commands);
   std::string json;
   base::JSONWriter::WriteWithOptions(
@@ -349,7 +292,7 @@
 }
 
 void Manager::OnStateChanged() {
-  auto state = state_manager_->GetStateValuesAsJson(nullptr);
+  auto state = device_->GetState()->GetStateValuesAsJson(nullptr);
   CHECK(state);
   std::string json;
   base::JSONWriter::WriteWithOptions(
@@ -374,38 +317,30 @@
 
 void Manager::UpdateWiFiBootstrapState(
     weave::privet::WifiBootstrapManager::State state) {
-  if (auto wifi = privet_->GetWifiBootstrapManager()) {
-    const std::string& ssid{wifi->GetCurrentlyConnectedSsid()};
-    if (ssid != device_info_->GetConfig().last_configured_ssid()) {
-      weave::BuffetConfig::Transaction change{device_info_->GetMutableConfig()};
-      change.set_last_configured_ssid(ssid);
-    }
-  }
-
   switch (state) {
-    case weave::privet::WifiBootstrapManager::kDisabled:
+    case weave::WifiSetupState::kDisabled:
       dbus_adaptor_.SetWiFiBootstrapState("disabled");
       break;
-    case weave::privet::WifiBootstrapManager::kBootstrapping:
+    case weave::WifiSetupState::kBootstrapping:
       dbus_adaptor_.SetWiFiBootstrapState("waiting");
       break;
-    case weave::privet::WifiBootstrapManager::kMonitoring:
+    case weave::WifiSetupState::kMonitoring:
       dbus_adaptor_.SetWiFiBootstrapState("monitoring");
       break;
-    case weave::privet::WifiBootstrapManager::kConnecting:
+    case weave::WifiSetupState::kConnecting:
       dbus_adaptor_.SetWiFiBootstrapState("connecting");
       break;
   }
 }
 
 void Manager::OnPairingStart(const std::string& session_id,
-                             privet::PairingType pairing_type,
+                             weave::PairingType pairing_type,
                              const std::vector<uint8_t>& code) {
   // For now, just overwrite the exposed PairInfo with
   // the most recent pairing attempt.
   dbus_adaptor_.SetPairingInfo(chromeos::VariantDictionary{
       {kPairingSessionIdKey, session_id},
-      {kPairingModeKey, PairingTypeToString(pairing_type)},
+      {kPairingModeKey, weave::privet::PairingTypeToString(pairing_type)},
       {kPairingCodeKey, code},
   });
 }
diff --git a/buffet/manager.h b/buffet/manager.h
index 4f73a3c..af01a80 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -20,10 +20,7 @@
 #include <chromeos/errors/error.h>
 
 #include "buffet/org.chromium.Buffet.Manager.h"
-#include "libweave/src/commands/command_manager.h"
-#include "libweave/src/device_registration_info.h"
-#include "libweave/src/privet/privet_manager.h"
-#include "libweave/src/privet/wifi_bootstrap_manager.h"
+#include "weave/device.h"
 
 namespace chromeos {
 namespace dbus_utils {
@@ -31,13 +28,6 @@
 }  // namespace dbus_utils
 }  // namespace chromeos
 
-namespace weave {
-class BaseApiHandler;
-class BuffetConfig;
-class StateChangeQueue;
-class StateManager;
-}  // namespace weave
-
 namespace buffet {
 
 template<typename... Types>
@@ -58,16 +48,7 @@
           object_manager);
   ~Manager();
 
-  struct Options {
-    base::FilePath config_path;
-    base::FilePath state_path;
-    base::FilePath test_definitions_path;
-    bool xmpp_enabled{true};
-    std::set<std::string> device_whitelist;
-    weave::privet::Manager::Options privet;
-  };
-
-  void Start(const Options& options,
+  void Start(const weave::Device::Options& options,
              chromeos::dbus_utils::AsyncEventSequencer* sequencer);
 
   void Stop();
@@ -80,9 +61,9 @@
   void RegisterDevice(DBusMethodResponsePtr<std::string> response,
                       const std::string& ticket_id) override;
   bool UpdateDeviceInfo(chromeos::ErrorPtr* error,
-                        const std::string& in_name,
-                        const std::string& in_description,
-                        const std::string& in_location) override;
+                        const std::string& name,
+                        const std::string& description,
+                        const std::string& location) override;
   bool UpdateServiceConfig(chromeos::ErrorPtr* error,
                            const std::string& client_id,
                            const std::string& client_secret,
@@ -119,30 +100,23 @@
       const std::shared_ptr<DBusMethodResponse<std::string>>& response,
       const chromeos::Error* error);
 
-  void StartPrivet(const weave::privet::Manager::Options& options,
+  void StartPrivet(const weave::Device::Options& options,
                    chromeos::dbus_utils::AsyncEventSequencer* sequencer);
 
   void OnCommandDefsChanged();
   void OnStateChanged();
   void OnRegistrationChanged(weave::RegistrationStatus status);
   void OnConfigChanged(const weave::BuffetConfig& config);
-  void UpdateWiFiBootstrapState(
-      weave::privet::WifiBootstrapManager::State state);
+  void UpdateWiFiBootstrapState(weave::WifiSetupState state);
   void OnPairingStart(const std::string& session_id,
-                      weave::privet::PairingType pairing_type,
+                      weave::PairingType pairing_type,
                       const std::vector<uint8_t>& code);
   void OnPairingEnd(const std::string& session_id);
 
   org::chromium::Buffet::ManagerAdaptor dbus_adaptor_{this};
   chromeos::dbus_utils::DBusObject dbus_object_;
 
-  std::shared_ptr<weave::CommandManager> command_manager_;
-  std::unique_ptr<weave::StateChangeQueue> state_change_queue_;
-  std::shared_ptr<weave::StateManager> state_manager_;
-  std::unique_ptr<weave::DeviceRegistrationInfo> device_info_;
-  std::unique_ptr<weave::BaseApiHandler> base_api_handler_;
-  std::unique_ptr<weave::privet::ShillClient> shill_client_;
-  std::unique_ptr<weave::privet::Manager> privet_;
+  std::unique_ptr<weave::Device> device_;
 
   base::WeakPtrFactory<Manager> weak_ptr_factory_{this};
   DISALLOW_COPY_AND_ASSIGN(Manager);
diff --git a/libweave/include/weave/device.h b/libweave/include/weave/device.h
new file mode 100644
index 0000000..5a49409
--- /dev/null
+++ b/libweave/include/weave/device.h
@@ -0,0 +1,80 @@
+// 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 LIBWEAVE_INCLUDE_WEAVE_DEVICE_H_
+#define LIBWEAVE_INCLUDE_WEAVE_DEVICE_H_
+
+#include <memory>
+#include <set>
+#include <string>
+
+#include <base/files/file_path.h>
+#include <chromeos/errors/error.h>
+#include <chromeos/variant_dictionary.h>
+
+#include "weave/types.h"
+
+namespace chromeos {
+namespace dbus_utils {
+class AsyncEventSequencer;
+class DBusObject;
+}
+}
+
+namespace weave {
+
+class CommandManager;
+class StateManager;
+class BuffetConfig;
+class DeviceRegistrationInfo;
+namespace privet {
+class Manager;
+}
+
+// TODO(vitalybuka): Replace with interfaces.
+using Commands = CommandManager;
+using State = StateManager;
+using Config = BuffetConfig;
+using Cloud = DeviceRegistrationInfo;
+using Privet = privet::Manager;
+
+class Device {
+ public:
+  struct Options {
+    base::FilePath config_path;
+    base::FilePath state_path;
+    base::FilePath definitions_path;
+    base::FilePath test_definitions_path;
+    bool xmpp_enabled{true};
+    std::set<std::string> device_whitelist;
+    bool disable_privet{false};
+    bool disable_security{false};
+    bool enable_ping{false};
+  };
+
+  virtual ~Device() = default;
+
+  virtual void Start(const Options& options,
+                     chromeos::dbus_utils::DBusObject* dbus_object,
+                     chromeos::dbus_utils::AsyncEventSequencer* sequencer) = 0;
+
+  virtual Commands* GetCommands() = 0;
+  virtual State* GetState() = 0;
+  virtual Config* GetConfig() = 0;
+  virtual Cloud* GetCloud() = 0;
+  virtual Privet* GetPrivet() = 0;
+
+  static std::unique_ptr<Device> Create();
+};
+
+}  // namespace weave
+
+// TODO(vitalybuka): Replace with interfaces
+#include "libweave/src/buffet_config.h"
+#include "libweave/src/commands/command_manager.h"
+#include "libweave/src/device_registration_info.h"
+#include "libweave/src/privet/privet_manager.h"
+#include "libweave/src/states/state_manager.h"
+
+#endif  // LIBWEAVE_INCLUDE_WEAVE_DEVICE_H_
diff --git a/libweave/include/weave/types.h b/libweave/include/weave/types.h
new file mode 100644
index 0000000..55a1fb0
--- /dev/null
+++ b/libweave/include/weave/types.h
@@ -0,0 +1,36 @@
+// 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 LIBWEAVE_INCLUDE_WEAVE_TYPES_H_
+#define LIBWEAVE_INCLUDE_WEAVE_TYPES_H_
+
+#include <string>
+
+namespace weave {
+
+// See the DBus interface XML file for complete descriptions of these states.
+enum class RegistrationStatus {
+  kUnconfigured,        // We have no credentials.
+  kConnecting,          // We have credentials but not yet connected.
+  kConnected,           // We're registered and connected to the cloud.
+  kInvalidCredentials,  // Our registration has been revoked.
+};
+
+enum class PairingType {
+  kPinCode,
+  kEmbeddedCode,
+  kUltrasound32,
+  kAudible32,
+};
+
+enum class WifiSetupState {
+  kDisabled,
+  kBootstrapping,
+  kMonitoring,
+  kConnecting,
+};
+
+}  // namespace weave
+
+#endif  // LIBWEAVE_INCLUDE_WEAVE_TYPES_H_
diff --git a/libweave/src/buffet_config.cc b/libweave/src/buffet_config.cc
index 2d4aa58..2b62c27 100644
--- a/libweave/src/buffet_config.cc
+++ b/libweave/src/buffet_config.cc
@@ -150,15 +150,15 @@
   if (store.GetString(config_keys::kEmbeddedCodePath, &embedded_code_path)) {
     embedded_code_path_ = base::FilePath(embedded_code_path);
     if (!embedded_code_path_.empty())
-      pairing_modes_ = {privet::PairingType::kEmbeddedCode};
+      pairing_modes_ = {PairingType::kEmbeddedCode};
   }
 
   std::string modes_str;
   if (store.GetString(config_keys::kPairingModes, &modes_str)) {
-    std::set<privet::PairingType> pairing_modes;
+    std::set<PairingType> pairing_modes;
     for (const std::string& mode :
          chromeos::string_utils::Split(modes_str, ",", true, true)) {
-      privet::PairingType pairing_mode;
+      PairingType pairing_mode;
       CHECK(privet::StringToPairingType(mode, &pairing_mode));
       pairing_modes.insert(pairing_mode);
     }
diff --git a/libweave/src/buffet_config.h b/libweave/src/buffet_config.h
index d08a1b8..d384b89 100644
--- a/libweave/src/buffet_config.h
+++ b/libweave/src/buffet_config.h
@@ -108,9 +108,7 @@
   }
 
   bool wifi_auto_setup_enabled() const { return wifi_auto_setup_enabled_; }
-  const std::set<privet::PairingType>& pairing_modes() const {
-    return pairing_modes_;
-  }
+  const std::set<PairingType>& pairing_modes() const { return pairing_modes_; }
   const base::FilePath& embedded_code_path() const {
     return embedded_code_path_;
   }
@@ -153,7 +151,7 @@
   base::TimeDelta backup_polling_period_{base::TimeDelta::FromMinutes(30)};
 
   bool wifi_auto_setup_enabled_{true};
-  std::set<privet::PairingType> pairing_modes_{privet::PairingType::kPinCode};
+  std::set<PairingType> pairing_modes_{PairingType::kPinCode};
   base::FilePath embedded_code_path_;
 
   std::string device_id_;
diff --git a/libweave/src/buffet_config_unittest.cc b/libweave/src/buffet_config_unittest.cc
index bd46403..a286c34 100644
--- a/libweave/src/buffet_config_unittest.cc
+++ b/libweave/src/buffet_config_unittest.cc
@@ -58,7 +58,7 @@
   EXPECT_EQ(base::TimeDelta::FromSeconds(7), config_->polling_period());
   EXPECT_EQ(base::TimeDelta::FromMinutes(30), config_->backup_polling_period());
   EXPECT_TRUE(config_->wifi_auto_setup_enabled());
-  EXPECT_EQ(std::set<privet::PairingType>{privet::PairingType::kPinCode},
+  EXPECT_EQ(std::set<PairingType>{PairingType::kPinCode},
             config_->pairing_modes());
   EXPECT_EQ("", config_->embedded_code_path().value());
   EXPECT_EQ("Developer device", config_->name());
@@ -120,9 +120,9 @@
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(6589),
             config_->backup_polling_period());
   EXPECT_FALSE(config_->wifi_auto_setup_enabled());
-  std::set<privet::PairingType> pairing_types{
-      privet::PairingType::kPinCode, privet::PairingType::kEmbeddedCode,
-      privet::PairingType::kUltrasound32, privet::PairingType::kAudible32};
+  std::set<PairingType> pairing_types{
+      PairingType::kPinCode, PairingType::kEmbeddedCode,
+      PairingType::kUltrasound32, PairingType::kAudible32};
   EXPECT_EQ(pairing_types, config_->pairing_modes());
   EXPECT_EQ("/conf_code", config_->embedded_code_path().value());
   EXPECT_EQ("conf_name", config_->name());
diff --git a/libweave/src/device_manager.cc b/libweave/src/device_manager.cc
new file mode 100644
index 0000000..7d2943b
--- /dev/null
+++ b/libweave/src/device_manager.cc
@@ -0,0 +1,119 @@
+// 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.
+
+#include "libweave/src/device_manager.h"
+
+#include <string>
+
+#include <chromeos/dbus/dbus_object.h>
+
+#include <base/message_loop/message_loop.h>
+
+#include "libweave/src/base_api_handler.h"
+#include "libweave/src/commands/command_manager.h"
+#include "libweave/src/privet/privet_manager.h"
+#include "libweave/src/privet/shill_client.h"
+#include "libweave/src/states/state_change_queue.h"
+#include "libweave/src/states/state_manager.h"
+
+namespace weave {
+
+namespace {
+
+// Max of 100 state update events should be enough in the queue.
+const size_t kMaxStateChangeQueueSize = 100;
+// The number of seconds each HTTP request will be allowed before timing out.
+const int kRequestTimeoutSeconds = 30;
+
+}  // namespace
+
+DeviceManager::DeviceManager() {}
+
+DeviceManager::~DeviceManager() {}
+
+void DeviceManager::Start(
+    const Options& options,
+    chromeos::dbus_utils::DBusObject* dbus_object,
+    chromeos::dbus_utils::AsyncEventSequencer* sequencer) {
+  command_manager_ =
+      std::make_shared<CommandManager>(dbus_object->GetObjectManager());
+  command_manager_->Startup(options.definitions_path,
+                            options.test_definitions_path);
+  state_change_queue_.reset(new StateChangeQueue(kMaxStateChangeQueueSize));
+  state_manager_ = std::make_shared<StateManager>(state_change_queue_.get());
+  state_manager_->Startup();
+
+  auto transport = chromeos::http::Transport::CreateDefault();
+  transport->SetDefaultTimeout(
+      base::TimeDelta::FromSeconds(kRequestTimeoutSeconds));
+
+  std::unique_ptr<BuffetConfig> config{new BuffetConfig{options.state_path}};
+  config->Load(options.config_path);
+
+  shill_client_.reset(
+      new privet::ShillClient(dbus_object->GetBus(), options.device_whitelist));
+
+  // TODO(avakulenko): Figure out security implications of storing
+  // device info state data unencrypted.
+  device_info_.reset(new DeviceRegistrationInfo(
+      command_manager_, state_manager_, std::move(config), transport,
+      base::MessageLoop::current()->task_runner(), options.xmpp_enabled,
+      shill_client_.get()));
+  base_api_handler_.reset(new BaseApiHandler{device_info_->AsWeakPtr(),
+                                             state_manager_, command_manager_});
+
+  device_info_->Start();
+
+  if (!options.disable_privet)
+    StartPrivet(options, dbus_object, sequencer);
+}
+
+CommandManager* DeviceManager::GetCommands() {
+  return command_manager_.get();
+}
+
+StateManager* DeviceManager::GetState() {
+  return state_manager_.get();
+}
+
+BuffetConfig* DeviceManager::GetConfig() {
+  return device_info_->GetMutableConfig();
+}
+
+DeviceRegistrationInfo* DeviceManager::GetCloud() {
+  return device_info_.get();
+}
+
+privet::Manager* DeviceManager::GetPrivet() {
+  return privet_.get();
+}
+
+void DeviceManager::StartPrivet(
+    const Options& options,
+    chromeos::dbus_utils::DBusObject* dbus_object,
+    chromeos::dbus_utils::AsyncEventSequencer* sequencer) {
+  privet_.reset(new privet::Manager{});
+  privet_->Start(options, dbus_object->GetBus(), shill_client_.get(),
+                 device_info_.get(), command_manager_.get(),
+                 state_manager_.get(), sequencer);
+
+  privet_->AddOnWifiSetupChangedCallback(
+      base::Bind(&DeviceManager::OnWiFiBootstrapStateChanged,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void DeviceManager::OnWiFiBootstrapStateChanged(
+    weave::privet::WifiBootstrapManager::State state) {
+  const std::string& ssid = privet_->GetCurrentlyConnectedSsid();
+  if (ssid != device_info_->GetConfig().last_configured_ssid()) {
+    weave::BuffetConfig::Transaction change{device_info_->GetMutableConfig()};
+    change.set_last_configured_ssid(ssid);
+  }
+}
+
+std::unique_ptr<Device> Device::Create() {
+  return std::unique_ptr<Device>{new DeviceManager};
+}
+
+}  // namespace weave
diff --git a/libweave/src/device_manager.h b/libweave/src/device_manager.h
new file mode 100644
index 0000000..0eba82a
--- /dev/null
+++ b/libweave/src/device_manager.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 LIBWEAVE_SRC_DEVICE_MANAGER_H_
+#define LIBWEAVE_SRC_DEVICE_MANAGER_H_
+
+#include "weave/device.h"
+
+namespace chromeos {
+namespace dbus_utils {
+class DBusObject;
+}
+}
+
+namespace weave {
+
+class BaseApiHandler;
+class BuffetConfig;
+class CommandManager;
+class DeviceRegistrationInfo;
+class StateChangeQueue;
+class StateManager;
+
+namespace privet {
+class ShillClient;
+class Manager;
+}  // namespace privet
+
+class DeviceManager final : public Device {
+ public:
+  DeviceManager();
+  ~DeviceManager() override;
+
+  void Start(const Options& options,
+             chromeos::dbus_utils::DBusObject* dbus_object,
+             chromeos::dbus_utils::AsyncEventSequencer* sequencer) override;
+
+  CommandManager* GetCommands() override;
+  StateManager* GetState() override;
+  BuffetConfig* GetConfig() override;
+  DeviceRegistrationInfo* GetCloud() override;
+  privet::Manager* GetPrivet() override;
+
+ private:
+  void StartPrivet(const Options& options,
+                   chromeos::dbus_utils::DBusObject* dbus_object,
+                   chromeos::dbus_utils::AsyncEventSequencer* sequencer);
+
+  void OnWiFiBootstrapStateChanged(weave::WifiSetupState state);
+
+  std::shared_ptr<CommandManager> command_manager_;
+  std::unique_ptr<StateChangeQueue> state_change_queue_;
+  std::shared_ptr<StateManager> state_manager_;
+  std::unique_ptr<DeviceRegistrationInfo> device_info_;
+  std::unique_ptr<BaseApiHandler> base_api_handler_;
+  std::unique_ptr<privet::ShillClient> shill_client_;
+  std::unique_ptr<privet::Manager> privet_;
+
+  base::WeakPtrFactory<DeviceManager> weak_ptr_factory_{this};
+  DISALLOW_COPY_AND_ASSIGN(DeviceManager);
+};
+
+}  // namespace weave
+
+#endif  // LIBWEAVE_SRC_DEVICE_MANAGER_H_
diff --git a/libweave/src/device_registration_info.cc b/libweave/src/device_registration_info.cc
index 4671010..d88b00a 100644
--- a/libweave/src/device_registration_info.cc
+++ b/libweave/src/device_registration_info.cc
@@ -704,7 +704,7 @@
     chromeos::ErrorPtr* error) {
   BuffetConfig::Transaction change(config_.get());
   if (!change.set_local_anonymous_access_role(anonymous_access_role)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
+    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain,
                                  "invalid_parameter", "Invalid role: %s",
                                  anonymous_access_role.c_str());
     return false;
@@ -724,8 +724,7 @@
     const std::string& service_url,
     chromeos::ErrorPtr* error) {
   if (HaveRegistrationCredentials()) {
-    chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainBuffet,
-                           "already_registered",
+    chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain, "already_registered",
                            "Unable to change config for registered device");
     return false;
   }
@@ -1010,7 +1009,7 @@
 void DeviceRegistrationInfo::SetRegistrationStatus(
     RegistrationStatus new_status) {
   VLOG_IF(1, new_status != registration_status_)
-      << "Changing registration status to " << StatusToString(new_status);
+      << "Changing registration status to " << static_cast<int>(new_status);
   registration_status_ = new_status;
   for (const auto& cb : on_registration_changed_)
     cb.Run(registration_status_);
diff --git a/libweave/src/device_registration_info.h b/libweave/src/device_registration_info.h
index 5d55ee6..afb64d1 100644
--- a/libweave/src/device_registration_info.h
+++ b/libweave/src/device_registration_info.h
@@ -29,7 +29,6 @@
 #include "libweave/src/notification/notification_channel.h"
 #include "libweave/src/notification/notification_delegate.h"
 #include "libweave/src/notification/pull_channel.h"
-#include "libweave/src/registration_status.h"
 #include "libweave/src/states/state_change_queue_interface.h"
 #include "libweave/src/storage_interface.h"
 
diff --git a/libweave/src/privet/cloud_delegate.cc b/libweave/src/privet/cloud_delegate.cc
index 1737b10..8f2aefc 100644
--- a/libweave/src/privet/cloud_delegate.cc
+++ b/libweave/src/privet/cloud_delegate.cc
@@ -21,6 +21,7 @@
 #include "libweave/src/commands/command_manager.h"
 #include "libweave/src/device_registration_info.h"
 #include "libweave/src/privet/constants.h"
+#include "libweave/src/registration_status.h"
 #include "libweave/src/states/state_manager.h"
 
 using chromeos::ErrorPtr;
diff --git a/libweave/src/privet/privet_manager.cc b/libweave/src/privet/privet_manager.cc
index 7fe3a78..1c48548 100644
--- a/libweave/src/privet/privet_manager.cc
+++ b/libweave/src/privet/privet_manager.cc
@@ -35,9 +35,7 @@
 #include "libweave/src/privet/device_delegate.h"
 #include "libweave/src/privet/peerd_client.h"
 #include "libweave/src/privet/privet_handler.h"
-#include "libweave/src/privet/security_manager.h"
 #include "libweave/src/privet/shill_client.h"
-#include "libweave/src/privet/wifi_bootstrap_manager.h"
 
 namespace weave {
 namespace privet {
@@ -62,7 +60,7 @@
 Manager::~Manager() {
 }
 
-void Manager::Start(const Options& options,
+void Manager::Start(const Device::Options& options,
                     const scoped_refptr<dbus::Bus>& bus,
                     ShillClient* shill_client,
                     DeviceRegistrationInfo* device,
@@ -123,7 +121,27 @@
   }
 }
 
-void Manager::OnShutdown() {
+std::string Manager::GetCurrentlyConnectedSsid() const {
+  return wifi_bootstrap_manager_
+             ? wifi_bootstrap_manager_->GetCurrentlyConnectedSsid()
+             : "";
+}
+
+void Manager::AddOnWifiSetupChangedCallback(
+    const WifiBootstrapManager::StateListener& callback) {
+  if (wifi_bootstrap_manager_)
+    wifi_bootstrap_manager_->RegisterStateListener(callback);
+  else
+    callback.Run(WifiSetupState::kDisabled);
+}
+
+void Manager::AddOnPairingChangedCallbacks(
+    const SecurityManager::PairingStartListener& on_start,
+    const SecurityManager::PairingEndListener& on_end) {
+  security_->RegisterPairingListeners(on_start, on_end);
+}
+
+void Manager::Shutdown() {
   web_server_->Disconnect();
 }
 
diff --git a/libweave/src/privet/privet_manager.h b/libweave/src/privet/privet_manager.h
index f16330d..3a01f13 100644
--- a/libweave/src/privet/privet_manager.h
+++ b/libweave/src/privet/privet_manager.h
@@ -14,6 +14,9 @@
 #include <base/scoped_observer.h>
 
 #include "libweave/src/privet/cloud_delegate.h"
+#include "libweave/src/privet/security_manager.h"
+#include "libweave/src/privet/wifi_bootstrap_manager.h"
+#include "weave/device.h"
 
 namespace chromeos {
 namespace dbus_utils {
@@ -44,21 +47,13 @@
 class PrivetHandler;
 class SecurityManager;
 class ShillClient;
-class WifiBootstrapManager;
 
 class Manager : public CloudDelegate::Observer {
  public:
-  struct Options {
-    bool disable_privet{false};
-    bool disable_security{false};
-    bool enable_ping{false};
-    base::FilePath config_path;
-  };
-
   Manager();
   ~Manager();
 
-  void Start(const Options& options,
+  void Start(const weave::Device::Options& options,
              const scoped_refptr<dbus::Bus>& bus,
              ShillClient* shill_client,
              DeviceRegistrationInfo* device,
@@ -66,17 +61,21 @@
              StateManager* state_manager,
              chromeos::dbus_utils::AsyncEventSequencer* sequencer);
 
-  void OnShutdown();
+  std::string GetCurrentlyConnectedSsid() const;
 
-  void OnDeviceInfoChanged() override;
+  void AddOnWifiSetupChangedCallback(
+      const WifiBootstrapManager::StateListener& callback);
 
-  privet::WifiBootstrapManager* GetWifiBootstrapManager() {
-    return wifi_bootstrap_manager_.get();
-  }
+  void AddOnPairingChangedCallbacks(
+      const SecurityManager::PairingStartListener& on_start,
+      const SecurityManager::PairingEndListener& on_end);
 
-  privet::SecurityManager* GetSecurityManager() { return security_.get(); }
+  void Shutdown();
 
  private:
+  // CloudDelegate::Observer
+  void OnDeviceInfoChanged() override;
+
   void PrivetRequestHandler(std::unique_ptr<libwebserv::Request> request,
                             std::unique_ptr<libwebserv::Response> response);
 
@@ -88,7 +87,6 @@
                          std::unique_ptr<libwebserv::Response> response);
 
   void OnChanged();
-
   void OnConnectivityChanged(bool online);
 
   void OnProtocolHandlerConnected(
diff --git a/libweave/src/privet/security_delegate.h b/libweave/src/privet/security_delegate.h
index 430e882..57098f6 100644
--- a/libweave/src/privet/security_delegate.h
+++ b/libweave/src/privet/security_delegate.h
@@ -13,17 +13,11 @@
 #include <chromeos/secure_blob.h>
 
 #include "libweave/src/privet/privet_types.h"
+#include "weave/types.h"
 
 namespace weave {
 namespace privet {
 
-enum class PairingType {
-  kPinCode,
-  kEmbeddedCode,
-  kUltrasound32,
-  kAudible32,
-};
-
 enum class CryptoType {
   kNone,
   kSpake_p224,
diff --git a/libweave/src/privet/wifi_bootstrap_manager.cc b/libweave/src/privet/wifi_bootstrap_manager.cc
index ef7096a..487450c 100644
--- a/libweave/src/privet/wifi_bootstrap_manager.cc
+++ b/libweave/src/privet/wifi_bootstrap_manager.cc
@@ -70,7 +70,7 @@
     return;
   }
 
-  UpdateState(kBootstrapping);
+  UpdateState(State::kBootstrapping);
   if (!last_configured_ssid_.empty()) {
     // If we have been configured before, we'd like to periodically take down
     // our AP and find out if we can connect again.  Many kinds of failures are
@@ -94,7 +94,7 @@
                                            const std::string& passphrase) {
   VLOG(1) << "WiFi is attempting to connect. (ssid=" << ssid
           << ", pass=" << passphrase << ").";
-  UpdateState(kConnecting);
+  UpdateState(State::kConnecting);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&WifiBootstrapManager::OnConnectTimeout,
                             tasks_weak_factory_.GetWeakPtr()),
@@ -112,27 +112,28 @@
   VLOG(1) << "Monitoring connectivity.";
   // We already have a callback in place with |shill_client_| to update our
   // connectivity state.  See OnConnectivityChange().
-  UpdateState(kMonitoring);
+  UpdateState(State::kMonitoring);
 }
 
 void WifiBootstrapManager::EndMonitoring() {
 }
 
 void WifiBootstrapManager::UpdateState(State new_state) {
-  VLOG(3) << "Switching state from " << state_ << " to " << new_state;
+  VLOG(3) << "Switching state from " << static_cast<int>(state_) << " to "
+          << static_cast<int>(new_state);
   // Abort irrelevant tasks.
   tasks_weak_factory_.InvalidateWeakPtrs();
 
   switch (state_) {
-    case kDisabled:
+    case State::kDisabled:
       break;
-    case kBootstrapping:
+    case State::kBootstrapping:
       EndBootstrapping();
       break;
-    case kMonitoring:
+    case State::kMonitoring:
       EndMonitoring();
       break;
-    case kConnecting:
+    case State::kConnecting:
       EndConnecting();
       break;
   }
@@ -221,11 +222,11 @@
   VLOG(3) << "ConnectivityChanged: " << is_connected;
   UpdateConnectionState();
 
-  if (state_ == kBootstrapping) {
+  if (state_ == State::kBootstrapping) {
     StartMonitoring();
     return;
   }
-  if (state_ == kMonitoring) {
+  if (state_ == State::kMonitoring) {
     if (is_connected) {
       tasks_weak_factory_.InvalidateWeakPtrs();
     } else {
diff --git a/libweave/src/privet/wifi_bootstrap_manager.h b/libweave/src/privet/wifi_bootstrap_manager.h
index 5b51c87..4a68c46 100644
--- a/libweave/src/privet/wifi_bootstrap_manager.h
+++ b/libweave/src/privet/wifi_bootstrap_manager.h
@@ -31,12 +31,7 @@
 class WifiBootstrapManager : public WifiDelegate,
                              public CloudDelegate::Observer {
  public:
-  enum State {
-    kDisabled,
-    kBootstrapping,
-    kMonitoring,
-    kConnecting,
-  };
+  using State = WifiSetupState;
 
   using StateListener = base::Callback<void(State)>;
 
@@ -94,7 +89,7 @@
 
   // Initialization could be delayed if ssid_generator_ is not ready.
   bool is_initialized_{false};
-  State state_{kDisabled};
+  State state_{State::kDisabled};
   // Setup state is the temporal state of the most recent bootstrapping attempt.
   // It is not persisted to disk.
   SetupState setup_state_{SetupState::kNone};
diff --git a/libweave/src/registration_status.h b/libweave/src/registration_status.h
index 7b6694f..6511de1 100644
--- a/libweave/src/registration_status.h
+++ b/libweave/src/registration_status.h
@@ -7,16 +7,11 @@
 
 #include <string>
 
+#include "weave/types.h"
+
 namespace weave {
 
-// See the DBus interface XML file for complete descriptions of these states.
-enum class RegistrationStatus {
-  kUnconfigured,        // We have no credentials.
-  kConnecting,          // We have credentials but not yet connected.
-  kConnected,           // We're registered and connected to the cloud.
-  kInvalidCredentials,  // Our registration has been revoked.
-};
-
+// TODO(vitalybuka): Use EnumToString.
 std::string StatusToString(RegistrationStatus status);
 
 }  // namespace weave
diff --git a/libweave/src/states/state_manager.cc b/libweave/src/states/state_manager.cc
index a548062..7b867ca 100644
--- a/libweave/src/states/state_manager.cc
+++ b/libweave/src/states/state_manager.cc
@@ -181,7 +181,7 @@
   while (!iter.IsAtEnd()) {
     std::string package_name = iter.key();
     if (package_name.empty()) {
-      chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainBuffet,
+      chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain,
                              kInvalidPackageError,
                              "State package name is empty");
       return false;
@@ -214,7 +214,7 @@
     return false;
   std::string category = json_file_path.BaseName().RemoveExtension().value();
   if (category == kDefaultCategory) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
+    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain,
                                  kInvalidCategoryError,
                                  "Invalid state category specified in '%s'",
                                  json_file_path.value().c_str());
@@ -222,8 +222,8 @@
   }
 
   if (!LoadStateDefinition(*json, category, error)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
-                                 kFileReadError, "Failed to load file '%s'",
+    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
+                                 "Failed to load file '%s'",
                                  json_file_path.value().c_str());
     return false;
   }
@@ -237,8 +237,8 @@
   if (!json)
     return false;
   if (!LoadStateDefinition(*json, kDefaultCategory, error)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
-                                 kFileReadError, "Failed to load file '%s'",
+    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
+                                 "Failed to load file '%s'",
                                  json_file_path.value().c_str());
     return false;
   }
@@ -251,7 +251,7 @@
   while (!iter.IsAtEnd()) {
     std::string package_name = iter.key();
     if (package_name.empty()) {
-      chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainBuffet,
+      chromeos::Error::AddTo(error, FROM_HERE, kErrorDomain,
                              kInvalidPackageError,
                              "State package name is empty");
       return false;
@@ -287,8 +287,8 @@
   if (!json)
     return false;
   if (!LoadStateDefaults(*json, error)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
-                                 kFileReadError, "Failed to load file '%s'",
+    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
+                                 "Failed to load file '%s'",
                                  json_file_path.value().c_str());
     return false;
   }
diff --git a/libweave/src/utils.cc b/libweave/src/utils.cc
index a8cd587..7e0864c 100644
--- a/libweave/src/utils.cc
+++ b/libweave/src/utils.cc
@@ -33,7 +33,7 @@
 
 }  // anonymous namespace
 
-const char kErrorDomainBuffet[] = "buffet";
+const char kErrorDomain[] = "weave";
 const char kFileReadError[] = "file_read_error";
 const char kInvalidCategoryError[] = "invalid_category";
 const char kInvalidPackageError[] = "invalid_package";
@@ -44,8 +44,8 @@
   std::string json_string;
   if (!base::ReadFileToString(json_file_path, &json_string)) {
     chromeos::errors::system::AddSystemError(error, FROM_HERE, errno);
-    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
-                                 kFileReadError, "Failed to read file '%s'",
+    chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
+                                 "Failed to read file '%s'",
                                  json_file_path.value().c_str());
     return {};
   }
diff --git a/libweave/src/utils.h b/libweave/src/utils.h
index 8fa556a..8bbae3e 100644
--- a/libweave/src/utils.h
+++ b/libweave/src/utils.h
@@ -14,10 +14,9 @@
 
 namespace weave {
 
-// Buffet-wide errors.
 // TODO(avakulenko): This should be consolidated into errors::<domain> namespace
 // See crbug.com/417274
-extern const char kErrorDomainBuffet[];
+extern const char kErrorDomain[];
 extern const char kFileReadError[];
 extern const char kInvalidCategoryError[];
 extern const char kInvalidPackageError[];