diff --git a/buffet/manager.cc b/buffet/manager.cc
index dd1ba79..572963e 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -264,15 +264,15 @@
   dbus_adaptor_.SetStatus(weave::EnumToString(status));
 }
 
-void Manager::OnConfigChanged(const weave::BuffetConfig& config) {
-  dbus_adaptor_.SetDeviceId(config.device_id());
-  dbus_adaptor_.SetOemName(config.oem_name());
-  dbus_adaptor_.SetModelName(config.model_name());
-  dbus_adaptor_.SetModelId(config.model_id());
-  dbus_adaptor_.SetName(config.name());
-  dbus_adaptor_.SetDescription(config.description());
-  dbus_adaptor_.SetLocation(config.location());
-  dbus_adaptor_.SetAnonymousAccessRole(config.local_anonymous_access_role());
+void Manager::OnConfigChanged(const weave::Settings& settings) {
+  dbus_adaptor_.SetDeviceId(settings.device_id);
+  dbus_adaptor_.SetOemName(settings.oem_name);
+  dbus_adaptor_.SetModelName(settings.model_name);
+  dbus_adaptor_.SetModelId(settings.model_id);
+  dbus_adaptor_.SetName(settings.name);
+  dbus_adaptor_.SetDescription(settings.description);
+  dbus_adaptor_.SetLocation(settings.location);
+  dbus_adaptor_.SetAnonymousAccessRole(settings.local_anonymous_access_role);
 }
 
 void Manager::UpdateWiFiBootstrapState(weave::WifiSetupState state) {
diff --git a/buffet/manager.h b/buffet/manager.h
index feb6b9d..6db50fe 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -102,7 +102,7 @@
 
   void OnStateChanged();
   void OnRegistrationChanged(weave::RegistrationStatus status);
-  void OnConfigChanged(const weave::BuffetConfig& config);
+  void OnConfigChanged(const weave::Settings& settings);
   void UpdateWiFiBootstrapState(weave::WifiSetupState state);
   void OnPairingStart(const std::string& session_id,
                       weave::PairingType pairing_type,
diff --git a/libweave/src/buffet_config.cc b/libweave/src/buffet_config.cc
index 5355566..a4a38da 100644
--- a/libweave/src/buffet_config.cc
+++ b/libweave/src/buffet_config.cc
@@ -91,6 +91,28 @@
 
 }  // namespace config_keys
 
+Settings BuffetConfig::CreateDefaultSettings() {
+  Settings result;
+  result.client_id = "58855907228.apps.googleusercontent.com";
+  result.client_secret = "eHSAREAHrIqPsHBxCE9zPPBi";
+  result.api_key = "AIzaSyDSq46gG-AxUnC3zoqD9COIPrjolFsMfMA";
+  result.oauth_url = "https://accounts.google.com/o/oauth2/";
+  result.service_url = "https://www.googleapis.com/clouddevices/v1/";
+  result.name = "Developer device";
+  result.local_anonymous_access_role = "viewer";
+  result.local_discovery_enabled = true;
+  result.local_pairing_enabled = true;
+  result.oem_name = "Chromium";
+  result.model_name = "Brillo";
+  result.model_id = "AAAAA";
+  result.device_kind = "vendor";
+  result.polling_period = base::TimeDelta::FromSeconds(7);
+  result.backup_polling_period = base::TimeDelta::FromMinutes(30);
+  result.wifi_auto_setup_enabled = true;
+  result.pairing_modes.emplace(PairingType::kPinCode);
+  return result;
+}
+
 BuffetConfig::BuffetConfig(std::unique_ptr<StorageInterface> storage)
     : storage_{std::move(storage)} {
 }
@@ -100,6 +122,16 @@
           std::unique_ptr<StorageInterface>{new FileStorage{state_path}}} {
 }
 
+void BuffetConfig::AddOnChangedCallback(const OnChangedCallback& callback) {
+  on_changed_.push_back(callback);
+  // Force to read current state.
+  callback.Run(settings_);
+}
+
+const Settings& BuffetConfig::GetSettings() const {
+  return settings_;
+}
+
 void BuffetConfig::Load(const base::FilePath& config_path) {
   chromeos::KeyValueStore store;
   if (base::PathExists(config_path)) {
@@ -113,45 +145,46 @@
   Transaction change{this};
   change.save_ = false;
 
-  store.GetString(config_keys::kClientId, &client_id_);
-  CHECK(!client_id_.empty());
+  store.GetString(config_keys::kClientId, &settings_.client_id);
+  CHECK(!settings_.client_id.empty());
 
-  store.GetString(config_keys::kClientSecret, &client_secret_);
-  CHECK(!client_secret_.empty());
+  store.GetString(config_keys::kClientSecret, &settings_.client_secret);
+  CHECK(!settings_.client_secret.empty());
 
-  store.GetString(config_keys::kApiKey, &api_key_);
-  CHECK(!api_key_.empty());
+  store.GetString(config_keys::kApiKey, &settings_.api_key);
+  CHECK(!settings_.api_key.empty());
 
-  store.GetString(config_keys::kOAuthURL, &oauth_url_);
-  CHECK(!oauth_url_.empty());
+  store.GetString(config_keys::kOAuthURL, &settings_.oauth_url);
+  CHECK(!settings_.oauth_url.empty());
 
-  store.GetString(config_keys::kServiceURL, &service_url_);
-  CHECK(!service_url_.empty());
+  store.GetString(config_keys::kServiceURL, &settings_.service_url);
+  CHECK(!settings_.service_url.empty());
 
-  store.GetString(config_keys::kOemName, &oem_name_);
-  CHECK(!oem_name_.empty());
+  store.GetString(config_keys::kOemName, &settings_.oem_name);
+  CHECK(!settings_.oem_name.empty());
 
-  store.GetString(config_keys::kModelName, &model_name_);
-  CHECK(!model_name_.empty());
+  store.GetString(config_keys::kModelName, &settings_.model_name);
+  CHECK(!settings_.model_name.empty());
 
-  store.GetString(config_keys::kModelId, &model_id_);
-  device_kind_ = GetDeviceKind(model_id_);
+  store.GetString(config_keys::kModelId, &settings_.model_id);
+  settings_.device_kind = GetDeviceKind(settings_.model_id);
 
   std::string polling_period_str;
   if (store.GetString(config_keys::kPollingPeriodMs, &polling_period_str))
-    CHECK(StringToTimeDelta(polling_period_str, &polling_period_));
+    CHECK(StringToTimeDelta(polling_period_str, &settings_.polling_period));
 
   if (store.GetString(config_keys::kBackupPollingPeriodMs, &polling_period_str))
-    CHECK(StringToTimeDelta(polling_period_str, &backup_polling_period_));
+    CHECK(StringToTimeDelta(polling_period_str,
+                            &settings_.backup_polling_period));
 
   store.GetBoolean(config_keys::kWifiAutoSetupEnabled,
-                   &wifi_auto_setup_enabled_);
+                   &settings_.wifi_auto_setup_enabled);
 
   std::string embedded_code_path;
   if (store.GetString(config_keys::kEmbeddedCodePath, &embedded_code_path)) {
-    embedded_code_path_ = base::FilePath(embedded_code_path);
-    if (!embedded_code_path_.empty())
-      pairing_modes_ = {PairingType::kEmbeddedCode};
+    settings_.embedded_code_path = base::FilePath(embedded_code_path);
+    if (!settings_.embedded_code_path.empty())
+      settings_.pairing_modes = {PairingType::kEmbeddedCode};
   }
 
   std::string modes_str;
@@ -163,25 +196,26 @@
       CHECK(StringToEnum(mode, &pairing_mode));
       pairing_modes.insert(pairing_mode);
     }
-    pairing_modes_ = std::move(pairing_modes);
+    settings_.pairing_modes = std::move(pairing_modes);
   }
 
   // Empty name set by user or server is allowed, still we expect some
   // meaningfull config value.
