diff --git a/libweave/include/weave/config_store.h b/libweave/include/weave/config_store.h
index e2bb710..8a5af58 100644
--- a/libweave/include/weave/config_store.h
+++ b/libweave/include/weave/config_store.h
@@ -5,8 +5,10 @@
 #ifndef LIBWEAVE_INCLUDE_WEAVE_CONFIG_STORE_H_
 #define LIBWEAVE_INCLUDE_WEAVE_CONFIG_STORE_H_
 
+#include <map>
 #include <set>
 #include <string>
+#include <vector>
 
 #include <base/callback.h>
 #include <base/time/time.h>
@@ -52,6 +54,15 @@
   virtual void SaveSettings(const std::string& settings) = 0;
   virtual void OnSettingsChanged(const Settings& settings) = 0;
 
+  virtual std::string LoadBaseCommandDefs() = 0;
+  virtual std::map<std::string, std::string> LoadCommandDefs() = 0;
+
+  virtual std::string LoadBaseStateDefs() = 0;
+  virtual std::string LoadBaseStateDefaults() = 0;
+
+  virtual std::map<std::string, std::string> LoadStateDefs() = 0;
+  virtual std::vector<std::string> LoadStateDefaults() = 0;
+
  protected:
   virtual ~ConfigStore() = default;
 };
diff --git a/libweave/include/weave/device.h b/libweave/include/weave/device.h
index 47e854c..cdac496 100644
--- a/libweave/include/weave/device.h
+++ b/libweave/include/weave/device.h
@@ -27,8 +27,6 @@
 class Device {
  public:
   struct Options {
-    base::FilePath definitions_path;
-    base::FilePath test_definitions_path;
     bool xmpp_enabled = true;
     bool disable_privet = false;
     bool disable_security = false;
diff --git a/libweave/include/weave/mock_config_store.h b/libweave/include/weave/mock_config_store.h
index de44877..0d03cf2 100644
--- a/libweave/include/weave/mock_config_store.h
+++ b/libweave/include/weave/mock_config_store.h
@@ -5,7 +5,9 @@
 #ifndef LIBWEAVE_INCLUDE_WEAVE_MOCK_CONFIG_STORE_H_
 #define LIBWEAVE_INCLUDE_WEAVE_MOCK_CONFIG_STORE_H_
 
+#include <map>
 #include <string>
+#include <vector>
 
 #include <gmock/gmock.h>
 #include <weave/config_store.h>
@@ -28,6 +30,15 @@
   MOCK_METHOD0(LoadSettings, std::string());
   MOCK_METHOD1(SaveSettings, void(const std::string&));
   MOCK_METHOD1(OnSettingsChanged, void(const Settings&));
+
+  MOCK_METHOD0(LoadBaseCommandDefs, std::string());
+  MOCK_METHOD0(LoadCommandDefs, std::map<std::string, std::string>());
+
+  MOCK_METHOD0(LoadBaseStateDefs, std::string());
+  MOCK_METHOD0(LoadBaseStateDefaults, std::string());
+
+  MOCK_METHOD0(LoadStateDefs, std::map<std::string, std::string>());
+  MOCK_METHOD0(LoadStateDefaults, std::vector<std::string>());
 };
 
 }  // namespace unittests
diff --git a/libweave/src/commands/command_manager.cc b/libweave/src/commands/command_manager.cc
index 34b10e6..6ecd8ba 100644
--- a/libweave/src/commands/command_manager.cc
+++ b/libweave/src/commands/command_manager.cc
@@ -6,6 +6,7 @@
 
 #include <base/files/file_enumerator.h>
 #include <base/values.h>
+#include <weave/config_store.h>
 #include <weave/enum_to_string.h>
 #include <weave/error.h>
 
@@ -27,65 +28,47 @@
   return dictionary_;
 }
 
