diff --git a/libweave/src/base_api_handler.cc b/libweave/src/base_api_handler.cc
index f05deff..40a3a47 100644
--- a/libweave/src/base_api_handler.cc
+++ b/libweave/src/base_api_handler.cc
@@ -28,10 +28,10 @@
   device_info_->AddOnConfigChangedCallback(base::Bind(
       &BaseApiHandler::OnConfigChanged, weak_ptr_factory_.GetWeakPtr()));
 
-  const Config& config = device_info_->GetConfig();
+  const auto& settings = device_info_->GetSettings();
   base::DictionaryValue state;
   state.SetStringWithoutPathExpansion(kBaseStateFirmwareVersion,
-                                      config.firmware_version());
+                                      settings.firmware_version);
   CHECK(state_manager_->SetProperties(state, nullptr));
 
   command_manager->AddOnCommandAddedCallback(base::Bind(
@@ -52,10 +52,10 @@
 void BaseApiHandler::UpdateBaseConfiguration(Command* command) {
   command->SetProgress(base::DictionaryValue{}, nullptr);
 
-  const Config& config = device_info_->GetConfig();
-  std::string anonymous_access_role{config.local_anonymous_access_role()};
-  bool discovery_enabled{config.local_discovery_enabled()};
-  bool pairing_enabled{config.local_pairing_enabled()};
+  const auto& settings = device_info_->GetSettings();
+  std::string anonymous_access_role{settings.local_anonymous_access_role};
+  bool discovery_enabled{settings.local_discovery_enabled};
+  bool pairing_enabled{settings.local_pairing_enabled};
 
   auto parameters = command->GetParameters();
   parameters->GetString("localAnonymousAccessMaxRole", &anonymous_access_role);
@@ -84,10 +84,10 @@
 void BaseApiHandler::UpdateDeviceInfo(Command* command) {
   command->SetProgress(base::DictionaryValue{}, nullptr);
 
-  const Config& config = device_info_->GetConfig();
-  std::string name{config.name()};
-  std::string description{config.description()};
-  std::string location{config.location()};
+  const auto& settings = device_info_->GetSettings();
+  std::string name{settings.name};
+  std::string description{settings.description};
+  std::string location{settings.location};
 
   auto parameters = command->GetParameters();
   parameters->GetString("name", &name);
diff --git a/libweave/src/base_api_handler_unittest.cc b/libweave/src/base_api_handler_unittest.cc
index 67b4a9f..2e67822 100644
--- a/libweave/src/base_api_handler_unittest.cc
+++ b/libweave/src/base_api_handler_unittest.cc
@@ -115,7 +115,7 @@
     }
   })");
 
-  Config& config = *dev_reg_->GetMutableConfig();
+  const Settings& settings = dev_reg_->GetSettings();
 
   AddCommand(R"({
     'name' : 'base.updateBaseConfiguration',
@@ -125,9 +125,9 @@
       'localPairingEnabled': false
     }
   })");
-  EXPECT_EQ("none", config.local_anonymous_access_role());
-  EXPECT_FALSE(config.local_discovery_enabled());
-  EXPECT_FALSE(config.local_pairing_enabled());
+  EXPECT_EQ("none", settings.local_anonymous_access_role);
+  EXPECT_FALSE(settings.local_discovery_enabled);
+  EXPECT_FALSE(settings.local_pairing_enabled);
 
   auto expected = R"({
     'base': {
@@ -148,9 +148,9 @@
       'localPairingEnabled': true
     }
   })");
-  EXPECT_EQ("user", config.local_anonymous_access_role());
-  EXPECT_TRUE(config.local_discovery_enabled());
-  EXPECT_TRUE(config.local_pairing_enabled());
+  EXPECT_EQ("user", settings.local_anonymous_access_role);
+  EXPECT_TRUE(settings.local_discovery_enabled);
+  EXPECT_TRUE(settings.local_pairing_enabled);
   expected = R"({
     'base': {
       'firmwareVersion': '123123',
@@ -163,7 +163,7 @@
   EXPECT_JSON_EQ(expected, *state_manager_->GetStateValuesAsJson());
 
   {
-    Config::Transaction change{&config};
+    Config::Transaction change{dev_reg_->GetMutableConfig()};
     change.set_local_anonymous_access_role("viewer");
   }
   expected = R"({
@@ -204,10 +204,10 @@
     }
   })");
 
