diff --git a/Android.mk b/Android.mk
index af05e09..de005d1 100644
--- a/Android.mk
+++ b/Android.mk
@@ -88,11 +88,8 @@
 LOCAL_MODULE := weaved
 LOCAL_REQUIRED_MODULES := \
 	avahi-daemon \
-	base_state.defaults.json \
-	base_state.schema.json \
 	weaved.json \
 	com.android.Weave.conf \
-	gcd.json \
 	webservd \
 
 LOCAL_CPP_EXTENSION := $(buffetCommonCppExtension)
@@ -156,52 +153,9 @@
 
 include $(BUILD_NATIVE_TEST)
 
-# weaved_client
-# ========================================================
-include $(CLEAR_VARS)
-LOCAL_MODULE := weaved_client
-LOCAL_CPP_EXTENSION := $(buffetCommonCppExtension)
-LOCAL_CFLAGS := $(buffetCommonCFlags)
-LOCAL_CPPFLAGS := $(buffetCommonCppFlags)
-LOCAL_C_INCLUDES := $(buffetCommonCIncludes)
-LOCAL_SHARED_LIBRARIES := $(buffetSharedLibraries)
-LOCAL_STATIC_LIBRARIES :=
-LOCAL_DBUS_PROXY_PREFIX := buffet
-LOCAL_RTTI_FLAG := -frtti
-LOCAL_CLANG := true
-
-LOCAL_SRC_FILES := \
-	buffet/buffet_client.cc \
-	buffet/dbus_bindings/dbus-service-config.json \
-	buffet/dbus_bindings/com.android.Weave.Command.dbus-xml \
-	buffet/dbus_bindings/com.android.Weave.Manager.dbus-xml \
-
-include $(BUILD_EXECUTABLE)
-
 # Config files for /etc/weaved
 # ========================================================
 include $(CLEAR_VARS)
-LOCAL_MODULE := base_state.defaults.json
-LOCAL_MODULE_CLASS := ETC
-LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/weaved
-LOCAL_SRC_FILES := buffet/etc/weaved/base_state.defaults.json
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := base_state.schema.json
-LOCAL_MODULE_CLASS := ETC
-LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/weaved
-LOCAL_SRC_FILES := buffet/etc/weaved/base_state.schema.json
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := gcd.json
-LOCAL_MODULE_CLASS := ETC
-LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/weaved
-LOCAL_SRC_FILES := buffet/etc/weaved/gcd.json
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
 LOCAL_MODULE := weaved.json
 LOCAL_MODULE_CLASS := ETC
 LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/weaved/commands