-  store.GetString(config_keys::kName, &name_);
-  CHECK(!name_.empty());
+  store.GetString(config_keys::kName, &settings_.name);
+  CHECK(!settings_.name.empty());
 
-  store.GetString(config_keys::kDescription, &description_);
-  store.GetString(config_keys::kLocation, &location_);
+  store.GetString(config_keys::kDescription, &settings_.description);
+  store.GetString(config_keys::kLocation, &settings_.location);
 
   store.GetString(config_keys::kLocalAnonymousAccessRole,
-                  &local_anonymous_access_role_);
-  CHECK(IsValidAccessRole(local_anonymous_access_role_))
-      << "Invalid role: " << local_anonymous_access_role_;
+                  &settings_.local_anonymous_access_role);
+  CHECK(IsValidAccessRole(settings_.local_anonymous_access_role))
+      << "Invalid role: " << settings_.local_anonymous_access_role;
 
   store.GetBoolean(config_keys::kLocalDiscoveryEnabled,
-                   &local_discovery_enabled_);
-  store.GetBoolean(config_keys::kLocalPairingEnabled, &local_pairing_enabled_);
+                   &settings_.local_discovery_enabled);
+  store.GetBoolean(config_keys::kLocalPairingEnabled,
+                   &settings_.local_pairing_enabled);
 
   change.LoadState();
 }