-  const Config& config = dev_reg_->GetConfig();
-  EXPECT_EQ("testName", config.name());
-  EXPECT_EQ("testDescription", config.description());
-  EXPECT_EQ("testLocation", config.location());
+  const Settings& config = dev_reg_->GetSettings();
+  EXPECT_EQ("testName", config.name);
+  EXPECT_EQ("testDescription", config.description);
+  EXPECT_EQ("testLocation", config.location);
 
   AddCommand(R"({
     'name' : 'base.updateDeviceInfo',
@@ -216,9 +216,9 @@
     }
   })");
 
-  EXPECT_EQ("testName", config.name());
-  EXPECT_EQ("testDescription", config.description());
-  EXPECT_EQ("newLocation", config.location());
+  EXPECT_EQ("testName", config.name);
+  EXPECT_EQ("testDescription", config.description);
+  EXPECT_EQ("newLocation", config.location);
 }
 
 }  // namespace weave
diff --git a/libweave/src/config.h b/libweave/src/config.h
index a54e018..2da5d0b 100644
--- a/libweave/src/config.h
+++ b/libweave/src/config.h
@@ -89,49 +89,6 @@
     bool save_{true};
   };
 
-  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& firmware_version() const {
-    return settings_.firmware_version;
-  }
-  base::TimeDelta polling_period() const { return settings_.polling_period; }
-  base::TimeDelta backup_polling_period() const {
-    return settings_.backup_polling_period;
-  }
-
-  bool wifi_auto_setup_enabled() const {
-    return settings_.wifi_auto_setup_enabled;
-  }
-  bool ble_setup_enabled() const { return settings_.ble_setup_enabled; }
-  const std::set<PairingType>& pairing_modes() const {
-    return settings_.pairing_modes;
-  }
-  const std::string& embedded_code() const { return settings_.embedded_code; }
-
-  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 settings_.local_anonymous_access_role;
-  }
-  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 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 settings_.last_configured_ssid;
-  }
-
  private:
   void Save();
 
diff --git a/libweave/src/config_unittest.cc b/libweave/src/config_unittest.cc
index 9ee16af..ec9b5a0 100644
--- a/libweave/src/config_unittest.cc
+++ b/libweave/src/config_unittest.cc
@@ -29,6 +29,10 @@
         base::Bind(&ConfigTest::OnConfigChanged, base::Unretained(this)));
   }
 
+  const Settings& GetSettings() const { return config_->GetSettings(); }
+
+  const Settings& GetDefaultSettings() const { return default_.GetSettings(); }
+
   MOCK_METHOD1(OnConfigChanged, void(const Settings&));
 
   test::MockConfigStore config_store_;