diff --git a/buffet/avahi_mdns_client.cc b/buffet/avahi_mdns_client.cc
index 3a28704..636ba35 100644
--- a/buffet/avahi_mdns_client.cc
+++ b/buffet/avahi_mdns_client.cc
@@ -39,7 +39,7 @@
 namespace buffet {
 
 AvahiMdnsClient::AvahiMdnsClient(const scoped_refptr<dbus::Bus> &bus)
-    : bus_(bus) {
+    : bus_(bus), service_name_(base::GenerateGUID()) {
 }
 
 AvahiMdnsClient::~AvahiMdnsClient() {
@@ -229,7 +229,7 @@
 void AvahiMdnsClient::CreateService() {
   ErrorPtr error;
 
-  VLOG(1) << "CreateService: name: " << device_id_ << ", type: " <<
+  VLOG(1) << "CreateService: name: " << service_name_ << ", type: " <<
       service_type_ << ", port: " << port_;
   auto resp = CallMethodAndBlock(
       entry_group_,
@@ -239,7 +239,7 @@
       int32_t{AVAHI_IF_UNSPEC},
       int32_t{AVAHI_PROTO_UNSPEC},
       uint32_t{0},  // No flags.
-      device_id_,
+      service_name_,
       std::string{"_privet._tcp"},
       std::string{},  // domain.
       std::string{},  // hostname
@@ -269,7 +269,7 @@
 
   CHECK_EQ(READY, service_state_);
 
-  VLOG(1) << "UpdateServiceTxt: name " << device_id_ << ", type: " <<
+  VLOG(1) << "UpdateServiceTxt: name " << service_name_ << ", type: " <<
       service_type_ << ", port: " << port_;
   auto resp = CallMethodAndBlock(
       entry_group_,
@@ -279,7 +279,7 @@
       int32_t{AVAHI_IF_UNSPEC},
       int32_t{AVAHI_PROTO_UNSPEC},
       uint32_t{0},  // No flags.
-      device_id_,
+      service_name_,
       std::string{"_privet._tcp"},
       std::string{},  // domain.
       txt_);
diff --git a/buffet/avahi_mdns_client.h b/buffet/avahi_mdns_client.h
index 681bd3b..e689cac 100644
--- a/buffet/avahi_mdns_client.h
+++ b/buffet/avahi_mdns_client.h
@@ -59,6 +59,7 @@
   // State of the group/service publish operation.
   AsyncState service_state_{UNDEF};
 
+  std::string service_name_;
   std::string service_type_;
   uint16_t port_{0};
   TxtRecord txt_;
diff --git a/buffet/buffet_client.cc b/buffet/buffet_client.cc
deleted file mode 100644
index cf39c73..0000000
--- a/buffet/buffet_client.cc
+++ /dev/null
@@ -1,400 +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 <memory>
-#include <string>
-#include <sysexits.h>
-
-#include <base/cancelable_callback.h>
-#include <base/command_line.h>
-#include <base/json/json_reader.h>
-#include <base/logging.h>
-#include <base/memory/ref_counted.h>
-#include <base/memory/weak_ptr.h>
-#include <base/strings/stringprintf.h>
-#include <base/values.h>
-#include <chromeos/any.h>
-#include <chromeos/daemons/dbus_daemon.h>
-#include <chromeos/data_encoding.h>
-#include <chromeos/dbus/data_serialization.h>
-#include <chromeos/dbus/dbus_method_invoker.h>
-#include <chromeos/errors/error.h>
-#include <chromeos/strings/string_utils.h>
-#include <chromeos/variant_dictionary.h>
-#include <dbus/bus.h>
-#include <dbus/message.h>
-#include <dbus/object_proxy.h>
-#include <dbus/object_manager.h>
-#include <dbus/values_util.h>
-
-#include "buffet/dbus-proxies.h"
-
-using chromeos::Error;
-using chromeos::ErrorPtr;
-using com::android::Weave::ManagerProxy;
-
-namespace {
-
-void usage() {
-  printf(R"(Possible commands:
-  - TestMethod <message>
-  - CheckDeviceRegistered
-  - GetDeviceInfo
-  - RegisterDevice param1=val1&param2=val2...
-  - AddCommand '{"name":"command_name","parameters":{}}'
-  - UpdateState prop_name prop_value
-  - GetState
-  - PendingCommands
-  - SetCommandVisibility pkg1.cmd1[,pkg2.cm2,...] [all|cloud|local|none]
-)");
-}
-
-// Helpers for JsonToAny().
-template<typename T>
-chromeos::Any GetJsonValue(const base::Value& json,
-                           bool(base::Value::*fnc)(T*) const) {
-  T val;
-  CHECK((json.*fnc)(&val));
-  return val;
-}
-
-template<typename T>
-chromeos::Any GetJsonList(const base::ListValue& list);  // Prototype.
-
-// Converts a JSON value into an Any so it can be sent over D-Bus using
-// UpdateState D-Bus method from Buffet.
-chromeos::Any JsonToAny(const base::Value& json) {
-  chromeos::Any prop_value;
-  switch (json.GetType()) {
-    case base::Value::TYPE_NULL:
-      prop_value = nullptr;
-      break;
-    case base::Value::TYPE_BOOLEAN:
-      prop_value = GetJsonValue<bool>(json, &base::Value::GetAsBoolean);
-      break;
-    case base::Value::TYPE_INTEGER:
-      prop_value = GetJsonValue<int>(json, &base::Value::GetAsInteger);
-      break;
-    case base::Value::TYPE_DOUBLE:
-      prop_value = GetJsonValue<double>(json, &base::Value::GetAsDouble);
-      break;
-    case base::Value::TYPE_STRING:
-      prop_value = GetJsonValue<std::string>(json, &base::Value::GetAsString);
-      break;
-    case base::Value::TYPE_BINARY:
-      LOG(FATAL) << "Binary values should not happen";
-      break;
-    case base::Value::TYPE_DICTIONARY: {
-      const base::DictionaryValue* dict = nullptr;  // Still owned by |json|.
-      CHECK(json.GetAsDictionary(&dict));
-      chromeos::VariantDictionary var_dict;
-      base::DictionaryValue::Iterator it(*dict);
-      while (!it.IsAtEnd()) {
-        var_dict.emplace(it.key(), JsonToAny(it.value()));
-        it.Advance();
-      }
-      prop_value = var_dict;
-      break;
-    }
-    case base::Value::TYPE_LIST: {
-      const base::ListValue* list = nullptr;  // Still owned by |json|.
-      CHECK(json.GetAsList(&list));
-      CHECK(!list->empty()) << "Unable to deduce the type of list elements.";
-      switch ((*list->begin())->GetType()) {
-        case base::Value::TYPE_BOOLEAN:
-          prop_value = GetJsonList<bool>(*list);
-          break;
-        case base::Value::TYPE_INTEGER:
-          prop_value = GetJsonList<int>(*list);
-          break;
-        case base::Value::TYPE_DOUBLE:
-          prop_value = GetJsonList<double>(*list);
-          break;
-        case base::Value::TYPE_STRING:
-          prop_value = GetJsonList<std::string>(*list);
-          break;
-        case base::Value::TYPE_DICTIONARY:
-          prop_value = GetJsonList<chromeos::VariantDictionary>(*list);
-          break;
-        default:
-          LOG(FATAL) << "Unsupported JSON value type for list element: "
-                     << (*list->begin())->GetType();
-      }
-      break;
-    }
-    default:
-      LOG(FATAL) << "Unexpected JSON value type: " << json.GetType();
-      break;
-  }
-  return prop_value;
-}
-
-template<typename T>
-chromeos::Any GetJsonList(const base::ListValue& list) {
-  std::vector<T> val;
-  val.reserve(list.GetSize());
-  for (const base::Value* v : list)
-    val.push_back(JsonToAny(*v).Get<T>());
-  return val;
-}
-
-class Daemon final : public chromeos::DBusDaemon {
- public:
-  Daemon() = default;
-
- protected:
-  int OnInit() override {
-    int return_code = chromeos::DBusDaemon::OnInit();
-    if (return_code != EX_OK)
-      return return_code;
-
-    object_manager_.reset(new com::android::Weave::ObjectManagerProxy{bus_});
-    return_code = ScheduleActions();
-    if (return_code == EX_USAGE) {
-      usage();
-    }
-    return return_code;
-  }
-
-  void OnShutdown(int* return_code) override {
-    if (*return_code == EX_OK)
-      *return_code = exit_code_;
-  }
-
- private:
-  int ScheduleActions() {
-    auto args = base::CommandLine::ForCurrentProcess()->GetArgs();
-
-    // Pop the command off of the args list.
-    std::string command = args.front();
-    args.erase(args.begin());
-    base::Callback<void(ManagerProxy*)> job;
-    if (command.compare("TestMethod") == 0) {
-      if (!args.empty() && !CheckArgs(command, args, 1))
-        return EX_USAGE;
-      std::string message;
-      if (!args.empty())
-        message = args.back();
-      job = base::Bind(&Daemon::CallTestMethod, weak_factory_.GetWeakPtr(),
-                       message);
-    } else if (command.compare("CheckDeviceRegistered") == 0 ||
-               command.compare("cr") == 0) {
-      if (!CheckArgs(command, args, 0))
-        return EX_USAGE;
-      job = base::Bind(&Daemon::CallCheckDeviceRegistered,
-                       weak_factory_.GetWeakPtr());
-    } else if (command.compare("GetDeviceInfo") == 0 ||
-               command.compare("di") == 0) {
-      if (!CheckArgs(command, args, 0))
-        return EX_USAGE;
-      job = base::Bind(&Daemon::CallGetDeviceInfo,
-                       weak_factory_.GetWeakPtr());
-    } else if (command.compare("RegisterDevice") == 0 ||
-               command.compare("rd") == 0) {
-      if (!args.empty() && !CheckArgs(command, args, 1))
-        return EX_USAGE;
-      std::string dict;
-      if (!args.empty())
-        dict = args.back();
-      job = base::Bind(&Daemon::CallRegisterDevice,
-                       weak_factory_.GetWeakPtr(), dict);
-    } else if (command.compare("UpdateState") == 0 ||
-               command.compare("us") == 0) {
-      if (!CheckArgs(command, args, 2))
-        return EX_USAGE;
-      job = base::Bind(&Daemon::CallUpdateState, weak_factory_.GetWeakPtr(),
-                       args.front(), args.back());
-    } else if (command.compare("GetState") == 0 ||
-               command.compare("gs") == 0) {
-      if (!CheckArgs(command, args, 0))
-        return EX_USAGE;
-      job = base::Bind(&Daemon::CallGetState, weak_factory_.GetWeakPtr());
-    } else if (command.compare("AddCommand") == 0 ||
-               command.compare("ac") == 0) {
-      if (!CheckArgs(command, args, 1))
-        return EX_USAGE;
-      job = base::Bind(&Daemon::CallAddCommand, weak_factory_.GetWeakPtr(),
-                       args.back());
-    } else if (command.compare("PendingCommands") == 0 ||
-               command.compare("pc") == 0) {
-      if (!CheckArgs(command, args, 0))
-        return EX_USAGE;
-      // CallGetPendingCommands relies on ObjectManager but it is being
-      // initialized asynchronously without a way to get a callback when
-      // it is ready to be used. So, just wait a bit before calling its
-      // methods.
-      base::MessageLoop::current()->PostDelayedTask(
-          FROM_HERE,
-          base::Bind(&Daemon::CallGetPendingCommands,
-                     weak_factory_.GetWeakPtr()),
-          base::TimeDelta::FromMilliseconds(100));
-    } else {
-      fprintf(stderr, "Unknown command: '%s'\n", command.c_str());
-      return EX_USAGE;
-    }
-    if (!job.is_null())
-      object_manager_->SetManagerAddedCallback(job);
-    timeout_task_.Reset(
-        base::Bind(&Daemon::OnJobTimeout, weak_factory_.GetWeakPtr()));
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        timeout_task_.callback(),
-        base::TimeDelta::FromSeconds(10));
-
-    return EX_OK;
-  }
-
-  void OnJobComplete() {
-    timeout_task_.Cancel();
-    Quit();
-  }
-
-  void OnJobTimeout() {
-    fprintf(stderr, "Timed out before completing request.");
-    Quit();
-  }
-
-  void ReportError(Error* error) {
-    fprintf(stderr, "Failed to receive a response: %s\n",
-            error->GetMessage().c_str());
-    exit_code_ = EX_UNAVAILABLE;
-    OnJobComplete();
-  }
-
-  bool CheckArgs(const std::string& command,
-                 const std::vector<std::string>& args,
-                 size_t expected_arg_count) {
-    if (args.size() == expected_arg_count)
-      return true;
-    fprintf(stderr, "Invalid number of arguments for command '%s'\n",
-            command.c_str());
-    return false;
-  }
-
-  void CallTestMethod(const std::string& message, ManagerProxy* manager_proxy) {
-    ErrorPtr error;
-    std::string response_message;
-    if (!manager_proxy->TestMethod(message, &response_message, &error)) {
-      return ReportError(error.get());
-    }
-    printf("Received a response: %s\n", response_message.c_str());
-    OnJobComplete();
-  }
-
-  void CallCheckDeviceRegistered(ManagerProxy* manager_proxy) {
-    ErrorPtr error;
-    std::string device_id;
-    if (!manager_proxy->CheckDeviceRegistered(&device_id, &error)) {
-      return ReportError(error.get());
-    }
-
-    printf("Device ID: %s\n",
-           device_id.empty() ? "<unregistered>" : device_id.c_str());
-    OnJobComplete();
-  }
-
-  void CallGetDeviceInfo(ManagerProxy* manager_proxy) {
-    ErrorPtr error;
-    std::string device_info;
-    if (!manager_proxy->GetDeviceInfo(&device_info, &error)) {
-      return ReportError(error.get());
-    }
-
-    printf("%s\n", device_info.c_str());
-    OnJobComplete();
-  }
-
-  void CallRegisterDevice(const std::string& args,
-                          ManagerProxy* manager_proxy) {
-    std::string ticket_id;
-    if (!args.empty()) {
-      auto key_values = chromeos::data_encoding::WebParamsDecode(args);
-      for (const auto& pair : key_values) {
-        if (pair.first == "ticket_id")
-          ticket_id = pair.second;
-      }
-    }
-
-    ErrorPtr error;
-    std::string device_id;
-    if (!manager_proxy->RegisterDevice(ticket_id, &device_id, &error)) {
-      return ReportError(error.get());
-    }
-
-    printf("Device registered: %s\n", device_id.c_str());
-    OnJobComplete();
-  }
-
-  void CallUpdateState(const std::string& prop,
-                       const std::string& value,
-                       ManagerProxy* manager_proxy) {
-    ErrorPtr error;
-    std::string error_message;
-    std::unique_ptr<base::Value> json(
-        base::JSONReader::ReadAndReturnError(value, base::JSON_PARSE_RFC,
-                                             nullptr, &error_message)
-            .release());
-    if (!json) {
-      Error::AddTo(&error, FROM_HERE, chromeos::errors::json::kDomain,
-                   chromeos::errors::json::kParseError, error_message);
-      return ReportError(error.get());
-    }
-
-    chromeos::VariantDictionary property_set{{prop, JsonToAny(*json)}};
-    if (!manager_proxy->UpdateState(property_set, &error)) {
-      return ReportError(error.get());
-    }
-    OnJobComplete();
-  }
-
-  void CallGetState(ManagerProxy* manager_proxy) {
-    std::string json;
-    ErrorPtr error;
-    if (!manager_proxy->GetState(&json, &error)) {
-      return ReportError(error.get());
-    }
-    printf("%s\n", json.c_str());
-    OnJobComplete();
-  }
-
-  void CallAddCommand(const std::string& command, ManagerProxy* manager_proxy) {
-    ErrorPtr error;
-    std::string id;
-    if (!manager_proxy->AddCommand(command, "owner", &id, &error)) {
-      return ReportError(error.get());
-    }
-    OnJobComplete();
-  }
-
-  void CallGetPendingCommands() {
-    printf("Pending commands:\n");
-    for (auto* cmd : object_manager_->GetCommandInstances()) {
-      printf("%10s - '%s' (id:%s)\n", cmd->status().c_str(),
-             cmd->name().c_str(), cmd->id().c_str());
-    }
-    OnJobComplete();
-  }
-
-  std::unique_ptr<com::android::Weave::ObjectManagerProxy> object_manager_;
-  int exit_code_{EX_OK};
-  base::CancelableCallback<void()> timeout_task_;
-
-  base::WeakPtrFactory<Daemon> weak_factory_{this};
-  DISALLOW_COPY_AND_ASSIGN(Daemon);
-};
-
-}  // anonymous namespace
-
-int main(int argc, char** argv) {
-  base::CommandLine::Init(argc, argv);
-  base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
-  base::CommandLine::StringVector args = cl->GetArgs();
-  if (args.empty()) {
-    usage();
-    return EX_USAGE;
-  }
-
-  Daemon daemon;
-  return daemon.Run();
-}
diff --git a/buffet/buffet_config.cc b/buffet/buffet_config.cc
index ad834f8..a31dde8 100644
--- a/buffet/buffet_config.cc
+++ b/buffet/buffet_config.cc
@@ -24,14 +24,6 @@
 const char kErrorDomain[] = "buffet";
 const char kFileReadError[] = "file_read_error";
 
-bool StringToTimeDelta(const std::string& value, base::TimeDelta* delta) {
-  uint64_t ms{0};
-  if (!base::StringToUint64(value, &ms))
-    return false;
-  *delta = base::TimeDelta::FromMilliseconds(ms);
-  return true;
-}
-
 bool LoadFile(const base::FilePath& file_path,
               std::string* data,
               chromeos::ErrorPtr* error) {
@@ -63,37 +55,34 @@
 const char kOemName[] = "oem_name";
 const char kModelName[] = "model_name";
 const char kModelId[] = "model_id";
-const char kPollingPeriodMs[] = "polling_period_ms";
-const char kBackupPollingPeriodMs[] = "backup_polling_period_ms";
 const char kWifiAutoSetupEnabled[] = "wifi_auto_setup_enabled";
-const char kBleSetupEnabled[] = "ble_setup_enabled";
 const char kEmbeddedCode[] = "embedded_code";
 const char kPairingModes[] = "pairing_modes";
 
 }  // namespace config_keys
 
-BuffetConfig::BuffetConfig(const BuffetConfigPaths& paths) : paths_(paths) {}
-
-void BuffetConfig::AddOnChangedCallback(const OnChangedCallback& callback) {
-  on_changed_.push_back(callback);
-}
+BuffetConfig::BuffetConfig(const Options& options) : options_(options) {}
 
 bool BuffetConfig::LoadDefaults(weave::Settings* settings) {
-  if (!base::PathExists(paths_.defaults))
+  // Keep this hard coded default for sometime. This previously was set by
+  // libweave. It should be set by overlays buffet.conf.
+  settings->client_id = "58855907228.apps.googleusercontent.com";
+  settings->client_secret = "eHSAREAHrIqPsHBxCE9zPPBi";
+  settings->api_key = "AIzaSyDSq46gG-AxUnC3zoqD9COIPrjolFsMfMA";
+  settings->name = "Developer device";
+  settings->oem_name = "Chromium";
+  settings->model_name = "Brillo";
+  settings->model_id = "AAAAA";
+
+  if (!base::PathExists(options_.defaults))
     return true;  // Nothing to load.
 
   chromeos::KeyValueStore store;
-  if (!store.Load(paths_.defaults))
+  if (!store.Load(options_.defaults))
     return false;
-  return LoadDefaults(store, settings);
-}
-
-std::string BuffetConfig::LoadBaseCommandDefs() {
-  // Load global standard GCD command dictionary.
-  base::FilePath path{paths_.definitions.Append("gcd.json")};
-  LOG(INFO) << "Loading standard commands from " << path.value();
-  std::string result;
-  CHECK(LoadFile(path, &result, nullptr));
+  bool result = LoadDefaults(store, settings);
+  settings->disable_security = options_.disable_security;
+  settings->test_privet_ssid = options_.test_privet_ssid;
   return result;
 }
 
@@ -112,32 +101,14 @@
       CHECK(LoadFile(path, &result[category], nullptr));
     }
   };
-  load_packages(paths_.definitions, FILE_PATH_LITERAL("*.json"));
-  load_packages(paths_.test_definitions, FILE_PATH_LITERAL("*test.json"));
-  return result;
-}
-
-std::string BuffetConfig::LoadBaseStateDefs() {
-  // Load standard device state definition.
-  base::FilePath path{paths_.definitions.Append("base_state.schema.json")};
-  LOG(INFO) << "Loading standard state definition from " << path.value();
-  std::string result;
-  CHECK(LoadFile(path, &result, nullptr));
-  return result;
-}
-
-std::string BuffetConfig::LoadBaseStateDefaults() {
-  // Load standard device state defaults.
-  base::FilePath path{paths_.definitions.Append("base_state.defaults.json")};
-  LOG(INFO) << "Loading base state defaults from " << path.value();
-  std::string result;
-  CHECK(LoadFile(path, &result, nullptr));
+  load_packages(options_.definitions, FILE_PATH_LITERAL("*.json"));
+  load_packages(options_.test_definitions, FILE_PATH_LITERAL("*test.json"));
   return result;
 }
 
 std::map<std::string, std::string> BuffetConfig::LoadStateDefs() {
   // Load component-specific device state definitions.
-  base::FilePath dir{paths_.definitions.Append("states")};
+  base::FilePath dir{options_.definitions.Append("states")};
   base::FileEnumerator enumerator(dir, false, base::FileEnumerator::FILES,
                                   FILE_PATH_LITERAL("*.schema.json"));
   std::map<std::string, std::string> result;
@@ -152,7 +123,7 @@
 
 std::vector<std::string> BuffetConfig::LoadStateDefaults() {
   // Load component-specific device state defaults.
-  base::FilePath dir{paths_.definitions.Append("states")};
+  base::FilePath dir{options_.definitions.Append("states")};
   base::FileEnumerator enumerator(dir, false, base::FileEnumerator::FILES,
                                   FILE_PATH_LITERAL("*.defaults.json"));
   std::vector<std::string> result;
@@ -187,22 +158,8 @@
                << lsb_release_path.value();
   }
 
-  std::string polling_period_str;
-  if (store.GetString(config_keys::kPollingPeriodMs, &polling_period_str) &&
-      !StringToTimeDelta(polling_period_str, &settings->polling_period)) {
-    return false;
-  }
-
-  if (store.GetString(config_keys::kBackupPollingPeriodMs,
-                      &polling_period_str) &&
-      !StringToTimeDelta(polling_period_str,
-                         &settings->backup_polling_period)) {
-    return false;
-  }
-
   store.GetBoolean(config_keys::kWifiAutoSetupEnabled,
                    &settings->wifi_auto_setup_enabled);
-  store.GetBoolean(config_keys::kBleSetupEnabled, &settings->ble_setup_enabled);
   store.GetString(config_keys::kEmbeddedCode, &settings->embedded_code);
 
   std::string modes_str;
@@ -221,8 +178,12 @@
   store.GetString(config_keys::kName, &settings->name);
   store.GetString(config_keys::kDescription, &settings->description);
   store.GetString(config_keys::kLocation, &settings->location);
-  store.GetString(config_keys::kLocalAnonymousAccessRole,
-                  &settings->local_anonymous_access_role);
+
+  std::string role_str;
+  if (store.GetString(config_keys::kLocalAnonymousAccessRole, &role_str)) {
+    if (!StringToEnum(role_str, &settings->local_anonymous_access_role))
+      return false;
+  }
   store.GetBoolean(config_keys::kLocalDiscoveryEnabled,
                    &settings->local_discovery_enabled);
   store.GetBoolean(config_keys::kLocalPairingEnabled,
@@ -232,17 +193,12 @@
 
 std::string BuffetConfig::LoadSettings() {
   std::string json_string;
-  base::ReadFileToString(paths_.settings, &json_string);
+  base::ReadFileToString(options_.settings, &json_string);
   return json_string;
 }
 
 void BuffetConfig::SaveSettings(const std::string& settings) {
-  base::ImportantFileWriter::WriteFileAtomically(paths_.settings, settings);
-}
-
-void BuffetConfig::OnSettingsChanged(const weave::Settings& settings) {
-  for (const auto& cb : on_changed_)
-    cb.Run(settings);
+  base::ImportantFileWriter::WriteFileAtomically(options_.settings, settings);
 }
 
 }  // namespace buffet
diff --git a/buffet/buffet_config.h b/buffet/buffet_config.h
index b83374d..20dea47 100644
--- a/buffet/buffet_config.h
+++ b/buffet/buffet_config.h
@@ -19,43 +19,37 @@
 
 class StorageInterface;
 
-struct BuffetConfigPaths {
-  base::FilePath defaults;
-  base::FilePath settings;
-
-  base::FilePath definitions;
-  base::FilePath test_definitions;
-};
-
 // Handles reading buffet config and state files.
 class BuffetConfig final : public weave::provider::ConfigStore {
  public:
-  using OnChangedCallback = base::Callback<void(const weave::Settings&)>;
+  struct Options {
+    base::FilePath defaults;
+    base::FilePath settings;
+
+    base::FilePath definitions;
+    base::FilePath test_definitions;
+
+    bool disable_security{false};
+    std::string test_privet_ssid;
+  };
+
   ~BuffetConfig() override = default;
 
-  explicit BuffetConfig(const BuffetConfigPaths& paths);
+  explicit BuffetConfig(const Options& options);
 
   // Config overrides.
   bool LoadDefaults(weave::Settings* settings) override;
   std::string LoadSettings() override;
   void SaveSettings(const std::string& settings) override;
-  void OnSettingsChanged(const weave::Settings& settings) override;
-  std::string LoadBaseCommandDefs() override;
   std::map<std::string, std::string> LoadCommandDefs() override;
-  std::string LoadBaseStateDefs() override;
-  std::string LoadBaseStateDefaults() override;
   std::map<std::string, std::string> LoadStateDefs() override;
   std::vector<std::string> LoadStateDefaults() override;
 
-  void AddOnChangedCallback(const OnChangedCallback& callback);
-
   bool LoadDefaults(const chromeos::KeyValueStore& store,
                     weave::Settings* settings);
 
  private:
-  BuffetConfigPaths paths_;
-
-  std::vector<OnChangedCallback> on_changed_;
+  Options options_;
 
   DISALLOW_COPY_AND_ASSIGN(BuffetConfig);
 };
diff --git a/buffet/buffet_config_unittest.cc b/buffet/buffet_config_unittest.cc
index 5825030..58c2117 100644
--- a/buffet/buffet_config_unittest.cc
+++ b/buffet/buffet_config_unittest.cc
@@ -25,8 +25,7 @@
   config_store.SetString("backup_polling_period_ms", "6589");
   config_store.SetBoolean("wifi_auto_setup_enabled", false);
   config_store.SetBoolean("ble_setup_enabled", true);
-  config_store.SetString("pairing_modes",
-                         "pinCode,embeddedCode,ultrasound32,audible32");
+  config_store.SetString("pairing_modes", "pinCode,embeddedCode");
   config_store.SetString("embedded_code", "567");
   config_store.SetString("name", "conf_name");
   config_store.SetString("description", "conf_description");
@@ -54,20 +53,15 @@
   EXPECT_EQ("conf_oem_name", settings.oem_name);
   EXPECT_EQ("conf_model_name", settings.model_name);
   EXPECT_EQ("ABCDE", settings.model_id);
-  EXPECT_EQ(base::TimeDelta::FromMilliseconds(12345), settings.polling_period);
-  EXPECT_EQ(base::TimeDelta::FromMilliseconds(6589),
-            settings.backup_polling_period);
   EXPECT_FALSE(settings.wifi_auto_setup_enabled);
-  EXPECT_TRUE(settings.ble_setup_enabled);
-  std::set<weave::PairingType> pairing_types{
-      weave::PairingType::kPinCode, weave::PairingType::kEmbeddedCode,
-      weave::PairingType::kUltrasound32, weave::PairingType::kAudible32};
+  std::set<weave::PairingType> pairing_types{weave::PairingType::kPinCode,
+                                             weave::PairingType::kEmbeddedCode};
   EXPECT_EQ(pairing_types, settings.pairing_modes);
   EXPECT_EQ("567", settings.embedded_code);
   EXPECT_EQ("conf_name", settings.name);
   EXPECT_EQ("conf_description", settings.description);
   EXPECT_EQ("conf_location", settings.location);
-  EXPECT_EQ("user", settings.local_anonymous_access_role);
+  EXPECT_EQ(weave::AuthScope::kUser, settings.local_anonymous_access_role);
   EXPECT_FALSE(settings.local_pairing_enabled);
   EXPECT_FALSE(settings.local_discovery_enabled);
 }
diff --git a/buffet/dbus_bindings/com.android.Weave.Manager.dbus-xml b/buffet/dbus_bindings/com.android.Weave.Manager.dbus-xml
index bde226e..c93d893 100644
--- a/buffet/dbus_bindings/com.android.Weave.Manager.dbus-xml
+++ b/buffet/dbus_bindings/com.android.Weave.Manager.dbus-xml
@@ -8,33 +8,11 @@
       interfaces which affect the entire device such as device registration and
       device state.
     </tp:docstring>
-    <method name="CheckDeviceRegistered">
-      <arg name="device_id" type="s" direction="out"/>
-      <annotation name="org.chromium.DBus.Method.Kind" value="async"/>
-    </method>
-    <method name="GetDeviceInfo">
-      <arg name="device_info" type="s" direction="out"/>
-      <annotation name="org.chromium.DBus.Method.Kind" value="async"/>
-    </method>
     <method name="RegisterDevice">
       <arg name="ticket_id" type="s" direction="in"/>
       <arg name="device_id" type="s" direction="out"/>
       <annotation name="org.chromium.DBus.Method.Kind" value="async"/>
     </method>
-    <method name="UpdateDeviceInfo">
-      <arg name="name" type="s" direction="in"/>
-      <arg name="description" type="s" direction="in"/>
-      <arg name="location" type="s" direction="in"/>
-      <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
-    </method>
-    <method name="UpdateServiceConfig">
-      <arg name="client_id" type="s" direction="in"/>
-      <arg name="client_secret" type="s" direction="in"/>
-      <arg name="api_key" type="s" direction="in"/>
-      <arg name="oauth_url" type="s" direction="in"/>
-      <arg name="service_url" type="s" direction="in"/>
-      <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
-    </method>
     <method name="UpdateState">
       <arg name="property_set" type="a{sv}" direction="in"/>
       <annotation name="org.chromium.DBus.Method.Kind" value="async"/>
@@ -45,7 +23,6 @@
     </method>
     <method name="AddCommand">
       <arg name="json_command" type="s" direction="in"/>
-      <arg name="user_role" type="s" direction="in"/>
       <arg name="id" type="s" direction="out"/>
       <annotation name="org.chromium.DBus.Method.Kind" value="async"/>
     </method>
@@ -59,39 +36,6 @@
       <arg name="echoed_message" type="s" direction="out"/>
       <annotation name="org.chromium.DBus.Method.Kind" value="simple"/>
     </method>
-    <method name="EnableWiFiBootstrapping">
-      <tp:docstring>
-        Enables WiFiBootstrapping if manual bootstrapping is selected via the
-        configuration file.  This will re-purpose a WiFi interface for use in
-        bootstrapping.  This breaks any existing WiFi connection on the
-        interface.
-      </tp:docstring>
-      <arg name="listener_path" type="o" direction="in">
-        <tp:docstring>
-          Path to an object exposed by the caller.  This object must support
-          the com.android.Weave.WiFiBootstrapListener interface.
-        </tp:docstring>
-      </arg>
-      <arg name="options" type="a{sv}" direction="in"/>
-      <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
-    </method>
-    <method name="DisableWiFiBootstrapping">
-      <tp:docstring>
-        If a previous call to EnableWiFiBootstrapping was successful and
-        has not been cancelled or completed since, disables that bootstrapping
-        process.
-      </tp:docstring>
-      <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
-    </method>
-    <method name="EnableGCDBootstrapping">
-      <arg name="listener_path" type="o" direction="in"/>
-      <arg name="options" type="a{sv}" direction="in"/>
-      <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
-    </method>
-    <method name="DisableGCDBootstrapping">
-      <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
-    </method>
-
     <property name="Status" type="s" access="read">
       <tp:docstring>
         State of Buffet's cloud registration.
diff --git a/buffet/etc/weaved/base_state.defaults.json b/buffet/etc/weaved/base_state.defaults.json
deleted file mode 100644
index 166f2f1..0000000
--- a/buffet/etc/weaved/base_state.defaults.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "base": {
-    "firmwareVersion": "",
-    "localDiscoveryEnabled": false,
-    "localAnonymousAccessMaxRole": "none",
-    "localPairingEnabled": false
-  }
-}
diff --git a/buffet/etc/weaved/base_state.schema.json b/buffet/etc/weaved/base_state.schema.json
deleted file mode 100644
index 19cc9b2..0000000
--- a/buffet/etc/weaved/base_state.schema.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "base": {
-    "firmwareVersion": "string",
-    "localDiscoveryEnabled": "boolean",
-    "localAnonymousAccessMaxRole": [ "none", "viewer", "user" ],
-    "localPairingEnabled": "boolean",
-    "network": {
-      "properties": {
-        "name": "string"
-      }
-    }
-  }
-}
diff --git a/buffet/etc/weaved/gcd.json b/buffet/etc/weaved/gcd.json
deleted file mode 100644
index 368704e..0000000
--- a/buffet/etc/weaved/gcd.json
+++ /dev/null
@@ -1,35 +0,0 @@
-{
-  "base": {
-    "updateBaseConfiguration": {
-      "minimalRole": "manager",
-      "parameters": {
-        "localDiscoveryEnabled": "boolean",
-        "localAnonymousAccessMaxRole": [ "none", "viewer", "user" ],
-        "localPairingEnabled": "boolean"
-      },
-      "results": {}
-    },
-
-    "reboot": {
-      "minimalRole": "user",
-      "parameters": {},
-      "results": {}
-    },
-
-    "identify": {
-      "minimalRole": "user",
-      "parameters": {},
-      "results": {}
-    },
-
-    "updateDeviceInfo": {
-      "minimalRole": "manager",
-      "parameters": {
-        "description": "string",
-        "name": "string",
-        "location": "string"
-      },
-      "results": {}
-    }
-  }
-}
diff --git a/buffet/main.cc b/buffet/main.cc
index 50b6944..bda526b 100644
--- a/buffet/main.cc
+++ b/buffet/main.cc
@@ -27,25 +27,25 @@
 
 class Daemon final : public DBusServiceDaemon {
  public:
-  Daemon(const weave::Device::Options& options,
-         const BuffetConfigPaths& paths,
+  Daemon(const Manager::Options& options,
+         const BuffetConfig::Options& config_options,
          const std::set<std::string>& device_whitelist)
       : DBusServiceDaemon(kServiceName, kRootServicePath),
         options_{options},
-        paths_(paths),
+        config_options_{config_options},
         device_whitelist_{device_whitelist} {}
 
  protected:
   void RegisterDBusObjectsAsync(AsyncEventSequencer* sequencer) override {
-    manager_.reset(new buffet::Manager(object_manager_->AsWeakPtr()));
-    manager_->Start(options_, paths_, device_whitelist_, sequencer);
+    manager_.reset(new Manager(object_manager_->AsWeakPtr()));
+    manager_->Start(options_, config_options_, device_whitelist_, sequencer);
   }
 
   void OnShutdown(int* return_code) override { manager_->Stop(); }
 
  private:
-  weave::Device::Options options_;
-  BuffetConfigPaths paths_;
+  Manager::Options options_;
+  BuffetConfig::Options config_options_;
   std::set<std::string> device_whitelist_;
 
   std::unique_ptr<buffet::Manager> manager_;
@@ -101,21 +101,21 @@
   // Mark it to be ignored.
   signal(SIGPIPE, SIG_IGN);
 
-  buffet::BuffetConfigPaths paths;
-  paths.defaults = base::FilePath{FLAGS_config_path};
-  paths.settings = base::FilePath{FLAGS_state_path};
-  paths.definitions = base::FilePath{"/etc/weaved"};
-  paths.test_definitions = base::FilePath{FLAGS_test_definitions_path};
+  buffet::BuffetConfig::Options config_options;
+  config_options.defaults = base::FilePath{FLAGS_config_path};
+  config_options.settings = base::FilePath{FLAGS_state_path};
+  config_options.definitions = base::FilePath{"/etc/weaved"};
+  config_options.test_definitions = base::FilePath{FLAGS_test_definitions_path};
+  config_options.disable_security = FLAGS_disable_security;
+  config_options.test_privet_ssid = FLAGS_test_privet_ssid;
 
-  weave::Device::Options options;
+  buffet::Manager::Options options;
   options.xmpp_enabled = FLAGS_enable_xmpp;
   options.disable_privet = FLAGS_disable_privet;
-  options.disable_security = FLAGS_disable_security;
   options.enable_ping = FLAGS_enable_ping;
-  options.test_privet_ssid = FLAGS_test_privet_ssid;
 
   buffet::Daemon daemon{
-      options, paths,
+      options, config_options,
       std::set<std::string>{device_whitelist.begin(), device_whitelist.end()}};
   return daemon.Run();
 }
diff --git a/buffet/manager.cc b/buffet/manager.cc
index a1032ff..f471ded 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -14,12 +14,15 @@
 #include <base/json/json_writer.h>
 #include <base/message_loop/message_loop.h>
 #include <base/time/time.h>
+#include <chromeos/bind_lambda.h>
 #include <chromeos/dbus/async_event_sequencer.h>
 #include <chromeos/dbus/exported_object_manager.h>
 #include <chromeos/errors/error.h>
 #include <chromeos/http/http_transport.h>
+#include <chromeos/http/http_utils.h>
 #include <chromeos/key_value_store.h>
 #include <chromeos/message_loops/message_loop.h>
+#include <chromeos/mime_utils.h>
 #include <dbus/bus.h>
 #include <dbus/object_path.h>
 #include <dbus/values_util.h>
@@ -47,7 +50,6 @@
 const char kPairingCodeKey[] = "code";
 
 const char kErrorDomain[] = "buffet";
-const char kNotImplemented[] = "notImplemented";
 
 }  // anonymous namespace
 