-bool CommandManager::LoadBaseCommands(const base::DictionaryValue& json,
+bool CommandManager::LoadBaseCommands(const base::DictionaryValue& dict,
                                       ErrorPtr* error) {
-  return base_dictionary_.LoadCommands(json, "", nullptr, error);
+  return base_dictionary_.LoadCommands(dict, "", nullptr, error);
 }
 
-bool CommandManager::LoadBaseCommands(const base::FilePath& json_file_path,
+bool CommandManager::LoadBaseCommands(const std::string& json,
                                       ErrorPtr* error) {
-  std::unique_ptr<const base::DictionaryValue> json =
-      LoadJsonDict(json_file_path, error);
-  if (!json)
+  std::unique_ptr<const base::DictionaryValue> dict = LoadJsonDict(json, error);
+  if (!dict)
     return false;
-  return LoadBaseCommands(*json, error);
+  return LoadBaseCommands(*dict, error);
 }
 
-bool CommandManager::LoadCommands(const base::DictionaryValue& json,
+bool CommandManager::LoadCommands(const base::DictionaryValue& dict,
                                   const std::string& category,
                                   ErrorPtr* error) {
   bool result =
-      dictionary_.LoadCommands(json, category, &base_dictionary_, error);
+      dictionary_.LoadCommands(dict, category, &base_dictionary_, error);
   for (const auto& cb : on_command_changed_)
     cb.Run();
   return result;
 }
 
-bool CommandManager::LoadCommands(const base::FilePath& json_file_path,
+bool CommandManager::LoadCommands(const std::string& json,
+                                  const std::string& category,
                                   ErrorPtr* error) {
-  std::unique_ptr<const base::DictionaryValue> json =
-      LoadJsonDict(json_file_path, error);
-  if (!json)
+  std::unique_ptr<const base::DictionaryValue> dict = LoadJsonDict(json, error);
+  if (!dict)
     return false;
-  std::string category = json_file_path.BaseName().RemoveExtension().value();
-  return LoadCommands(*json, category, error);
+  return LoadCommands(*dict, category, error);
 }
 
-void CommandManager::Startup(const base::FilePath& definitions_path,
-                             const base::FilePath& test_definitions_path) {
+void CommandManager::Startup(ConfigStore* config_store) {
   LOG(INFO) << "Initializing CommandManager.";
-  // Load global standard GCD command dictionary.
-  base::FilePath base_command_file{definitions_path.Append("gcd.json")};
-  LOG(INFO) << "Loading standard commands from " << base_command_file.value();
-  CHECK(LoadBaseCommands(base_command_file, nullptr))
-      << "Failed to load the standard command definitions.";
 
-  auto LoadPackages = [this](const base::FilePath& root,
-                             const base::FilePath::StringType& pattern) {
-    base::FilePath device_command_dir{root.Append("commands")};
-    VLOG(2) << "Looking for commands in " << root.value();
-    base::FileEnumerator enumerator(device_command_dir, false,
-                                    base::FileEnumerator::FILES, pattern);
-    base::FilePath json_file_path = enumerator.Next();
-    while (!json_file_path.empty()) {
-      LOG(INFO) << "Loading command schema from " << json_file_path.value();
-      CHECK(this->LoadCommands(json_file_path, nullptr))
-          << "Failed to load the command definition file.";
-      json_file_path = enumerator.Next();
-    }
-  };
-  LoadPackages(definitions_path, FILE_PATH_LITERAL("*.json"));
-  LoadPackages(test_definitions_path, FILE_PATH_LITERAL("*test.json"));
+  // Load global standard GCD command dictionary.
+  CHECK(LoadBaseCommands(config_store->LoadBaseCommandDefs(), nullptr));
+
+  // Loading the rest of commands.
+  for (const auto& defs : config_store->LoadCommandDefs())
+    CHECK(this->LoadCommands(defs.second, defs.first, nullptr));
 }
 
 void CommandManager::AddCommand(
diff --git a/libweave/src/commands/command_manager.h b/libweave/src/commands/command_manager.h
index f42e293..b533579 100644
--- a/libweave/src/commands/command_manager.h
+++ b/libweave/src/commands/command_manager.h
@@ -21,6 +21,7 @@
 namespace weave {
 
 class CommandInstance;
+class ConfigStore;
 
 // CommandManager class that will have a list of all the device command
 // schemas as well as the live command queue of pending command instances
@@ -47,22 +48,22 @@
   const CommandDictionary& GetCommandDictionary() const;
 
   // Loads base/standard GCD command definitions.
-  // |json| is the full JSON schema of standard GCD commands. These commands
+  // |dict| is the full JSON schema of standard GCD commands. These commands
   // are not necessarily supported by a particular device but rather
   // all the standard commands defined by GCD standard for all known/supported
   // device kinds.
   // On success, returns true. Otherwise, |error| contains additional
   // error information.
-  bool LoadBaseCommands(const base::DictionaryValue& json, ErrorPtr* error);
+  bool LoadBaseCommands(const base::DictionaryValue& dict, ErrorPtr* error);
 
   // Same as the overload above, but takes a path to a json file to read
   // the base command definitions from.
-  bool LoadBaseCommands(const base::FilePath& json_file_path, ErrorPtr* error);
+  bool LoadBaseCommands(const std::string& json, ErrorPtr* error);
 
   // Loads device command schema for particular category.
   // See CommandDictionary::LoadCommands for detailed description of the
   // parameters.
-  bool LoadCommands(const base::DictionaryValue& json,
+  bool LoadCommands(const base::DictionaryValue& dict,
                     const std::string& category,
                     ErrorPtr* error);
 
@@ -70,16 +71,15 @@
   // the base command definitions from. Also, the command category is
   // derived from file name (without extension). So, if the path points to
   // "power_manager.json", the command category used will be "power_manager".
-  bool LoadCommands(const base::FilePath& json_file_path, ErrorPtr* error);
+  bool LoadCommands(const std::string& json,
+                    const std::string& category,
+                    ErrorPtr* error);
 
   // Startup method to be called by buffet daemon at startup.
-  // Initializes the object and reads files in |definitions_path| to load
+  // Initializes the object and loads:
   //   1) the standard GCD command dictionary
   //   2) static vendor-provided command definitions
-  // If |test_definitions_path| is not empty, we'll also look there for
-  // additional commands.
-  void Startup(const base::FilePath& definitions_path,
-               const base::FilePath& test_definitions_path);
+  void Startup(weave::ConfigStore* config_store);
 
   // Adds a new command to the command queue.
   void AddCommand(std::unique_ptr<CommandInstance> command_instance);
diff --git a/libweave/src/commands/command_manager_unittest.cc b/libweave/src/commands/command_manager_unittest.cc
index 8d79db2..a3b3de6 100644
--- a/libweave/src/commands/command_manager_unittest.cc
+++ b/libweave/src/commands/command_manager_unittest.cc
@@ -4,10 +4,13 @@
 
 #include "libweave/src/commands/command_manager.h"
 
+#include <map>
+
 #include <base/files/file_util.h>
 #include <base/files/scoped_temp_dir.h>
 #include <base/json/json_writer.h>
 #include <gtest/gtest.h>
+#include <weave/mock_config_store.h>
 
 #include "libweave/src/bind_lambda.h"
 #include "libweave/src/commands/unittest_utils.h"
@@ -19,55 +22,40 @@
 namespace {
 
 const char kTestBaseCommands[] = R"({
-  'base': {
-    'reboot': {
-      'parameters': {'delay': 'integer'},
-      'results': {}
+  "base": {
+    "reboot": {
+      "parameters": {"delay": "integer"},
+      "results": {}
     },
-    'shutdown': {
-      'parameters': {},
-      'results': {}
+    "shutdown": {
+      "parameters": {},
+      "results": {}
     }
   }
 })";
 
 const char kTestVendorCommands[] = R"({
-  'robot': {
-    '_jump': {
-      'parameters': {'height': 'integer'},
-      'results': {}
+  "robot": {
+    "_jump": {
+      "parameters": {"height": "integer"},
+      "results": {}
     },
-    '_speak': {
-      'parameters': {'phrase': 'string'},
-      'results': {}
+    "_speak": {
+      "parameters": {"phrase": "string"},
+      "results": {}
     }
   }
 })";
 
 const char kTestTestCommands[] = R"({
-  'test': {
-    '_yo': {
-      'parameters': {'name': 'string'},
-      'results': {}
+  "test": {
+    "_yo": {
+      "parameters": {"name": "string"},
+      "results": {}
     }
   }
 })";
 
-static void SaveJsonToFile(const base::DictionaryValue& dict,
-                           const base::FilePath& file_path) {
-  std::string json;
-  base::JSONWriter::Write(dict, &json);
-  const int bytes_to_write = static_cast<int>(json.size());
-  CHECK_EQ(bytes_to_write, WriteFile(file_path, json.data(), bytes_to_write));
-}
-
-static base::FilePath SaveJsonToTempFile(const base::DictionaryValue& dict) {
-  base::FilePath temp_file;
-  base::CreateTemporaryFile(&temp_file);
-  SaveJsonToFile(dict, temp_file);
-  return temp_file;
-}
-
 }  // namespace
 
 TEST(CommandManager, Empty) {
@@ -81,21 +69,13 @@
   EXPECT_TRUE(manager.LoadBaseCommands(*json, nullptr));
 }
 
-TEST(CommandManager, LoadBaseCommandsFile) {
-  CommandManager manager;
-  auto json = CreateDictionaryValue(kTestBaseCommands);
-  base::FilePath temp_file = SaveJsonToTempFile(*json);
-  EXPECT_TRUE(manager.LoadBaseCommands(temp_file, nullptr));
-  base::DeleteFile(temp_file, false);
-}
-
-TEST(CommandManager, LoadCommandsJSON) {
+TEST(CommandManager, LoadCommandsDict) {
   CommandManager manager;
   auto json = CreateDictionaryValue(kTestVendorCommands);
   EXPECT_TRUE(manager.LoadCommands(*json, "category", nullptr));
 }
 
-TEST(CommandManager, LoadCommandsFile) {
+TEST(CommandManager, LoadCommandsJson) {
   CommandManager manager;
   // Load some standard command definitions first.
   auto json = CreateDictionaryValue(R"({
@@ -111,24 +91,23 @@
     }
   })");
   manager.LoadBaseCommands(*json, nullptr);
+
   // Load device-supported commands.
-  json = CreateDictionaryValue(R"({
-    'base': {
-      'reboot': {
-        'parameters': {'delay': 'integer'},
-        'results': {}
+  auto json_str = R"({
+    "base": {
+      "reboot": {
+        "parameters": {"delay": "integer"},
+        "results": {}
       }
     },
-    'robot': {
-      '_jump': {
-        'parameters': {'height': 'integer'},
-        'results': {}
+    "robot": {
+      "_jump": {
+        "parameters": {"height": "integer"},
+        "results": {}
       }
     }
-  })");
-  base::FilePath temp_file = SaveJsonToTempFile(*json);
-  EXPECT_TRUE(manager.LoadCommands(temp_file, nullptr));
-  base::DeleteFile(temp_file, false);
+  })";
+  EXPECT_TRUE(manager.LoadCommands(json_str, "test", nullptr));
   EXPECT_EQ(2, manager.GetCommandDictionary().GetSize());
   EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("base.reboot"));
   EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("robot._jump"));
@@ -136,21 +115,13 @@
 
 TEST(CommandManager, ShouldLoadStandardAndTestDefinitions) {
   CommandManager manager;
-  base::ScopedTempDir temp;
-  CHECK(temp.CreateUniqueTempDir());
-  base::FilePath base_path{temp.path().Append("base_defs")};
-  base::FilePath test_path{temp.path().Append("test_defs")};
-  base::FilePath base_commands_path{base_path.Append("commands")};
-  base::FilePath test_commands_path{test_path.Append("commands")};
-  CHECK(CreateDirectory(base_commands_path));
-  CHECK(CreateDirectory(test_commands_path));
-  SaveJsonToFile(*CreateDictionaryValue(kTestBaseCommands),
-                 base_path.Append("gcd.json"));
-  SaveJsonToFile(*CreateDictionaryValue(kTestVendorCommands),
-                 base_commands_path.Append("category.json"));
-  SaveJsonToFile(*CreateDictionaryValue(kTestTestCommands),
-                 test_commands_path.Append("test.json"));
-  manager.Startup(base_path, test_path);
+  unittests::MockConfigStore config_store;
+  EXPECT_CALL(config_store, LoadBaseCommandDefs())
+      .WillOnce(Return(kTestBaseCommands));
+  EXPECT_CALL(config_store, LoadCommandDefs())
+      .WillOnce(Return(std::map<std::string, std::string>{
+          {"category", kTestVendorCommands}, {"test", kTestTestCommands}}));
+  manager.Startup(&config_store);
   EXPECT_EQ(3, manager.GetCommandDictionary().GetSize());
   EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("robot._jump"));
   EXPECT_NE(nullptr,
diff --git a/libweave/src/device_manager.cc b/libweave/src/device_manager.cc
index e5710d4..0f51098 100644
--- a/libweave/src/device_manager.cc
+++ b/libweave/src/device_manager.cc
@@ -35,11 +35,10 @@
                           Mdns* mdns,
                           HttpServer* http_server) {
   command_manager_ = std::make_shared<CommandManager>();
-  command_manager_->Startup(options.definitions_path,
-                            options.test_definitions_path);
+  command_manager_->Startup(config_store);
   state_change_queue_.reset(new StateChangeQueue(kMaxStateChangeQueueSize));
   state_manager_ = std::make_shared<StateManager>(state_change_queue_.get());
-  state_manager_->Startup();
+  state_manager_->Startup(config_store);
 
   std::unique_ptr<Config> config{new Config{config_store}};
   config->Load();
diff --git a/libweave/src/device_registration_info.cc b/libweave/src/device_registration_info.cc
index 26e47ed..62d1ac9 100644
--- a/libweave/src/device_registration_info.cc
+++ b/libweave/src/device_registration_info.cc
@@ -827,8 +827,9 @@
     ErrorPtr* error) {
   Config::Transaction change(config_.get());
   if (!change.set_local_anonymous_access_role(anonymous_access_role)) {
-    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, "invalid_parameter",
-                       "Invalid role: %s", anonymous_access_role.c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::kErrorDomain,
+                       "invalid_parameter", "Invalid role: %s",
+                       anonymous_access_role.c_str());
     return false;
   }
 
@@ -846,7 +847,7 @@
     const std::string& service_url,
     ErrorPtr* error) {
   if (HaveRegistrationCredentials()) {
-    Error::AddTo(error, FROM_HERE, kErrorDomain, "already_registered",
+    Error::AddTo(error, FROM_HERE, errors::kErrorDomain, "already_registered",
                  "Unable to change config for registered device");
     return false;
   }
diff --git a/libweave/src/states/state_manager.cc b/libweave/src/states/state_manager.cc
index 455b563..9d78178 100644
--- a/libweave/src/states/state_manager.cc
+++ b/libweave/src/states/state_manager.cc
@@ -4,10 +4,9 @@
 
 #include "libweave/src/states/state_manager.h"
 
-#include <base/files/file_enumerator.h>
-#include <base/files/file_path.h>
 #include <base/logging.h>
 #include <base/values.h>
+#include <weave/config_store.h>
 
 #include "libweave/src/json_error_codes.h"
 #include "libweave/src/states/error_codes.h"
@@ -29,47 +28,22 @@
   callback.Run();  // Force to read current state.
 }
 
-void StateManager::Startup() {
+void StateManager::Startup(ConfigStore* config_store) {
   LOG(INFO) << "Initializing StateManager.";
 
   // Load standard device state definition.
-  base::FilePath base_state_file("/etc/buffet/base_state.schema.json");
-  LOG(INFO) << "Loading standard state definition from "
-            << base_state_file.value();
-  CHECK(LoadBaseStateDefinition(base_state_file, nullptr))
-      << "Failed to load the standard state definition file.";
+  CHECK(LoadBaseStateDefinition(config_store->LoadBaseStateDefs(), nullptr));
 
   // Load component-specific device state definitions.
-  base::FilePath device_state_dir("/etc/buffet/states");
-  base::FileEnumerator enumerator(device_state_dir, false,
-                                  base::FileEnumerator::FILES,
-                                  FILE_PATH_LITERAL("*.schema.json"));
-  base::FilePath json_file_path = enumerator.Next();
-  while (!json_file_path.empty()) {
-    LOG(INFO) << "Loading state definition from " << json_file_path.value();
-    CHECK(LoadStateDefinition(json_file_path, nullptr))
-        << "Failed to load the state definition file.";
-    json_file_path = enumerator.Next();
-  }
+  for (const auto& pair : config_store->LoadStateDefs())
+    CHECK(LoadStateDefinition(pair.first, pair.second, nullptr));
 
   // Load standard device state defaults.
-  base::FilePath base_state_defaults("/etc/buffet/base_state.defaults.json");
-  LOG(INFO) << "Loading base state defaults from "
-            << base_state_defaults.value();
-  CHECK(LoadStateDefaults(base_state_defaults, nullptr))
-      << "Failed to load the base state defaults.";
+  CHECK(LoadStateDefaults(config_store->LoadBaseStateDefaults(), nullptr));
 
   // Load component-specific device state defaults.
-  base::FileEnumerator enumerator2(device_state_dir, false,
-                                   base::FileEnumerator::FILES,
-                                   FILE_PATH_LITERAL("*.defaults.json"));
-  json_file_path = enumerator2.Next();
-  while (!json_file_path.empty()) {
-    LOG(INFO) << "Loading state defaults from " << json_file_path.value();
-    CHECK(LoadStateDefaults(json_file_path, nullptr))
-        << "Failed to load the state defaults.";
-    json_file_path = enumerator2.Next();
-  }
+  for (const auto& json : config_store->LoadStateDefaults())
+    CHECK(LoadStateDefaults(json, nullptr));
 
   for (const auto& cb : on_changed_)
     cb.Run();
@@ -151,15 +125,15 @@
   state_change_queue_->NotifyStateUpdatedOnServer(id);
 }
 
-bool StateManager::LoadStateDefinition(const base::DictionaryValue& json,
+bool StateManager::LoadStateDefinition(const base::DictionaryValue& dict,
                                        const std::string& category,
                                        ErrorPtr* error) {
-  base::DictionaryValue::Iterator iter(json);
+  base::DictionaryValue::Iterator iter(dict);
   while (!iter.IsAtEnd()) {
     std::string package_name = iter.key();
     if (package_name.empty()) {
-      Error::AddTo(error, FROM_HERE, kErrorDomain, kInvalidPackageError,
-                   "State package name is empty");
+      Error::AddTo(error, FROM_HERE, errors::kErrorDomain,
+                   errors::kInvalidPackageError, "State package name is empty");
       return false;
     }
     const base::DictionaryValue* package_dict = nullptr;
@@ -182,52 +156,50 @@
   return true;
 }
 
-bool StateManager::LoadStateDefinition(const base::FilePath& json_file_path,
+bool StateManager::LoadStateDefinition(const std::string& json,
+                                       const std::string& category,
                                        ErrorPtr* error) {
-  std::unique_ptr<const base::DictionaryValue> json =
-      LoadJsonDict(json_file_path, error);
-  if (!json)
+  std::unique_ptr<const base::DictionaryValue> dict = LoadJsonDict(json, error);
+  if (!dict)
     return false;
-  std::string category = json_file_path.BaseName().RemoveExtension().value();
   if (category == kDefaultCategory) {
-    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kInvalidCategoryError,
-                       "Invalid state category specified in '%s'",
-                       json_file_path.value().c_str());
+    Error::AddToPrintf(error, FROM_HERE, errors::kErrorDomain,
+                       errors::kInvalidCategoryError,
+                       "Invalid state category: '%s'", category.c_str());
     return false;
   }
 
-  if (!LoadStateDefinition(*json, category, error)) {
-    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
-                       "Failed to load file '%s'",
-                       json_file_path.value().c_str());
+  if (!LoadStateDefinition(*dict, category, error)) {
+    Error::AddToPrintf(error, FROM_HERE, errors::kErrorDomain,
+                       errors::kSchemaError,
+                       "Failed to load state definition: '%s'", json.c_str());
     return false;
   }
   return true;
 }
 
-bool StateManager::LoadBaseStateDefinition(const base::FilePath& json_file_path,
+bool StateManager::LoadBaseStateDefinition(const std::string& json,
                                            ErrorPtr* error) {
-  std::unique_ptr<const base::DictionaryValue> json =
-      LoadJsonDict(json_file_path, error);
-  if (!json)
+  std::unique_ptr<const base::DictionaryValue> dict = LoadJsonDict(json, error);
+  if (!dict)
     return false;
-  if (!LoadStateDefinition(*json, kDefaultCategory, error)) {
-    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
-                       "Failed to load file '%s'",
-                       json_file_path.value().c_str());
+  if (!LoadStateDefinition(*dict, kDefaultCategory, error)) {
+    Error::AddToPrintf(
+        error, FROM_HERE, errors::kErrorDomain, errors::kSchemaError,
+        "Failed to load base state definition: '%s'", json.c_str());
     return false;
   }
   return true;
 }
 
-bool StateManager::LoadStateDefaults(const base::DictionaryValue& json,
+bool StateManager::LoadStateDefaults(const base::DictionaryValue& dict,
                                      ErrorPtr* error) {
-  base::DictionaryValue::Iterator iter(json);
+  base::DictionaryValue::Iterator iter(dict);
   while (!iter.IsAtEnd()) {
     std::string package_name = iter.key();
     if (package_name.empty()) {
-      Error::AddTo(error, FROM_HERE, kErrorDomain, kInvalidPackageError,
-                   "State package name is empty");
+      Error::AddTo(error, FROM_HERE, errors::kErrorDomain,
+                   errors::kInvalidPackageError, "State package name is empty");
       return false;
     }
     const base::DictionaryValue* package_dict = nullptr;
@@ -253,16 +225,14 @@
   return true;
 }
 
-bool StateManager::LoadStateDefaults(const base::FilePath& json_file_path,
-                                     ErrorPtr* error) {
-  std::unique_ptr<const base::DictionaryValue> json =
-      LoadJsonDict(json_file_path, error);
-  if (!json)
+bool StateManager::LoadStateDefaults(const std::string& json, ErrorPtr* error) {
+  std::unique_ptr<const base::DictionaryValue> dict = LoadJsonDict(json, error);
+  if (!dict)
     return false;
-  if (!LoadStateDefaults(*json, error)) {
-    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
-                       "Failed to load file '%s'",
-                       json_file_path.value().c_str());
+  if (!LoadStateDefaults(*dict, error)) {
+    Error::AddToPrintf(error, FROM_HERE, errors::kErrorDomain,
+                       errors::kSchemaError, "Failed to load defaults: '%s'",
+                       json.c_str());
     return false;
   }
   return true;
diff --git a/libweave/src/states/state_manager.h b/libweave/src/states/state_manager.h
index 1668bb2..59c7716 100644
--- a/libweave/src/states/state_manager.h
+++ b/libweave/src/states/state_manager.h
@@ -22,12 +22,13 @@
 
 namespace base {
 class DictionaryValue;
-class FilePath;
 class Time;
 }  // namespace base
 
 namespace weave {
 
+class ConfigStore;
+
 // StateManager is the class that aggregates the device state fragments
 // provided by device daemons and makes the aggregate device state available
 // to the GCD cloud server and local clients.
@@ -44,7 +45,7 @@
 
   // Initializes the state manager and load device state fragments.
   // Called by Buffet daemon at startup.
-  void Startup();
+  void Startup(ConfigStore* config_store);
 
   // Returns all the categories the state properties are registered from.
   // As with GCD command handling, the category normally represent a device
@@ -78,26 +79,25 @@
   // Loads a device state fragment from a JSON object. |category| represents
   // a device daemon providing the state fragment or empty string for the
   // base state fragment.
-  bool LoadStateDefinition(const base::DictionaryValue& json,
+  bool LoadStateDefinition(const base::DictionaryValue& dict,
                            const std::string& category,
                            ErrorPtr* error);
 
-  // Loads a device state fragment JSON file. The file name (without extension)
-  // is used as the state fragment category.
-  bool LoadStateDefinition(const base::FilePath& json_file_path,
+  // Loads a device state fragment JSON.
+  bool LoadStateDefinition(const std::string& json,
+                           const std::string& category,
                            ErrorPtr* error);
 
-  // Loads the base device state fragment JSON file. This state fragment
+  // Loads the base device state fragment JSON. This state fragment
   // defines the standard state properties from the 'base' package as defined
   // by GCD specification.
-  bool LoadBaseStateDefinition(const base::FilePath& json_file_path,
-                               ErrorPtr* error);
+  bool LoadBaseStateDefinition(const std::string& json, ErrorPtr* error);
 
   // Loads state default values from JSON object.
-  bool LoadStateDefaults(const base::DictionaryValue& json, ErrorPtr* error);
+  bool LoadStateDefaults(const base::DictionaryValue& dict, ErrorPtr* error);
 
-  // Loads state default values from JSON file.
-  bool LoadStateDefaults(const base::FilePath& json_file_path, ErrorPtr* error);
+  // Loads state default values from JSON.
+  bool LoadStateDefaults(const std::string& json, ErrorPtr* error);
 
   // Finds a package by its name. Returns nullptr if not found.
   StatePackage* FindPackage(const std::string& package_name);
diff --git a/libweave/src/utils.cc b/libweave/src/utils.cc
index dd62f88..317eb5d 100644
--- a/libweave/src/utils.cc
+++ b/libweave/src/utils.cc
@@ -5,7 +5,6 @@
 #include "libweave/src/utils.h"
 
 #include <base/bind_helpers.h>
-#include <base/files/file_util.h>
 #include <base/json/json_reader.h>
 
 #include "libweave/src/json_error_codes.h"
@@ -26,23 +25,12 @@
 
 }  // anonymous namespace
 
+namespace errors {
 const char kErrorDomain[] = "weave";
-const char kFileReadError[] = "file_read_error";
+const char kSchemaError[] = "schema_error";
 const char kInvalidCategoryError[] = "invalid_category";
 const char kInvalidPackageError[] = "invalid_package";
-
-std::unique_ptr<base::DictionaryValue> LoadJsonDict(
-    const base::FilePath& json_file_path,
-    ErrorPtr* error) {
-  std::string json_string;
-  if (!base::ReadFileToString(json_file_path, &json_string)) {
-    Error::AddToPrintf(error, FROM_HERE, kErrorDomain, kFileReadError,
-                       "Failed to read file '%s'",
-                       json_file_path.value().c_str());
-    return {};
-  }
-  return LoadJsonDict(json_string, error);
-}
+}  // namespace errors
 
 std::unique_ptr<base::DictionaryValue> LoadJsonDict(
     const std::string& json_string,
diff --git a/libweave/src/utils.h b/libweave/src/utils.h
index 7ef4fa1..29ea138 100644
--- a/libweave/src/utils.h
+++ b/libweave/src/utils.h
@@ -9,30 +9,22 @@
 #include <string>
 
 #include <base/values.h>
-#include <base/files/file_path.h>
 #include <weave/error.h>
 
 namespace weave {
 
-// TODO(avakulenko): This should be consolidated into errors::<domain> namespace
-// See crbug.com/417274
+namespace errors {
 extern const char kErrorDomain[];
-extern const char kFileReadError[];
+extern const char kSchemaError[];
 extern const char kInvalidCategoryError[];
 extern const char kInvalidPackageError[];
+}  // namespace errors
 
 // kDefaultCategory represents a default state property category for standard
 // properties from "base" package which are provided by buffet and not any of
 // the daemons running on the device.
 const char kDefaultCategory[] = "";
 
-// Helper function to load a JSON file that is expected to be
-// an object/dictionary. In case of error, returns empty unique ptr and fills
-// in error details in |error|.
-std::unique_ptr<base::DictionaryValue> LoadJsonDict(
-    const base::FilePath& json_file_path,
-    ErrorPtr* error);
-
 // Helper function to load a JSON dictionary from a string.
 std::unique_ptr<base::DictionaryValue> LoadJsonDict(
     const std::string& json_string,