@@ -43,33 +47,34 @@
 }
 
 TEST_F(ConfigTest, Defaults) {
-  EXPECT_EQ("58855907228.apps.googleusercontent.com", config_->client_id());
-  EXPECT_EQ("eHSAREAHrIqPsHBxCE9zPPBi", config_->client_secret());
-  EXPECT_EQ("AIzaSyDSq46gG-AxUnC3zoqD9COIPrjolFsMfMA", config_->api_key());
-  EXPECT_EQ("https://accounts.google.com/o/oauth2/", config_->oauth_url());
+  EXPECT_EQ("58855907228.apps.googleusercontent.com", GetSettings().client_id);
+  EXPECT_EQ("eHSAREAHrIqPsHBxCE9zPPBi", GetSettings().client_secret);
+  EXPECT_EQ("AIzaSyDSq46gG-AxUnC3zoqD9COIPrjolFsMfMA", GetSettings().api_key);
+  EXPECT_EQ("https://accounts.google.com/o/oauth2/", GetSettings().oauth_url);
   EXPECT_EQ("https://www.googleapis.com/clouddevices/v1/",
-            config_->service_url());
-  EXPECT_EQ("Chromium", config_->oem_name());
-  EXPECT_EQ("Brillo", config_->model_name());
-  EXPECT_EQ("AAAAA", config_->model_id());
-  EXPECT_EQ("", config_->firmware_version());
-  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_FALSE(config_->ble_setup_enabled());
+            GetSettings().service_url);
+  EXPECT_EQ("Chromium", GetSettings().oem_name);
+  EXPECT_EQ("Brillo", GetSettings().model_name);
+  EXPECT_EQ("AAAAA", GetSettings().model_id);
+  EXPECT_EQ("", GetSettings().firmware_version);
+  EXPECT_EQ(base::TimeDelta::FromSeconds(7), GetSettings().polling_period);
+  EXPECT_EQ(base::TimeDelta::FromMinutes(30),
+            GetSettings().backup_polling_period);
+  EXPECT_TRUE(GetSettings().wifi_auto_setup_enabled);
+  EXPECT_FALSE(GetSettings().ble_setup_enabled);
   EXPECT_EQ(std::set<PairingType>{PairingType::kPinCode},
-            config_->pairing_modes());
-  EXPECT_EQ("", config_->embedded_code());
-  EXPECT_EQ("Developer device", config_->name());
-  EXPECT_EQ("", config_->description());
-  EXPECT_EQ("", config_->location());
-  EXPECT_EQ("viewer", config_->local_anonymous_access_role());
-  EXPECT_TRUE(config_->local_pairing_enabled());
-  EXPECT_TRUE(config_->local_discovery_enabled());
-  EXPECT_EQ("", config_->device_id());
-  EXPECT_EQ("", config_->refresh_token());
-  EXPECT_EQ("", config_->robot_account());
-  EXPECT_EQ("", config_->last_configured_ssid());
+            GetSettings().pairing_modes);
+  EXPECT_EQ("", GetSettings().embedded_code);
+  EXPECT_EQ("Developer device", GetSettings().name);
+  EXPECT_EQ("", GetSettings().description);
+  EXPECT_EQ("", GetSettings().location);
+  EXPECT_EQ("viewer", GetSettings().local_anonymous_access_role);
+  EXPECT_TRUE(GetSettings().local_pairing_enabled);
+  EXPECT_TRUE(GetSettings().local_discovery_enabled);
+  EXPECT_EQ("", GetSettings().device_id);
+  EXPECT_EQ("", GetSettings().refresh_token);
+  EXPECT_EQ("", GetSettings().robot_account);
+  EXPECT_EQ("", GetSettings().last_configured_ssid);
 }
 
 TEST_F(ConfigTest, LoadState) {
@@ -95,92 +100,94 @@
   EXPECT_CALL(*this, OnConfigChanged(_)).Times(1);
   config_->Load();
 
-  EXPECT_EQ("state_client_id", config_->client_id());
-  EXPECT_EQ("state_client_secret", config_->client_secret());
-  EXPECT_EQ("state_api_key", config_->api_key());
-  EXPECT_EQ("state_oauth_url", config_->oauth_url());
-  EXPECT_EQ("state_service_url", config_->service_url());
-  EXPECT_EQ(default_.oem_name(), config_->oem_name());
-  EXPECT_EQ(default_.model_name(), config_->model_name());
-  EXPECT_EQ(default_.model_id(), config_->model_id());
-  EXPECT_EQ(default_.polling_period(), config_->polling_period());
-  EXPECT_EQ(default_.backup_polling_period(), config_->backup_polling_period());
-  EXPECT_EQ(default_.wifi_auto_setup_enabled(),
-            config_->wifi_auto_setup_enabled());
-  EXPECT_EQ(default_.ble_setup_enabled(), config_->ble_setup_enabled());
-  EXPECT_EQ(default_.pairing_modes(), config_->pairing_modes());
-  EXPECT_EQ(default_.embedded_code(), config_->embedded_code());
-  EXPECT_EQ("state_name", config_->name());
-  EXPECT_EQ("state_description", config_->description());
-  EXPECT_EQ("state_location", config_->location());
-  EXPECT_EQ("user", config_->local_anonymous_access_role());
-  EXPECT_FALSE(config_->local_pairing_enabled());
-  EXPECT_FALSE(config_->local_discovery_enabled());
-  EXPECT_EQ("state_device_id", config_->device_id());
-  EXPECT_EQ("state_refresh_token", config_->refresh_token());
-  EXPECT_EQ("state_robot_account", config_->robot_account());
-  EXPECT_EQ("state_last_configured_ssid", config_->last_configured_ssid());
+  EXPECT_EQ("state_client_id", GetSettings().client_id);
+  EXPECT_EQ("state_client_secret", GetSettings().client_secret);
+  EXPECT_EQ("state_api_key", GetSettings().api_key);
+  EXPECT_EQ("state_oauth_url", GetSettings().oauth_url);
+  EXPECT_EQ("state_service_url", GetSettings().service_url);
+  EXPECT_EQ(GetDefaultSettings().oem_name, GetSettings().oem_name);
+  EXPECT_EQ(GetDefaultSettings().model_name, GetSettings().model_name);
+  EXPECT_EQ(GetDefaultSettings().model_id, GetSettings().model_id);
+  EXPECT_EQ(GetDefaultSettings().polling_period, GetSettings().polling_period);
+  EXPECT_EQ(GetDefaultSettings().backup_polling_period,
+            GetSettings().backup_polling_period);
+  EXPECT_EQ(GetDefaultSettings().wifi_auto_setup_enabled,
+            GetSettings().wifi_auto_setup_enabled);
+  EXPECT_EQ(GetDefaultSettings().ble_setup_enabled,
+            GetSettings().ble_setup_enabled);
+  EXPECT_EQ(GetDefaultSettings().pairing_modes, GetSettings().pairing_modes);
+  EXPECT_EQ(GetDefaultSettings().embedded_code, GetSettings().embedded_code);
+  EXPECT_EQ("state_name", GetSettings().name);
+  EXPECT_EQ("state_description", GetSettings().description);
+  EXPECT_EQ("state_location", GetSettings().location);
+  EXPECT_EQ("user", GetSettings().local_anonymous_access_role);
+  EXPECT_FALSE(GetSettings().local_pairing_enabled);
+  EXPECT_FALSE(GetSettings().local_discovery_enabled);
+  EXPECT_EQ("state_device_id", GetSettings().device_id);
+  EXPECT_EQ("state_refresh_token", GetSettings().refresh_token);
+  EXPECT_EQ("state_robot_account", GetSettings().robot_account);
+  EXPECT_EQ("state_last_configured_ssid", GetSettings().last_configured_ssid);
 }
 
 TEST_F(ConfigTest, Setters) {
   Config::Transaction change{config_.get()};
 
   change.set_client_id("set_client_id");
-  EXPECT_EQ("set_client_id", config_->client_id());
+  EXPECT_EQ("set_client_id", GetSettings().client_id);
 
   change.set_client_secret("set_client_secret");
-  EXPECT_EQ("set_client_secret", config_->client_secret());
+  EXPECT_EQ("set_client_secret", GetSettings().client_secret);
 
   change.set_api_key("set_api_key");
-  EXPECT_EQ("set_api_key", config_->api_key());
+  EXPECT_EQ("set_api_key", GetSettings().api_key);
 
   change.set_oauth_url("set_oauth_url");
-  EXPECT_EQ("set_oauth_url", config_->oauth_url());
+  EXPECT_EQ("set_oauth_url", GetSettings().oauth_url);
 
   change.set_service_url("set_service_url");
-  EXPECT_EQ("set_service_url", config_->service_url());
+  EXPECT_EQ("set_service_url", GetSettings().service_url);
 
   change.set_name("set_name");
-  EXPECT_EQ("set_name", config_->name());
+  EXPECT_EQ("set_name", GetSettings().name);
 
   change.set_description("set_description");
-  EXPECT_EQ("set_description", config_->description());
+  EXPECT_EQ("set_description", GetSettings().description);
 
   change.set_location("set_location");
-  EXPECT_EQ("set_location", config_->location());
+  EXPECT_EQ("set_location", GetSettings().location);
 
   change.set_local_anonymous_access_role("viewer");
-  EXPECT_EQ("viewer", config_->local_anonymous_access_role());
+  EXPECT_EQ("viewer", GetSettings().local_anonymous_access_role);
 
   change.set_local_anonymous_access_role("none");
-  EXPECT_EQ("none", config_->local_anonymous_access_role());
+  EXPECT_EQ("none", GetSettings().local_anonymous_access_role);
 
   change.set_local_anonymous_access_role("user");
-  EXPECT_EQ("user", config_->local_anonymous_access_role());
+  EXPECT_EQ("user", GetSettings().local_anonymous_access_role);
 
   change.set_local_discovery_enabled(false);
-  EXPECT_FALSE(config_->local_discovery_enabled());
+  EXPECT_FALSE(GetSettings().local_discovery_enabled);
 
   change.set_local_pairing_enabled(false);
-  EXPECT_FALSE(config_->local_pairing_enabled());
+  EXPECT_FALSE(GetSettings().local_pairing_enabled);
 
   change.set_local_discovery_enabled(true);
-  EXPECT_TRUE(config_->local_discovery_enabled());
+  EXPECT_TRUE(GetSettings().local_discovery_enabled);
 
   change.set_local_pairing_enabled(true);
-  EXPECT_TRUE(config_->local_pairing_enabled());
+  EXPECT_TRUE(GetSettings().local_pairing_enabled);
 
   change.set_device_id("set_id");
-  EXPECT_EQ("set_id", config_->device_id());
+  EXPECT_EQ("set_id", GetSettings().device_id);
 
   change.set_refresh_token("set_token");
-  EXPECT_EQ("set_token", config_->refresh_token());
+  EXPECT_EQ("set_token", GetSettings().refresh_token);
 
   change.set_robot_account("set_account");
-  EXPECT_EQ("set_account", config_->robot_account());
+  EXPECT_EQ("set_account", GetSettings().robot_account);
 
   change.set_last_configured_ssid("set_last_configured_ssid");
-  EXPECT_EQ("set_last_configured_ssid", config_->last_configured_ssid());
+  EXPECT_EQ("set_last_configured_ssid", GetSettings().last_configured_ssid);
 
   EXPECT_CALL(*this, OnConfigChanged(_)).Times(1);
 
diff --git a/libweave/src/device_manager.cc b/libweave/src/device_manager.cc
index 4187df7..a54ac05 100644
--- a/libweave/src/device_manager.cc
+++ b/libweave/src/device_manager.cc
@@ -101,7 +101,7 @@
 void DeviceManager::OnWiFiBootstrapStateChanged(
     weave::privet::WifiBootstrapManager::State state) {
   const std::string& ssid = privet_->GetCurrentlyConnectedSsid();
-  if (ssid != device_info_->GetConfig().last_configured_ssid()) {
+  if (ssid != device_info_->GetSettings().last_configured_ssid) {
     weave::Config::Transaction change{device_info_->GetMutableConfig()};
     change.set_last_configured_ssid(ssid);
   }
diff --git a/libweave/src/device_registration_info.cc b/libweave/src/device_registration_info.cc
index 310eaf0..9135cfa 100644
--- a/libweave/src/device_registration_info.cc
+++ b/libweave/src/device_registration_info.cc
@@ -249,21 +249,21 @@
 std::string DeviceRegistrationInfo::GetServiceURL(
     const std::string& subpath,
     const WebParamList& params) const {
-  return BuildURL(config_->service_url(), subpath, params);
+  return BuildURL(GetSettings().service_url, subpath, params);
 }
 
 std::string DeviceRegistrationInfo::GetDeviceURL(
     const std::string& subpath,
     const WebParamList& params) const {
-  CHECK(!config_->device_id().empty()) << "Must have a valid device ID";
-  return BuildURL(config_->service_url(),
-                  "devices/" + config_->device_id() + "/" + subpath, params);
+  CHECK(!GetSettings().device_id.empty()) << "Must have a valid device ID";
+  return BuildURL(GetSettings().service_url,
+                  "devices/" + GetSettings().device_id + "/" + subpath, params);
 }
 
 std::string DeviceRegistrationInfo::GetOAuthURL(
     const std::string& subpath,
     const WebParamList& params) const {
-  return BuildURL(config_->oauth_url(), subpath, params);
+  return BuildURL(GetSettings().oauth_url, subpath, params);
 }
 
 void DeviceRegistrationInfo::Start() {
@@ -291,8 +291,9 @@
 }
 
 bool DeviceRegistrationInfo::HaveRegistrationCredentials() const {
-  return !config_->refresh_token().empty() && !config_->device_id().empty() &&
-         !config_->robot_account().empty();
+  return !GetSettings().refresh_token.empty() &&
+         !GetSettings().device_id.empty() &&
+         !GetSettings().robot_account.empty();
 }
 
 bool DeviceRegistrationInfo::VerifyRegistrationCredentials(
@@ -365,9 +366,9 @@
 
   RequestSender sender{http::kPost, GetOAuthURL("token"), http_client_};
   sender.SetFormData({
-      {"refresh_token", config_->refresh_token()},
-      {"client_id", config_->client_id()},
-      {"client_secret", config_->client_secret()},
+      {"refresh_token", GetSettings().refresh_token},
+      {"client_id", GetSettings().client_id},
+      {"client_secret", GetSettings().client_secret},
       {"grant_type", "refresh_token"},
   });
   int request_id = sender.Send(
@@ -452,7 +453,7 @@
   // call back to OnConnected() and at that time we'll switch to use the
   // primary channel and switch periodic poll into much more infrequent backup
   // poll mode.
-  const base::TimeDelta pull_interval = config_->polling_period();
+  const base::TimeDelta pull_interval = GetSettings().polling_period;
   if (!pull_channel_) {
     pull_channel_.reset(new PullChannel{pull_interval, task_runner_});
     pull_channel_->Start(this);
@@ -468,7 +469,7 @@
 
   notification_channel_starting_ = true;
   primary_notification_channel_.reset(new XmppChannel{
-      config_->robot_account(), access_token_, task_runner_, network_});
+      GetSettings().robot_account, access_token_, task_runner_, network_});
   primary_notification_channel_->Start(this);
 }
 
@@ -497,14 +498,14 @@
   CHECK(state);
 
   std::unique_ptr<base::DictionaryValue> resource{new base::DictionaryValue};
-  if (!config_->device_id().empty())
-    resource->SetString("id", config_->device_id());
-  resource->SetString("name", config_->name());
-  if (!config_->description().empty())
-    resource->SetString("description", config_->description());
-  if (!config_->location().empty())
-    resource->SetString("location", config_->location());
-  resource->SetString("modelManifestId", config_->model_id());
+  if (!GetSettings().device_id.empty())
+    resource->SetString("id", GetSettings().device_id);
+  resource->SetString("name", GetSettings().name);
+  if (!GetSettings().description.empty())
+    resource->SetString("description", GetSettings().description);
+  if (!GetSettings().location.empty())
+    resource->SetString("location", GetSettings().location);
+  resource->SetString("modelManifestId", GetSettings().model_id);
   std::unique_ptr<base::DictionaryValue> channel{new base::DictionaryValue};
   if (current_notification_channel_) {
     channel->SetString("supportedType",
@@ -542,11 +543,11 @@
 
   base::DictionaryValue req_json;
   req_json.SetString("id", ticket_id);
-  req_json.SetString("oauthClientId", config_->client_id());
+  req_json.SetString("oauthClientId", GetSettings().client_id);
   req_json.Set("deviceDraft", device_draft.release());
 
   auto url = GetServiceURL("registrationTickets/" + ticket_id,
-                           {{"key", config_->api_key()}});
+                           {{"key", GetSettings().api_key}});
 
   RequestSender sender{http::kPatch, url, http_client_};
   sender.SetJsonData(req_json);
@@ -563,7 +564,7 @@
   }
 
   url = GetServiceURL("registrationTickets/" + ticket_id + "/finalize",
-                      {{"key", config_->api_key()}});
+                      {{"key", GetSettings().api_key}});
   response = RequestSender{http::kPost, url, http_client_}.SendAndBlock(error);
   if (!response)
     return std::string();
@@ -594,8 +595,8 @@
   RequestSender sender2{http::kPost, GetOAuthURL("token"), http_client_};
   sender2.SetFormData(
       {{"code", auth_code},
-       {"client_id", config_->client_id()},
-       {"client_secret", config_->client_secret()},
+       {"client_id", GetSettings().client_id},
+       {"client_secret", GetSettings().client_secret},
        {"redirect_uri", "oob"},
        {"scope", "https://www.googleapis.com/auth/clouddevices"},
        {"grant_type", "authorization_code"}});
@@ -1041,10 +1042,9 @@
   fetch_commands_request_queued_ = false;
   DoCloudRequest(
       http::kGet,
-      GetServiceURL("commands/queue", {{"deviceId", config_->device_id()}}),
-      nullptr,
-      base::Bind(&DeviceRegistrationInfo::OnFetchCommandsSuccess, AsWeakPtr(),
-                 on_success),
+      GetServiceURL("commands/queue", {{"deviceId", GetSettings().device_id}}),
+      nullptr, base::Bind(&DeviceRegistrationInfo::OnFetchCommandsSuccess,
+                          AsWeakPtr(), on_success),
       base::Bind(&DeviceRegistrationInfo::OnFetchCommandsError, AsWeakPtr(),
                  on_failure));
 }
@@ -1230,7 +1230,7 @@
             << channel_name;
   CHECK_EQ(primary_notification_channel_->GetName(), channel_name);
   notification_channel_starting_ = false;
-  pull_channel_->UpdatePullInterval(config_->backup_polling_period());
+  pull_channel_->UpdatePullInterval(GetSettings().backup_polling_period);
   current_notification_channel_ = primary_notification_channel_.get();
 
   // If we have not successfully connected to the cloud server and we have not
@@ -1254,7 +1254,7 @@
   if (!HaveRegistrationCredentials() || !connected_to_cloud_)
     return;
 
-  pull_channel_->UpdatePullInterval(config_->polling_period());
+  pull_channel_->UpdatePullInterval(GetSettings().polling_period);
   current_notification_channel_ = pull_channel_.get();
   UpdateDeviceResource(base::Bind(&base::DoNothing),
                        base::Bind(&IgnoreCloudError));
@@ -1286,7 +1286,7 @@
 }
 
 void DeviceRegistrationInfo::OnDeviceDeleted(const std::string& device_id) {
-  if (device_id != config_->device_id()) {
+  if (device_id != GetSettings().device_id) {
     LOG(WARNING) << "Unexpected device deletion notification for device ID '"
                  << device_id << "'";
     return;
diff --git a/libweave/src/device_registration_info.h b/libweave/src/device_registration_info.h
index 93fe85c..3b2cdb7 100644
--- a/libweave/src/device_registration_info.h
+++ b/libweave/src/device_registration_info.h
@@ -132,7 +132,7 @@
                      const base::Closure& on_error) override;
 
   // TODO(vitalybuka): remove getters and pass config to dependent code.
-  const Config& GetConfig() const { return *config_; }
+  const Settings& GetSettings() const { return config_->GetSettings(); }
   Config* GetMutableConfig() { return config_.get(); }
 
  private:
diff --git a/libweave/src/privet/cloud_delegate.cc b/libweave/src/privet/cloud_delegate.cc
index 1db4228..9f16ce5 100644
--- a/libweave/src/privet/cloud_delegate.cc
+++ b/libweave/src/privet/cloud_delegate.cc
@@ -66,18 +66,18 @@
   ~CloudDelegateImpl() override = default;
 
   std::string GetModelId() const override {
-    CHECK_EQ(5, device_->GetConfig().model_id().size());
-    return device_->GetConfig().model_id();
+    CHECK_EQ(5u, device_->GetSettings().model_id.size());
+    return device_->GetSettings().model_id;
   }
 
-  std::string GetName() const override { return device_->GetConfig().name(); }
+  std::string GetName() const override { return device_->GetSettings().name; }
 
   std::string GetDescription() const override {
-    return device_->GetConfig().description();
+    return device_->GetSettings().description;
   }
 
   std::string GetLocation() const override {
-    return device_->GetConfig().location();
+    return device_->GetSettings().location;
   }
 
   void UpdateDeviceInfo(const std::string& name,
@@ -92,11 +92,11 @@
   }
 
   std::string GetOemName() const override {
-    return device_->GetConfig().oem_name();
+    return device_->GetSettings().oem_name;
   }
 
   std::string GetModelName() const override {
-    return device_->GetConfig().model_name();
+    return device_->GetSettings().model_name;
   }
 
   std::set<std::string> GetServices() const override {
@@ -110,7 +110,7 @@
 
   AuthScope GetAnonymousMaxScope() const override {
     AuthScope scope;
-    if (StringToEnum(device_->GetConfig().local_anonymous_access_role(),
+    if (StringToEnum(device_->GetSettings().local_anonymous_access_role,
                      &scope)) {
       return scope;
     }
@@ -148,7 +148,7 @@
   }
 
   std::string GetCloudId() const override {
-    return device_->GetConfig().device_id();
+    return device_->GetSettings().device_id;
   }
 
   const base::DictionaryValue& GetState() const override { return state_; }
diff --git a/libweave/src/privet/privet_manager.cc b/libweave/src/privet/privet_manager.cc
index 125fba5..2541908 100644
--- a/libweave/src/privet/privet_manager.cc
+++ b/libweave/src/privet/privet_manager.cc
@@ -49,17 +49,17 @@
   cloud_ = CloudDelegate::CreateDefault(task_runner, device, command_manager,
                                         state_manager);
   cloud_observer_.Add(cloud_.get());
-  security_.reset(new SecurityManager(device->GetConfig().pairing_modes(),
-                                      device->GetConfig().embedded_code(),
+  security_.reset(new SecurityManager(device->GetSettings().pairing_modes,
+                                      device->GetSettings().embedded_code,
                                       disable_security_, task_runner));
   network->AddOnConnectionChangedCallback(
       base::Bind(&Manager::OnConnectivityChanged, base::Unretained(this)));
 
-  if (device->GetConfig().wifi_auto_setup_enabled()) {
+  if (device->GetSettings().wifi_auto_setup_enabled) {
     VLOG(1) << "Enabling WiFi bootstrapping.";
     wifi_bootstrap_manager_.reset(new WifiBootstrapManager(
-        device->GetConfig().last_configured_ssid(), options.test_privet_ssid,
-        device->GetConfig().ble_setup_enabled(), task_runner, network,
+        device->GetSettings().last_configured_ssid, options.test_privet_ssid,
+        device->GetSettings().ble_setup_enabled, task_runner, network,
         cloud_.get()));
     wifi_bootstrap_manager_->Init();
   }