@@ -247,23 +281,25 @@
   if (!storage_)
     return false;
   base::DictionaryValue dict;
-  dict.SetString(config_keys::kClientId, client_id_);
-  dict.SetString(config_keys::kClientSecret, client_secret_);
-  dict.SetString(config_keys::kApiKey, api_key_);
-  dict.SetString(config_keys::kOAuthURL, oauth_url_);
-  dict.SetString(config_keys::kServiceURL, service_url_);
-  dict.SetString(config_keys::kRefreshToken, refresh_token_);
-  dict.SetString(config_keys::kDeviceId, device_id_);
-  dict.SetString(config_keys::kRobotAccount, robot_account_);
-  dict.SetString(config_keys::kLastConfiguredSsid, last_configured_ssid_);
-  dict.SetString(config_keys::kName, name_);
-  dict.SetString(config_keys::kDescription, description_);
-  dict.SetString(config_keys::kLocation, location_);
+  dict.SetString(config_keys::kClientId, settings_.client_id);
+  dict.SetString(config_keys::kClientSecret, settings_.client_secret);
+  dict.SetString(config_keys::kApiKey, settings_.api_key);
+  dict.SetString(config_keys::kOAuthURL, settings_.oauth_url);
+  dict.SetString(config_keys::kServiceURL, settings_.service_url);
+  dict.SetString(config_keys::kRefreshToken, settings_.refresh_token);
+  dict.SetString(config_keys::kDeviceId, settings_.device_id);
+  dict.SetString(config_keys::kRobotAccount, settings_.robot_account);
+  dict.SetString(config_keys::kLastConfiguredSsid,
+                 settings_.last_configured_ssid);
+  dict.SetString(config_keys::kName, settings_.name);
+  dict.SetString(config_keys::kDescription, settings_.description);
+  dict.SetString(config_keys::kLocation, settings_.location);
   dict.SetString(config_keys::kLocalAnonymousAccessRole,
-                 local_anonymous_access_role_);
+                 settings_.local_anonymous_access_role);
   dict.SetBoolean(config_keys::kLocalDiscoveryEnabled,
-                  local_discovery_enabled_);
-  dict.SetBoolean(config_keys::kLocalPairingEnabled, local_pairing_enabled_);
+                  settings_.local_discovery_enabled);
+  dict.SetBoolean(config_keys::kLocalPairingEnabled,
+                  settings_.local_pairing_enabled);
 
   return storage_->Save(dict);
 }
@@ -278,7 +314,7 @@
     LOG(ERROR) << "Invalid role: " << role;
     return false;
   }
-  config_->local_anonymous_access_role_ = role;
+  settings_->local_anonymous_access_role = role;
   return true;
 }
 
@@ -288,7 +324,7 @@
   if (save_)
     config_->Save();
   for (const auto& cb : config_->on_changed_)
-    cb.Run(*config_);
+    cb.Run(*settings_);
   config_ = nullptr;
 }
 
diff --git a/libweave/src/buffet_config.h b/libweave/src/buffet_config.h
index d384b89..d0296da 100644
--- a/libweave/src/buffet_config.h
+++ b/libweave/src/buffet_config.h
@@ -20,20 +20,46 @@
 
 class StorageInterface;
 