@@ -69,42 +71,55 @@
 Manager::~Manager() {
 }
 
-void Manager::Start(const weave::Device::Options& options,
-                    const BuffetConfigPaths& paths,
+void Manager::Start(const Options& options,
+                    const BuffetConfig::Options& paths,
                     const std::set<std::string>& device_whitelist,
                     AsyncEventSequencer* sequencer) {
   task_runner_.reset(new TaskRunner{});
   http_client_.reset(new HttpTransportClient);
-  shill_client_.reset(new ShillClient{dbus_object_.GetBus(), device_whitelist});
+  shill_client_.reset(new ShillClient{dbus_object_.GetBus(), device_whitelist,
+                                      !options.xmpp_enabled});
+  weave::provider::HttpServer* http_server{nullptr};
 #ifdef BUFFET_USE_WIFI_BOOTSTRAPPING
   if (!options.disable_privet) {
     mdns_client_ = MdnsClient::CreateInstance(dbus_object_.GetBus());
     web_serv_client_.reset(new WebServClient{dbus_object_.GetBus(), sequencer});
     bluetooth_client_ = BluetoothClient::CreateInstance();
+    http_server = web_serv_client_.get();
+
+    if (options.enable_ping) {
+      http_server->AddRequestHandler(
+          "/privet/ping",
+          base::Bind(
+              [](const weave::provider::HttpServer::Request& request,
+                 const weave::provider::HttpServer::OnReplyCallback& callback) {
+                callback.Run(chromeos::http::status_code::Ok, "Hello, world!",
+                             chromeos::mime::text::kPlain);
+              }));
+    }
   }
 #endif  // BUFFET_USE_WIFI_BOOTSTRAPPING
 
-  device_ = weave::Device::Create();
   config_.reset(new BuffetConfig{paths});
-  config_->AddOnChangedCallback(
-      base::Bind(&Manager::OnConfigChanged, weak_ptr_factory_.GetWeakPtr()));
+  device_ = weave::Device::Create(config_.get(), task_runner_.get(),
+                                  http_client_.get(), shill_client_.get(),
+                                  mdns_client_.get(), web_serv_client_.get(),
+                                  shill_client_.get(), bluetooth_client_.get());
 
-  device_->Start(options, config_.get(), task_runner_.get(), http_client_.get(),
-                 shill_client_.get(), mdns_client_.get(),
-                 web_serv_client_.get(), shill_client_.get(),
-                 bluetooth_client_.get());
+  device_->AddSettingsChangedCallback(
+      base::Bind(&Manager::OnConfigChanged, weak_ptr_factory_.GetWeakPtr()));
 
   command_dispatcher_.reset(new DBusCommandDispacher{
       dbus_object_.GetObjectManager(), device_->GetCommands()});
 
-  device_->GetState()->AddOnChangedCallback(
+  device_->AddStateChangedCallback(
       base::Bind(&Manager::OnStateChanged, weak_ptr_factory_.GetWeakPtr()));
 
-  device_->GetCloud()->AddOnRegistrationChangedCallback(base::Bind(
-      &Manager::OnRegistrationChanged, weak_ptr_factory_.GetWeakPtr()));
+  device_->AddGcdStateChangedCallback(
+      base::Bind(&Manager::OnGcdStateChanged, weak_ptr_factory_.GetWeakPtr()));
 
-  if (device_->GetPrivet()) {
-    device_->GetPrivet()->AddOnPairingChangedCallbacks(
+  if (!options.disable_privet) {
+    device_->AddPairingChangedCallbacks(
         base::Bind(&Manager::OnPairingStart, weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&Manager::OnPairingEnd, weak_ptr_factory_.GetWeakPtr()));
   }
@@ -118,50 +133,12 @@
   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()";
-  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_->GetCloud()->GetDeviceInfo(
-      base::Bind(&Manager::OnGetDeviceInfoSuccess,
-                 weak_ptr_factory_.GetWeakPtr(), shared_response),
-      base::Bind(&Manager::OnGetDeviceInfoError, weak_ptr_factory_.GetWeakPtr(),
-                 shared_response));
-}
-
-void Manager::OnGetDeviceInfoSuccess(
-    const std::shared_ptr<DBusMethodResponse<std::string>>& response,
-    const base::DictionaryValue& device_info) {
-  std::string device_info_str;
-  base::JSONWriter::WriteWithOptions(
-      device_info, base::JSONWriter::OPTIONS_PRETTY_PRINT, &device_info_str);
-  response->Return(device_info_str);
-}
-
-void Manager::OnGetDeviceInfoError(
-    const std::shared_ptr<DBusMethodResponse<std::string>>& response,
-    const weave::Error* error) {
-  chromeos::ErrorPtr chromeos_error;
-  ConvertError(*error, &chromeos_error);
-  response->ReplyWithError(chromeos_error.get());
-}
-
 void Manager::RegisterDevice(DBusMethodResponsePtr<std::string> response,
                              const std::string& ticket_id) {
   LOG(INFO) << "Received call to Manager.RegisterDevice()";
 
   weave::ErrorPtr error;
-  std::string device_id =
-      device_->GetCloud()->RegisterDevice(ticket_id, &error);
+  std::string device_id = device_->Register(ticket_id, &error);
   if (!device_id.empty()) {
     response->Return(device_id);
     return;
@@ -180,7 +157,7 @@
     return response->ReplyWithError(chromeos_error.get());
 
   weave::ErrorPtr error;
-  if (!device_->GetState()->SetProperties(*properties, &error)) {
+  if (!device_->SetStateProperties(*properties, &error)) {
     ConvertError(*error, &chromeos_error);
     return response->ReplyWithError(chromeos_error.get());
   }
@@ -188,7 +165,7 @@
 }
 
 bool Manager::GetState(chromeos::ErrorPtr* error, std::string* state) {
-  auto json = device_->GetState()->GetStateValuesAsJson();
+  auto json = device_->GetState();
   CHECK(json);
   base::JSONWriter::WriteWithOptions(
       *json, base::JSONWriter::OPTIONS_PRETTY_PRINT, state);
@@ -196,8 +173,7 @@
 }
 
 void Manager::AddCommand(DBusMethodResponsePtr<std::string> response,
-                         const std::string& json_command,
-                         const std::string& in_user_role) {
+                         const std::string& json_command) {
   std::string error_message;
   std::unique_ptr<base::Value> value(
       base::JSONReader::ReadAndReturnError(json_command, base::JSON_PARSE_RFC,
@@ -210,18 +186,10 @@
                                     error_message);
   }
 
-  chromeos::ErrorPtr chromeos_error;
-  weave::UserRole role;
-  if (!StringToEnum(in_user_role, &role)) {
-    chromeos::Error::AddToPrintf(&chromeos_error, FROM_HERE, kErrorDomain,
-                                 "invalid_user_role", "Invalid role: '%s'",
-                                 in_user_role.c_str());
-    return response->ReplyWithError(chromeos_error.get());
-  }
-
   std::string id;
   weave::ErrorPtr error;
-  if (!device_->GetCommands()->AddCommand(*command, role, &id, &error)) {
+  if (!device_->GetCommands()->AddCommand(*command, &id, &error)) {
+    chromeos::ErrorPtr chromeos_error;
     ConvertError(*error, &chromeos_error);
     return response->ReplyWithError(chromeos_error.get());
   }
@@ -248,66 +216,8 @@
   return message;
 }
 
-bool Manager::EnableWiFiBootstrapping(
-    chromeos::ErrorPtr* error,
-    const dbus::ObjectPath& in_listener_path,
-    const chromeos::VariantDictionary& in_options) {
-  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, kErrorDomain, kNotImplemented,
-                         "Manual WiFi bootstrapping is not implemented");
-  return false;
-}
-
-bool Manager::EnableGCDBootstrapping(
-    chromeos::ErrorPtr* error,
-    const dbus::ObjectPath& in_listener_path,
-    const chromeos::VariantDictionary& in_options) {
-  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, kErrorDomain, kNotImplemented,
-                         "Manual GCD bootstrapping is not implemented");
-  return false;
-}
-
-bool Manager::UpdateDeviceInfo(chromeos::ErrorPtr* chromeos_error,
-                               const std::string& name,
-                               const std::string& description,
-                               const std::string& location) {
-  weave::ErrorPtr error;
-  if (!device_->GetCloud()->UpdateDeviceInfo(name, description, location,
-                                             &error)) {
-    ConvertError(*error, chromeos_error);
-    return false;
-  }
-  return true;
-}
-
-bool Manager::UpdateServiceConfig(chromeos::ErrorPtr* chromeos_error,
-                                  const std::string& client_id,
-                                  const std::string& client_secret,
-                                  const std::string& api_key,
-                                  const std::string& oauth_url,
-                                  const std::string& service_url) {
-  weave::ErrorPtr error;
-  if (!device_->GetCloud()->UpdateServiceConfig(
-          client_id, client_secret, api_key, oauth_url, service_url, &error)) {
-    ConvertError(*error, chromeos_error);
-    return false;
-  }
-  return true;
-}
-
 void Manager::OnStateChanged() {
-  auto state = device_->GetState()->GetStateValuesAsJson();
+  auto state = device_->GetState();
   CHECK(state);
   std::string json;
   base::JSONWriter::WriteWithOptions(
@@ -315,8 +225,8 @@
   dbus_adaptor_.SetState(json);
 }
 
-void Manager::OnRegistrationChanged(weave::RegistrationStatus status) {
-  dbus_adaptor_.SetStatus(weave::EnumToString(status));
+void Manager::OnGcdStateChanged(weave::GcdState state) {
+  dbus_adaptor_.SetStatus(weave::EnumToString(state));
 }
 
 void Manager::OnConfigChanged(const weave::Settings& settings) {
diff --git a/buffet/manager.h b/buffet/manager.h
index 5dd42b0..d7e8377 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -20,6 +20,7 @@
 #include <chromeos/errors/error.h>
 #include <weave/device.h>
 
+#include "buffet/buffet_config.h"
 #include "buffet/dbus_bindings/com.android.Weave.Manager.h"
 
 namespace chromeos {
@@ -31,13 +32,11 @@
 namespace buffet {
 
 class BluetoothClient;
-class BuffetConfig;
 class DBusCommandDispacher;
 class HttpTransportClient;
 class MdnsClient;
 class ShillClient;
 class WebServClient;
-struct BuffetConfigPaths;
 
 template<typename... Types>
 using DBusMethodResponsePtr =
@@ -52,13 +51,19 @@
 // device state.
 class Manager final : public com::android::Weave::ManagerInterface {
  public:
+  struct Options {
+    bool xmpp_enabled = true;
+    bool disable_privet = false;
+    bool enable_ping = false;
+  };
+
   explicit Manager(
       const base::WeakPtr<chromeos::dbus_utils::ExportedObjectManager>&
           object_manager);
   ~Manager();
 
-  void Start(const weave::Device::Options& options,
-             const BuffetConfigPaths& paths,
+  void Start(const Options& options,
+             const BuffetConfig::Options& config_options,
              const std::set<std::string>& device_whitelist,
              chromeos::dbus_utils::AsyncEventSequencer* sequencer);
 
@@ -66,53 +71,22 @@
 
  private:
   // DBus methods:
-  void CheckDeviceRegistered(
-      DBusMethodResponsePtr<std::string> response) override;
-  void GetDeviceInfo(DBusMethodResponsePtr<std::string> response) override;
   void RegisterDevice(DBusMethodResponsePtr<std::string> response,
                       const std::string& ticket_id) override;
-  bool UpdateDeviceInfo(chromeos::ErrorPtr* error,
-                        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,
-                           const std::string& api_key,
-                           const std::string& oauth_url,
-                           const std::string& service_url) override;
   void UpdateState(DBusMethodResponsePtr<> response,
                    const chromeos::VariantDictionary& property_set) override;
   bool GetState(chromeos::ErrorPtr* error, std::string* state) override;
   void AddCommand(DBusMethodResponsePtr<std::string> response,
-                  const std::string& json_command,
-                  const std::string& in_user_role) override;
+                  const std::string& json_command) override;
   void GetCommand(DBusMethodResponsePtr<std::string> response,
                   const std::string& id) override;
   std::string TestMethod(const std::string& message) override;
-  bool EnableWiFiBootstrapping(
-      chromeos::ErrorPtr* error,
-      const dbus::ObjectPath& in_listener_path,
-      const chromeos::VariantDictionary& in_options) override;
-  bool DisableWiFiBootstrapping(chromeos::ErrorPtr* error) override;
-  bool EnableGCDBootstrapping(
-      chromeos::ErrorPtr* error,
-      const dbus::ObjectPath& in_listener_path,
-      const chromeos::VariantDictionary& in_options) override;
-  bool DisableGCDBootstrapping(chromeos::ErrorPtr* error) override;
 
-  void OnGetDeviceInfoSuccess(
-      const std::shared_ptr<DBusMethodResponse<std::string>>& response,
-      const base::DictionaryValue& device_info);
-  void OnGetDeviceInfoError(
-      const std::shared_ptr<DBusMethodResponse<std::string>>& response,
-      const weave::Error* error);
-
-  void StartPrivet(const weave::Device::Options& options,
+  void StartPrivet(const Options& options,
                    chromeos::dbus_utils::AsyncEventSequencer* sequencer);
 
   void OnStateChanged();
-  void OnRegistrationChanged(weave::RegistrationStatus status);
+  void OnGcdStateChanged(weave::GcdState state);
   void OnConfigChanged(const weave::Settings& settings);
   void OnPairingStart(const std::string& session_id,
                       weave::PairingType pairing_type,
diff --git a/buffet/mdns_client.h b/buffet/mdns_client.h
index ff7a97a..f9bc229 100644
--- a/buffet/mdns_client.h
+++ b/buffet/mdns_client.h
@@ -31,22 +31,18 @@
 // Stub MDNS implementation that does nothing on platform without MDNS support.
 class MdnsClient : public weave::provider::DnsServiceDiscovery {
  public:
-  MdnsClient() : device_id_{base::GenerateGUID()} {}
+  MdnsClient() {}
   ~MdnsClient() override = default;
 
   // weave::provider::DnsServiceDiscovery implementation.
   void PublishService(const std::string& service_type, uint16_t port,
                       const std::vector<std::string>& txt) override {}
   void StopPublishing(const std::string& service_type) override {}
-  std::string GetId() const override { return device_id_; }
 
   static std::unique_ptr<MdnsClient> CreateInstance(
       const scoped_refptr<dbus::Bus>& bus);
 
  protected:
-  // Cached value of the device ID that we got from peerd.
-  std::string device_id_;
-
   DISALLOW_COPY_AND_ASSIGN(MdnsClient);
 };
 
diff --git a/buffet/peerd_client.cc b/buffet/peerd_client.cc
index 73b71e4..9c56b53 100644
--- a/buffet/peerd_client.cc
+++ b/buffet/peerd_client.cc
@@ -22,8 +22,6 @@
 // updates relevant for a short amount of time.
 const int kCommitTimeoutSeconds = 1;
 
-const char kSelfPath[] = "/org/chromium/peerd/Self";
-
 void OnError(const std::string& operation, chromeos::Error* error) {
   LOG(ERROR) << operation << " failed:" << error->GetMessage();
 }
@@ -39,18 +37,12 @@
       base::Bind(&PeerdClient::OnPeerdOnline, weak_ptr_factory_.GetWeakPtr()));
   peerd_object_manager_proxy_.SetManagerRemovedCallback(
       base::Bind(&PeerdClient::OnPeerdOffline, weak_ptr_factory_.GetWeakPtr()));
-  peerd_object_manager_proxy_.SetPeerAddedCallback(
-      base::Bind(&PeerdClient::OnNewPeer, weak_ptr_factory_.GetWeakPtr()));
 }
 
 PeerdClient::~PeerdClient() {
   RemoveService();
 }
 
-std::string PeerdClient::GetId() const {
-  return device_id_;
-}
-
 void PeerdClient::PublishService(const std::string& service_type,
                                  uint16_t port,
                                  const std::vector<std::string>& txt) {
@@ -77,26 +69,6 @@
       base::TimeDelta::FromSeconds(kCommitTimeoutSeconds));
 }
 
-void PeerdClient::OnNewPeer(PeerProxy* peer) {
-  if (!peer || peer->GetObjectPath().value() != kSelfPath)
-    return;
-  peer->SetPropertyChangedCallback(base::Bind(
-      &PeerdClient::OnPeerPropertyChanged, weak_ptr_factory_.GetWeakPtr()));
-  OnPeerPropertyChanged(peer, PeerProxy::UUIDName());
-}
-
-void PeerdClient::OnPeerPropertyChanged(PeerProxy* peer,
-                                        const std::string& property_name) {
-  if (property_name != PeerProxy::UUIDName() ||
-      peer->GetObjectPath().value() != kSelfPath)
-    return;
-  const std::string new_id{peer->uuid()};
-  if (new_id != device_id_) {
-    device_id_ = new_id;
-    Update();
-  }
-}
-
 void PeerdClient::OnPeerdOnline(
     org::chromium::peerd::ManagerProxy* manager_proxy) {
   peerd_manager_proxy_ = manager_proxy;
diff --git a/buffet/peerd_client.h b/buffet/peerd_client.h
index 997dcfd..b2cda27 100644
--- a/buffet/peerd_client.h
+++ b/buffet/peerd_client.h
@@ -32,14 +32,10 @@
                       uint16_t port,
                       const std::vector<std::string>& txt) override;
   void StopPublishing(const std::string& service_type) override;
-  std::string GetId() const override;
 
  private:
   void OnPeerdOnline(org::chromium::peerd::ManagerProxy* manager_proxy);
   void OnPeerdOffline(const dbus::ObjectPath& object_path);
-  void OnNewPeer(org::chromium::peerd::PeerProxy* peer_proxy);
-  void OnPeerPropertyChanged(org::chromium::peerd::PeerProxy* peer_proxy,
-                             const std::string& property_name);
 
   // Updates published information.  Removes service if HTTP is not alive.
   void Update();
@@ -53,9 +49,6 @@
   // |peerd_manager_proxy_| is owned by |peerd_object_manager_proxy_|.
   org::chromium::peerd::ManagerProxy* peerd_manager_proxy_{nullptr};
 
-  // Cached value of the device ID that we got from peerd.
-  std::string device_id_;
-
   bool published_{false};
   uint16_t port_{0};
   std::vector<std::string> txt_;
diff --git a/buffet/shill_client.cc b/buffet/shill_client.cc
index 64f7de3..ed80af2 100644
--- a/buffet/shill_client.cc
+++ b/buffet/shill_client.cc
@@ -88,10 +88,12 @@
 }  // namespace
 
 ShillClient::ShillClient(const scoped_refptr<dbus::Bus>& bus,
-                         const set<string>& device_whitelist)
+                         const set<string>& device_whitelist,
+                         bool disable_xmpp)
     : bus_{bus},
       manager_proxy_{bus_},
       device_whitelist_{device_whitelist},
+      disable_xmpp_{disable_xmpp},
       ap_manager_client_{new ApManagerClient(bus)} {
   manager_proxy_.RegisterPropertyChangedSignalHandler(
       base::Bind(&ShillClient::OnManagerPropertyChange,
@@ -561,6 +563,8 @@
     const base::Callback<void(std::unique_ptr<weave::Stream>)>&
         success_callback,
     const base::Callback<void(const weave::Error*)>& error_callback) {
+  if (disable_xmpp_)
+    return;
   std::unique_ptr<weave::Stream> raw_stream{
       SocketStream::ConnectBlocking(host, port)};
   if (!raw_stream) {
diff --git a/buffet/shill_client.h b/buffet/shill_client.h
index 2e4dc2c..b4ce53e 100644
--- a/buffet/shill_client.h
+++ b/buffet/shill_client.h
@@ -28,7 +28,8 @@
                           public weave::provider::Wifi {
  public:
   ShillClient(const scoped_refptr<dbus::Bus>& bus,
-              const std::set<std::string>& device_whitelist);
+              const std::set<std::string>& device_whitelist,
+              bool disable_xmpp);
   ~ShillClient();
 
   void Init();
@@ -104,6 +105,7 @@
   // There is logic that assumes we will never change this device list
   // in OnManagerPropertyChange.  Do not be tempted to remove this const.
   const std::set<std::string> device_whitelist_;
+  bool disable_xmpp_{false};
   std::vector<ConnectionChangedCallback> connectivity_listeners_;
 
   // State for tracking where we are in our attempts to connect to a service.
diff --git a/buffet/socket_stream.cc b/buffet/socket_stream.cc
index bec0cd1..4dfdeb6 100644
--- a/buffet/socket_stream.cc
+++ b/buffet/socket_stream.cc
@@ -30,7 +30,7 @@
   switch (sa->sa_family) {
     case AF_INET:
       if (inet_ntop(AF_INET,
-                    &reinterpret_cast<const sockaddr_in*>(sa)->sin_addr, str,
+                    &(reinterpret_cast<const sockaddr_in*>(sa)->sin_addr), str,
                     sizeof(str))) {
         addr = str;
       }
@@ -38,8 +38,8 @@
 
     case AF_INET6:
       if (inet_ntop(AF_INET6,
-                    &reinterpret_cast<const sockaddr_in6*>(sa)->sin6_addr, str,
-                    sizeof(str))) {
+                    &(reinterpret_cast<const sockaddr_in6*>(sa)->sin6_addr),
+                    str, sizeof(str))) {
         addr = str;
       }
       break;