+struct Settings {
+  std::string client_id;
+  std::string client_secret;
+  std::string api_key;
+  std::string oauth_url;
+  std::string service_url;
+  std::string name;
+  std::string description;
+  std::string location;
+  std::string local_anonymous_access_role;
+  bool local_discovery_enabled{true};
+  bool local_pairing_enabled{true};
+  std::string oem_name;
+  std::string model_name;
+  std::string model_id;
+  std::string device_kind;
+  base::TimeDelta polling_period;
+  base::TimeDelta backup_polling_period;
+
+  bool wifi_auto_setup_enabled{true};
+  std::set<PairingType> pairing_modes;
+  base::FilePath embedded_code_path;
+
+  std::string device_id;
+  std::string refresh_token;
+  std::string robot_account;
+  std::string last_configured_ssid;
+};
+
 // Handles reading buffet config and state files.
 class BuffetConfig final {
  public:
-  using OnChangedCallback = base::Callback<void(const BuffetConfig&)>;
+  using OnChangedCallback = base::Callback<void(const Settings&)>;
 
   explicit BuffetConfig(std::unique_ptr<StorageInterface> storage);
 
   explicit BuffetConfig(const base::FilePath& state_path);
 
-  void AddOnChangedCallback(const OnChangedCallback& callback) {
-    on_changed_.push_back(callback);
-    // Force to read current state.
-    callback.Run(*this);
-  }
+  void AddOnChangedCallback(const OnChangedCallback& callback);
+  const Settings& GetSettings() const;
 
   void Load(const base::FilePath& config_path);
   void Load(const chromeos::KeyValueStore& store);
@@ -44,44 +70,45 @@
   // object.
   class Transaction final {
    public:
-    explicit Transaction(BuffetConfig* config) : config_(config) {
+    explicit Transaction(BuffetConfig* config)
+        : config_(config), settings_(&config->settings_) {
       CHECK(config_);
     }
 
     ~Transaction();
 
-    void set_client_id(const std::string& id) { config_->client_id_ = id; }
+    void set_client_id(const std::string& id) { settings_->client_id = id; }
     void set_client_secret(const std::string& secret) {
-      config_->client_secret_ = secret;
+      settings_->client_secret = secret;
     }
-    void set_api_key(const std::string& key) { config_->api_key_ = key; }
-    void set_oauth_url(const std::string& url) { config_->oauth_url_ = url; }
+    void set_api_key(const std::string& key) { settings_->api_key = key; }
+    void set_oauth_url(const std::string& url) { settings_->oauth_url = url; }
     void set_service_url(const std::string& url) {
-      config_->service_url_ = url;
+      settings_->service_url = url;
     }
-    void set_name(const std::string& name) { config_->name_ = name; }
+    void set_name(const std::string& name) { settings_->name = name; }
     void set_description(const std::string& description) {
-      config_->description_ = description;
+      settings_->description = description;
     }
     void set_location(const std::string& location) {
-      config_->location_ = location;
+      settings_->location = location;
     }
     bool set_local_anonymous_access_role(const std::string& role);
     void set_local_discovery_enabled(bool enabled) {
-      config_->local_discovery_enabled_ = enabled;
+      settings_->local_discovery_enabled = enabled;
     }
     void set_local_pairing_enabled(bool enabled) {
-      config_->local_pairing_enabled_ = enabled;
+      settings_->local_pairing_enabled = enabled;
     }
-    void set_device_id(const std::string& id) { config_->device_id_ = id; }
+    void set_device_id(const std::string& id) { settings_->device_id = id; }
     void set_refresh_token(const std::string& token) {
-      config_->refresh_token_ = token;
+      settings_->refresh_token = token;
     }
     void set_robot_account(const std::string& account) {
-      config_->robot_account_ = account;
+      settings_->robot_account = account;
     }
     void set_last_configured_ssid(const std::string& ssid) {
-      config_->last_configured_ssid_ = ssid;
+      settings_->last_configured_ssid = ssid;
     }
 
     void Commit();
@@ -90,74 +117,57 @@
     friend class BuffetConfig;
     void LoadState();
     BuffetConfig* config_;
+    Settings* settings_;
     bool save_{true};
   };
 
-  const std::string& client_id() const { return client_id_; }
-  const std::string& client_secret() const { return client_secret_; }
-  const std::string& api_key() const { return api_key_; }
-  const std::string& oauth_url() const { return oauth_url_; }
-  const std::string& service_url() const { return service_url_; }
-  const std::string& oem_name() const { return oem_name_; }
-  const std::string& model_name() const { return model_name_; }
-  const std::string& model_id() const { return model_id_; }
-  const std::string& device_kind() const { return device_kind_; }
-  base::TimeDelta polling_period() const { return polling_period_; }
+  const std::string& client_id() const { return settings_.client_id; }
+  const std::string& client_secret() const { return settings_.client_secret; }
+  const std::string& api_key() const { return settings_.api_key; }
+  const std::string& oauth_url() const { return settings_.oauth_url; }
+  const std::string& service_url() const { return settings_.service_url; }
+  const std::string& oem_name() const { return settings_.oem_name; }
+  const std::string& model_name() const { return settings_.model_name; }
+  const std::string& model_id() const { return settings_.model_id; }
+  const std::string& device_kind() const { return settings_.device_kind; }
+  base::TimeDelta polling_period() const { return settings_.polling_period; }
   base::TimeDelta backup_polling_period() const {
-    return backup_polling_period_;
+    return settings_.backup_polling_period;
   }
 
-  bool wifi_auto_setup_enabled() const { return wifi_auto_setup_enabled_; }
-  const std::set<PairingType>& pairing_modes() const { return pairing_modes_; }
+  bool wifi_auto_setup_enabled() const {
+    return settings_.wifi_auto_setup_enabled;
+  }
+  const std::set<PairingType>& pairing_modes() const {
+    return settings_.pairing_modes;
+  }
   const base::FilePath& embedded_code_path() const {
-    return embedded_code_path_;
+    return settings_.embedded_code_path;
   }
 
-  const std::string& name() const { return name_; }
-  const std::string& description() const { return description_; }
-  const std::string& location() const { return location_; }
+  const std::string& name() const { return settings_.name; }
+  const std::string& description() const { return settings_.description; }
+  const std::string& location() const { return settings_.location; }
   const std::string& local_anonymous_access_role() const {
-    return local_anonymous_access_role_;
+    return settings_.local_anonymous_access_role;
   }
-  bool local_pairing_enabled() const { return local_pairing_enabled_; }
-  bool local_discovery_enabled() const { return local_discovery_enabled_; }
+  bool local_pairing_enabled() const { return settings_.local_pairing_enabled; }
+  bool local_discovery_enabled() const {
+    return settings_.local_discovery_enabled;
+  }
 
-  const std::string& device_id() const { return device_id_; }
-  const std::string& refresh_token() const { return refresh_token_; }
-  const std::string& robot_account() const { return robot_account_; }
+  const std::string& device_id() const { return settings_.device_id; }
+  const std::string& refresh_token() const { return settings_.refresh_token; }
+  const std::string& robot_account() const { return settings_.robot_account; }
   const std::string& last_configured_ssid() const {
-    return last_configured_ssid_;
+    return settings_.last_configured_ssid;
   }
 
  private:
   bool Save();
+  static Settings CreateDefaultSettings();
 
-  std::string client_id_{"58855907228.apps.googleusercontent.com"};
-  std::string client_secret_{"eHSAREAHrIqPsHBxCE9zPPBi"};
-  std::string api_key_{"AIzaSyDSq46gG-AxUnC3zoqD9COIPrjolFsMfMA"};
-  std::string oauth_url_{"https://accounts.google.com/o/oauth2/"};
-  std::string service_url_{"https://www.googleapis.com/clouddevices/v1/"};
-  std::string name_{"Developer device"};
-  std::string description_;
-  std::string location_;
-  std::string local_anonymous_access_role_{"viewer"};
-  bool local_discovery_enabled_{true};
-  bool local_pairing_enabled_{true};
-  std::string oem_name_{"Chromium"};
-  std::string model_name_{"Brillo"};
-  std::string model_id_{"AAAAA"};
-  std::string device_kind_{"vendor"};
-  base::TimeDelta polling_period_{base::TimeDelta::FromSeconds(7)};
-  base::TimeDelta backup_polling_period_{base::TimeDelta::FromMinutes(30)};
-
-  bool wifi_auto_setup_enabled_{true};
-  std::set<PairingType> pairing_modes_{PairingType::kPinCode};
-  base::FilePath embedded_code_path_;
-
-  std::string device_id_;
-  std::string refresh_token_;
-  std::string robot_account_;
-  std::string last_configured_ssid_;
+  Settings settings_ = CreateDefaultSettings();
 
   // Serialization interface to save and load buffet state.
   std::unique_ptr<StorageInterface> storage_;
diff --git a/libweave/src/buffet_config_unittest.cc b/libweave/src/buffet_config_unittest.cc
index a286c34..7811814 100644
--- a/libweave/src/buffet_config_unittest.cc
+++ b/libweave/src/buffet_config_unittest.cc
@@ -31,7 +31,7 @@
         base::Bind(&BuffetConfigTest::OnConfigChanged, base::Unretained(this)));
   }
 
-  MOCK_METHOD1(OnConfigChanged, void(const BuffetConfig&));
+  MOCK_METHOD1(OnConfigChanged, void(const Settings&));
 
   StorageInterface* storage_{nullptr};
   std::unique_ptr<BuffetConfig> config_;
diff --git a/libweave/src/privet/cloud_delegate.cc b/libweave/src/privet/cloud_delegate.cc
index c5efb4d..9ef680d 100644
--- a/libweave/src/privet/cloud_delegate.cc
+++ b/libweave/src/privet/cloud_delegate.cc
@@ -249,7 +249,7 @@
     CHECK(command_owners_.erase(command->GetID()));
   }
 
-  void OnConfigChanged(const BuffetConfig&) { NotifyOnDeviceInfoChanged(); }
+  void OnConfigChanged(const Settings&) { NotifyOnDeviceInfoChanged(); }
 
   void OnRegistrationChanged(RegistrationStatus status) {
     if (status == RegistrationStatus::kUnconfigured) {