Remove category from Commands definitions BUG:24267885 Change-Id: If60064eaf7620a32156edf572d8ce887f9abad04 Reviewed-on: https://weave-review.googlesource.com/1234 Reviewed-by: Vitaly Buka <vitalybuka@google.com>

diff --git a/libweave/examples/ubuntu/file_config_store.cc b/libweave/examples/ubuntu/file_config_store.cc
index d28f817..d3b3b43 100644
--- a/libweave/examples/ubuntu/file_config_store.cc
+++ b/libweave/examples/ubuntu/file_config_store.cc

@@ -60,8 +60,8 @@
   str << settings;
 }
 
-std::map<std::string, std::string> FileConfigStore::LoadCommandDefs() {
-  return {{kCategory, R"({
+std::vector<std::string> FileConfigStore::LoadCommandDefs() {
+  return {R"({
     "base": {
       "updateBaseConfiguration": {},
       "identify": {},
@@ -74,7 +74,7 @@
         "results": { "_greeting": "string" }
       }
     }
-  })"}};
+  })"};
 }
 
 std::vector<std::string> FileConfigStore::LoadStateDefs() {

diff --git a/libweave/examples/ubuntu/file_config_store.h b/libweave/examples/ubuntu/file_config_store.h
index 53e56f1..926576f 100644
--- a/libweave/examples/ubuntu/file_config_store.h
+++ b/libweave/examples/ubuntu/file_config_store.h

@@ -21,7 +21,7 @@
   bool LoadDefaults(Settings* settings) override;
   std::string LoadSettings() override;
   void SaveSettings(const std::string& settings) override;
-  std::map<std::string, std::string> LoadCommandDefs() override;
+  std::vector<std::string> LoadCommandDefs() override;
   std::vector<std::string> LoadStateDefs() override;
   std::vector<std::string> LoadStateDefaults() override;
 

diff --git a/libweave/include/weave/command.h b/libweave/include/weave/command.h
index e3d35a7..911da1e 100644
--- a/libweave/include/weave/command.h
+++ b/libweave/include/weave/command.h

@@ -52,9 +52,6 @@
   // Returns the full name of the command.
   virtual const std::string& GetName() const = 0;
 
-  // Returns the command category.
-  virtual const std::string& GetCategory() const = 0;
-
   // Returns the command status.
   virtual CommandStatus GetStatus() const = 0;
 

diff --git a/libweave/include/weave/provider/config_store.h b/libweave/include/weave/provider/config_store.h
index 64975a7..aa7c5e5 100644
--- a/libweave/include/weave/provider/config_store.h
+++ b/libweave/include/weave/provider/config_store.h

@@ -35,11 +35,8 @@
   // recommended to protect data, e.g. using encryption.
   virtual void SaveSettings(const std::string& settings) = 0;
 
-  // Returns command definitions as JSON.
-  // Key is unique string which will be used to assign single command handler
-  // later.
-  // Value is JSON with command definition.
-  virtual std::map<std::string, std::string> LoadCommandDefs() = 0;
+  // Returns command definitions as array of JSONs.
+  virtual std::vector<std::string> LoadCommandDefs() = 0;
 
   // Returns device state definitions as array of JSONs.
   virtual std::vector<std::string> LoadStateDefs() = 0;

diff --git a/libweave/include/weave/provider/test/mock_config_store.h b/libweave/include/weave/provider/test/mock_config_store.h
index 30027f3..6eab802 100644
--- a/libweave/include/weave/provider/test/mock_config_store.h
+++ b/libweave/include/weave/provider/test/mock_config_store.h

@@ -42,7 +42,7 @@
   MOCK_METHOD0(LoadSettings, std::string());
   MOCK_METHOD1(SaveSettings, void(const std::string&));
 
-  MOCK_METHOD0(LoadCommandDefs, std::map<std::string, std::string>());
+  MOCK_METHOD0(LoadCommandDefs, std::vector<std::string>());
   MOCK_METHOD0(LoadStateDefs, std::vector<std::string>());
   MOCK_METHOD0(LoadStateDefaults, std::vector<std::string>());
 };

diff --git a/libweave/src/base_api_handler_unittest.cc b/libweave/src/base_api_handler_unittest.cc
index 25a07f6..a583dc3 100644
--- a/libweave/src/base_api_handler_unittest.cc
+++ b/libweave/src/base_api_handler_unittest.cc

@@ -68,7 +68,7 @@
   void LoadCommands(const std::string& command_definitions) {
     auto json = test::CreateDictionaryValue(command_definitions.c_str());
     EXPECT_TRUE(command_manager_->LoadBaseCommands(*json, nullptr));
-    EXPECT_TRUE(command_manager_->LoadCommands(*json, "", nullptr));
+    EXPECT_TRUE(command_manager_->LoadCommands(*json, nullptr));
   }
 
   void AddCommand(const std::string& command) {

diff --git a/libweave/src/commands/cloud_command_proxy_unittest.cc b/libweave/src/commands/cloud_command_proxy_unittest.cc
index b462439..e1d96b0 100644
--- a/libweave/src/commands/cloud_command_proxy_unittest.cc
+++ b/libweave/src/commands/cloud_command_proxy_unittest.cc

@@ -94,7 +94,7 @@
       }
     })");
     CHECK(json.get());
-    CHECK(command_dictionary_.LoadCommands(*json, "calcd", nullptr, nullptr))
+    CHECK(command_dictionary_.LoadCommands(*json, nullptr, nullptr))
         << "Failed to parse test command dictionary";
 
     CreateCommandInstance();

diff --git a/libweave/src/commands/command_definition.cc b/libweave/src/commands/command_definition.cc
index 1deb594..21e186a 100644
--- a/libweave/src/commands/command_definition.cc
+++ b/libweave/src/commands/command_definition.cc

@@ -71,12 +71,10 @@
 }
 
 CommandDefinition::CommandDefinition(
-    const std::string& category,
     std::unique_ptr<const ObjectSchema> parameters,
     std::unique_ptr<const ObjectSchema> progress,
     std::unique_ptr<const ObjectSchema> results)
-    : category_{category},
-      parameters_{std::move(parameters)},
+    : parameters_{std::move(parameters)},
       progress_{std::move(progress)},
       results_{std::move(results)} {
   // Set to be available to all clients by default.

diff --git a/libweave/src/commands/command_definition.h b/libweave/src/commands/command_definition.h
index a6a17f8..305e8f5 100644
--- a/libweave/src/commands/command_definition.h
+++ b/libweave/src/commands/command_definition.h

@@ -22,11 +22,8 @@
   kOwner,
 };
 
-// A simple GCD command definition. This class contains the command category
-// and a full object schema describing the command parameter types and
-// constraints. See comments for CommandDefinitions::LoadCommands for the
-// detailed description of what command categories are and what they are used
-// for.
+// A simple GCD command definition. This class contains the full object schema
+// describing the command parameter types and constraints.
 class CommandDefinition final {
  public:
   struct Visibility {
@@ -52,13 +49,10 @@
     bool cloud{false};  // Command is available to cloud clients.
   };
 
-  CommandDefinition(const std::string& category,
-                    std::unique_ptr<const ObjectSchema> parameters,
+  CommandDefinition(std::unique_ptr<const ObjectSchema> parameters,
                     std::unique_ptr<const ObjectSchema> progress,
                     std::unique_ptr<const ObjectSchema> results);
 
-  // Gets the category this command belongs to.
-  const std::string& GetCategory() const { return category_; }
   // Gets the object schema for command parameters.
   const ObjectSchema* GetParameters() const { return parameters_.get(); }
   // Gets the object schema for command progress.
@@ -75,7 +69,6 @@
   void SetMinimalRole(UserRole minimal_role) { minimal_role_ = minimal_role; }
 
  private:
-  std::string category_;  // Cmd category. Could be "powerd" for "base.reboot".
   std::unique_ptr<const ObjectSchema> parameters_;  // Command parameters def.
   std::unique_ptr<const ObjectSchema> progress_;    // Command progress def.
   std::unique_ptr<const ObjectSchema> results_;     // Command results def.

diff --git a/libweave/src/commands/command_definition_unittest.cc b/libweave/src/commands/command_definition_unittest.cc
index f3e5de8..dda2385 100644
--- a/libweave/src/commands/command_definition_unittest.cc
+++ b/libweave/src/commands/command_definition_unittest.cc

@@ -78,9 +78,8 @@
   const ObjectSchema* param_ptr = params.get();
   const ObjectSchema* progress_ptr = progress.get();
   const ObjectSchema* results_ptr = results.get();
-  CommandDefinition def{"powerd", std::move(params), std::move(progress),
+  CommandDefinition def{std::move(params), std::move(progress),
                         std::move(results)};
-  EXPECT_EQ("powerd", def.GetCategory());
   EXPECT_EQ(param_ptr, def.GetParameters());
   EXPECT_EQ(progress_ptr, def.GetProgress());
   EXPECT_EQ(results_ptr, def.GetResults());

diff --git a/libweave/src/commands/command_dictionary.cc b/libweave/src/commands/command_dictionary.cc
index 0dcb441..f03e92d 100644
--- a/libweave/src/commands/command_dictionary.cc
+++ b/libweave/src/commands/command_dictionary.cc

@@ -13,18 +13,7 @@
 
 namespace weave {
 
-std::vector<std::string> CommandDictionary::GetCommandNamesByCategory(
-    const std::string& category) const {
-  std::vector<std::string> names;
-  for (const auto& pair : definitions_) {
-    if (pair.second->GetCategory() == category)
-      names.push_back(pair.first);
-  }
-  return names;
-}
-
 bool CommandDictionary::LoadCommands(const base::DictionaryValue& json,
-                                     const std::string& category,
                                      const CommandDictionary* base_commands,
                                      ErrorPtr* error) {
   CommandMap new_defs;
@@ -142,7 +131,7 @@
       }
 
       std::unique_ptr<CommandDefinition> command_def{new CommandDefinition{
-          category, std::move(parameters_schema), std::move(progress_schema),
+          std::move(parameters_schema), std::move(progress_schema),
           std::move(results_schema)}};
       command_def->SetVisibility(visibility);
       command_def->SetMinimalRole(minimal_role);
@@ -159,18 +148,11 @@
   // daemon on the same device.
   for (const auto& pair : new_defs) {
     auto iter = definitions_.find(pair.first);
-    CHECK(iter == definitions_.end())
-        << "Definition for command '" << pair.first
-        << "' overrides an earlier definition in category '"
-        << iter->second->GetCategory().c_str() << "'";
+    CHECK(iter == definitions_.end()) << "Definition for command '"
+                                      << pair.first
+                                      << "' overrides an earlier definition";
   }
 
-  // Now that we successfully loaded all the command definitions,
-  // remove previous definitions of commands from the same category.
-  std::vector<std::string> names = GetCommandNamesByCategory(category);
-  for (const std::string& name : names)
-    definitions_.erase(name);
-
   // Insert new definitions into the global map.
   for (auto& pair : new_defs)
     definitions_.emplace(pair.first, std::move(pair.second));

diff --git a/libweave/src/commands/command_dictionary.h b/libweave/src/commands/command_dictionary.h
index f0f3bbd..389d419 100644
--- a/libweave/src/commands/command_dictionary.h
+++ b/libweave/src/commands/command_dictionary.h

@@ -34,27 +34,14 @@
  public:
   CommandDictionary() = default;
 
-  // Gets the list of names of commands that belong to the given category.
-  std::vector<std::string> GetCommandNamesByCategory(
-      const std::string& category) const;
-
   // Loads command definitions from a JSON object. This is done at the daemon
   // startup and whenever a device daemon decides to update its command list.
-  // |json| is a JSON dictionary that describes the complete commands contained
-  // in a particular |category|. Usually, |categories| are 1:1 with daemons on
-  // a device. For instance, the power manager daemon might provide a category
-  // "power_man" that provides the "base.reboot" and "base.shutdown" commands.
-  // However, nothing prohibits a daemon providing commands in two categories.
-  // When LoadCommands is called, all previous definitions of commands from the
-  // same category are removed, effectively replacing all the commands in the
-  // given category.
-  // Optional |base_commands| parameter specifies the definition of standard
-  // GCD commands for parameter schema validation. Can be set to nullptr if
-  // no validation is needed.
-  // Returns false on failure and |error| provides additional error information
-  // when provided.
+  // |json| is a JSON dictionary that describes the complete commands. Optional
+  // |base_commands| parameter specifies the definition of standard GCD commands
+  // for parameter schema validation. Can be set to nullptr if no validation is
+  // needed. Returns false on failure and |error| provides additional error
+  // information when provided.
   bool LoadCommands(const base::DictionaryValue& json,
-                    const std::string& category,
                     const CommandDictionary* base_commands,
                     ErrorPtr* error);
   // Converts all the command definitions to a JSON object for CDD/Device

diff --git a/libweave/src/commands/command_dictionary_unittest.cc b/libweave/src/commands/command_dictionary_unittest.cc
index ac9e261..531a561 100644
--- a/libweave/src/commands/command_dictionary_unittest.cc
+++ b/libweave/src/commands/command_dictionary_unittest.cc

@@ -17,7 +17,6 @@
   CommandDictionary dict;
   EXPECT_TRUE(dict.IsEmpty());
   EXPECT_EQ(nullptr, dict.FindCommand("robot.jump"));
-  EXPECT_TRUE(dict.GetCommandNamesByCategory("robotd").empty());
 }
 
 TEST(CommandDictionary, LoadCommands) {
@@ -36,7 +35,7 @@
     }
   })");
   CommandDictionary dict;
-  EXPECT_TRUE(dict.LoadCommands(*json, "robotd", nullptr, nullptr));
+  EXPECT_TRUE(dict.LoadCommands(*json, nullptr, nullptr));
   EXPECT_EQ(1, dict.GetSize());
   EXPECT_NE(nullptr, dict.FindCommand("robot.jump"));
   json = CreateDictionaryValue(R"({
@@ -48,14 +47,12 @@
       }
     }
   })");
-  EXPECT_TRUE(dict.LoadCommands(*json, "powerd", nullptr, nullptr));
+  EXPECT_TRUE(dict.LoadCommands(*json, nullptr, nullptr));
   EXPECT_EQ(3, dict.GetSize());
   EXPECT_NE(nullptr, dict.FindCommand("robot.jump"));
   EXPECT_NE(nullptr, dict.FindCommand("base.reboot"));
   EXPECT_NE(nullptr, dict.FindCommand("base.shutdown"));
   EXPECT_EQ(nullptr, dict.FindCommand("foo.bar"));
-  std::vector<std::string> expected_commands{"base.reboot", "base.shutdown"};
-  EXPECT_EQ(expected_commands, dict.GetCommandNamesByCategory("powerd"));
 }
 
 TEST(CommandDictionary, LoadWithInheritance) {
@@ -77,12 +74,12 @@
     }
   })");
   CommandDictionary base_dict;
-  EXPECT_TRUE(base_dict.LoadCommands(*json, "test1", nullptr, nullptr));
+  EXPECT_TRUE(base_dict.LoadCommands(*json, nullptr, nullptr));
   EXPECT_EQ(1, base_dict.GetSize());
   json = CreateDictionaryValue(R"({'robot': {'jump': {}}})");
 
   CommandDictionary dict;
-  EXPECT_TRUE(dict.LoadCommands(*json, "test2", &base_dict, nullptr));
+  EXPECT_TRUE(dict.LoadCommands(*json, &base_dict, nullptr));
   EXPECT_EQ(1, dict.GetSize());
 
   auto cmd = dict.FindCommand("robot.jump");
@@ -105,27 +102,27 @@
 
   // Command definition is not an object.
   auto json = CreateDictionaryValue("{'robot':{'jump':0}}");
-  EXPECT_FALSE(dict.LoadCommands(*json, "robotd", nullptr, &error));
+  EXPECT_FALSE(dict.LoadCommands(*json, nullptr, &error));
   EXPECT_EQ("type_mismatch", error->GetCode());
   error.reset();
 
   // Package definition is not an object.
   json = CreateDictionaryValue("{'robot':'blah'}");
-  EXPECT_FALSE(dict.LoadCommands(*json, "robotd", nullptr, &error));
+  EXPECT_FALSE(dict.LoadCommands(*json, nullptr, &error));
   EXPECT_EQ("type_mismatch", error->GetCode());
   error.reset();
 
   // Invalid command definition is not an object.
   json = CreateDictionaryValue(
       "{'robot':{'jump':{'parameters':{'flip':0},'results':{}}}}");
-  EXPECT_FALSE(dict.LoadCommands(*json, "robotd", nullptr, &error));
+  EXPECT_FALSE(dict.LoadCommands(*json, nullptr, &error));
   EXPECT_EQ("invalid_object_schema", error->GetCode());
   EXPECT_NE(nullptr, error->GetInnerError());  // Must have additional info.
   error.reset();
 
   // Empty command name.
   json = CreateDictionaryValue("{'robot':{'':{'parameters':{},'results':{}}}}");
-  EXPECT_FALSE(dict.LoadCommands(*json, "robotd", nullptr, &error));
+  EXPECT_FALSE(dict.LoadCommands(*json, nullptr, &error));
   EXPECT_EQ("invalid_command_name", error->GetCode());
   error.reset();
 }
@@ -135,10 +132,10 @@
   CommandDictionary dict;
   ErrorPtr error;
   auto json = CreateDictionaryValue("{'robot':{'jump':{}}}");
-  dict.LoadCommands(*json, "category1", nullptr, &error);
-  ASSERT_DEATH(dict.LoadCommands(*json, "category2", nullptr, &error),
+  dict.LoadCommands(*json, nullptr, &error);
+  ASSERT_DEATH(dict.LoadCommands(*json, nullptr, &error),
                ".*Definition for command 'robot.jump' overrides an "
-               "earlier definition in category 'category1'");
+               "earlier definition");
 }
 
 TEST(CommandDictionary, LoadCommands_CustomCommandNaming) {
@@ -154,18 +151,18 @@
       }
     }
   })");
-  base_dict.LoadCommands(*json, "", nullptr, &error);
-  EXPECT_TRUE(dict.LoadCommands(*json, "robotd", &base_dict, &error));
+  base_dict.LoadCommands(*json, nullptr, &error);
+  EXPECT_TRUE(dict.LoadCommands(*json, &base_dict, &error));
   auto json2 =
       CreateDictionaryValue("{'base':{'jump':{'parameters':{},'results':{}}}}");
-  EXPECT_FALSE(dict.LoadCommands(*json2, "robotd", &base_dict, &error));
+  EXPECT_FALSE(dict.LoadCommands(*json2, &base_dict, &error));
   EXPECT_EQ("invalid_command_name", error->GetCode());
   error.reset();
 
   // If the command starts with "_", then it's Ok.
   json2 = CreateDictionaryValue(
       "{'base':{'_jump':{'parameters':{},'results':{}}}}");
-  EXPECT_TRUE(dict.LoadCommands(*json2, "robotd", &base_dict, nullptr));
+  EXPECT_TRUE(dict.LoadCommands(*json2, &base_dict, nullptr));
 }
 
 TEST(CommandDictionary, LoadCommands_RedefineStdCommand) {
@@ -181,7 +178,7 @@
       }
     }
   })");
-  base_dict.LoadCommands(*json, "", nullptr, &error);
+  base_dict.LoadCommands(*json, nullptr, &error);
 
   auto json2 = CreateDictionaryValue(R"({
     'base': {
@@ -191,7 +188,7 @@
       }
     }
   })");
-  EXPECT_FALSE(dict.LoadCommands(*json2, "robotd", &base_dict, &error));
+  EXPECT_FALSE(dict.LoadCommands(*json2, &base_dict, &error));
   EXPECT_EQ("invalid_object_schema", error->GetCode());
   EXPECT_EQ("invalid_parameter_definition", error->GetInnerError()->GetCode());
   EXPECT_EQ("param_type_changed", error->GetFirstError()->GetCode());
@@ -205,7 +202,7 @@
       }
     }
   })");
-  EXPECT_FALSE(dict.LoadCommands(*json3, "robotd", &base_dict, &error));
+  EXPECT_FALSE(dict.LoadCommands(*json3, &base_dict, &error));
   EXPECT_EQ("invalid_object_schema", error->GetCode());
   // TODO(antonm): remove parameter from error below and use some generic.
   EXPECT_EQ("invalid_parameter_definition", error->GetInnerError()->GetCode());
@@ -227,7 +224,7 @@
     }
   })");
   CommandDictionary base_dict;
-  base_dict.LoadCommands(*json_base, "base", nullptr, nullptr);
+  base_dict.LoadCommands(*json_base, nullptr, nullptr);
 
   auto json = CreateDictionaryValue(R"({
     'base': {
@@ -244,7 +241,7 @@
     }
   })");
   CommandDictionary dict;
-  dict.LoadCommands(*json, "device", &base_dict, nullptr);
+  dict.LoadCommands(*json, &base_dict, nullptr);
 
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return true; }, false, nullptr);
@@ -341,7 +338,7 @@
     }
   })");
   CommandDictionary dict;
-  ASSERT_TRUE(dict.LoadCommands(*json, "test", nullptr, nullptr));
+  ASSERT_TRUE(dict.LoadCommands(*json, nullptr, nullptr));
 
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return true; }, false, nullptr);
@@ -438,7 +435,7 @@
       }
     }
   })");
-  EXPECT_TRUE(base_dict.LoadCommands(*json, "testd", nullptr, nullptr));
+  EXPECT_TRUE(base_dict.LoadCommands(*json, nullptr, nullptr));
 
   auto cmd = base_dict.FindCommand("base.command1");
   ASSERT_NE(nullptr, cmd);
@@ -494,7 +491,7 @@
       }
     }
   })");
-  EXPECT_TRUE(dict.LoadCommands(*json, "testd", &base_dict, nullptr));
+  EXPECT_TRUE(dict.LoadCommands(*json, &base_dict, nullptr));
 
   cmd = dict.FindCommand("base.command1");
   ASSERT_NE(nullptr, cmd);
@@ -540,7 +537,7 @@
       }
     }
   })");
-  EXPECT_FALSE(dict.LoadCommands(*json, "testd", nullptr, &error));
+  EXPECT_FALSE(dict.LoadCommands(*json, nullptr, &error));
   EXPECT_EQ("invalid_command_visibility", error->GetCode());
   EXPECT_EQ("invalid_parameter_value", error->GetInnerError()->GetCode());
   error.reset();
@@ -560,7 +557,7 @@
       }
     }
   })");
-  EXPECT_FALSE(dict.LoadCommands(*json, "testd", nullptr, &error));
+  EXPECT_FALSE(dict.LoadCommands(*json, nullptr, &error));
   EXPECT_EQ("invalid_minimal_role", error->GetCode());
   EXPECT_EQ("invalid_parameter_value", error->GetInnerError()->GetCode());
   error.reset();

diff --git a/libweave/src/commands/command_instance.cc b/libweave/src/commands/command_instance.cc
index ea2c773..a8891f7 100644
--- a/libweave/src/commands/command_instance.cc
+++ b/libweave/src/commands/command_instance.cc

@@ -70,10 +70,6 @@
   return name_;
 }
 
-const std::string& CommandInstance::GetCategory() const {
-  return command_definition_->GetCategory();
-}
-
 CommandStatus CommandInstance::GetStatus() const {
   return status_;
 }

diff --git a/libweave/src/commands/command_instance.h b/libweave/src/commands/command_instance.h
index 0b82a81..8a54b05 100644
--- a/libweave/src/commands/command_instance.h
+++ b/libweave/src/commands/command_instance.h

@@ -46,7 +46,6 @@
   void RemoveObserver(Observer* observer) override;
   const std::string& GetID() const override;
   const std::string& GetName() const override;
-  const std::string& GetCategory() const override;
   CommandStatus GetStatus() const override;
   CommandOrigin GetOrigin() const override;
   std::unique_ptr<base::DictionaryValue> GetParameters() const override;

diff --git a/libweave/src/commands/command_instance_unittest.cc b/libweave/src/commands/command_instance_unittest.cc
index 811d9bb..865ba6e 100644
--- a/libweave/src/commands/command_instance_unittest.cc
+++ b/libweave/src/commands/command_instance_unittest.cc

@@ -61,7 +61,7 @@
         }
       }
     })");
-    CHECK(dict_.LoadCommands(*json, "robotd", nullptr, nullptr))
+    CHECK(dict_.LoadCommands(*json, nullptr, nullptr))
         << "Failed to parse test command dictionary";
   }
   CommandDictionary dict_;
@@ -84,7 +84,6 @@
 
   EXPECT_EQ("", instance.GetID());
   EXPECT_EQ("robot.speak", instance.GetName());
-  EXPECT_EQ("robotd", instance.GetCategory());
   EXPECT_EQ(CommandOrigin::kCloud, instance.GetOrigin());
   EXPECT_JSON_EQ("{'phrase': 'iPityDaFool', 'volume': 5}",
                  *instance.GetParameters());
@@ -122,7 +121,6 @@
   EXPECT_EQ("abcd", id);
   EXPECT_EQ("abcd", instance->GetID());
   EXPECT_EQ("robot.jump", instance->GetName());
-  EXPECT_EQ("robotd", instance->GetCategory());
   EXPECT_JSON_EQ("{'height': 53, '_jumpType': '_withKick'}",
                  *instance->GetParameters());
 }
@@ -132,7 +130,6 @@
   auto instance = CommandInstance::FromJson(json.get(), CommandOrigin::kCloud,
                                             dict_, nullptr, nullptr);
   EXPECT_EQ("base.reboot", instance->GetName());
-  EXPECT_EQ("robotd", instance->GetCategory());
   EXPECT_JSON_EQ("{}", *instance->GetParameters());
 }
 

diff --git a/libweave/src/commands/command_manager.cc b/libweave/src/commands/command_manager.cc
index bd7d02c..2add19e 100644
--- a/libweave/src/commands/command_manager.cc
+++ b/libweave/src/commands/command_manager.cc

@@ -66,7 +66,7 @@
 
 bool CommandManager::LoadBaseCommands(const base::DictionaryValue& dict,
                                       ErrorPtr* error) {
-  return base_dictionary_.LoadCommands(dict, "", nullptr, error);
+  return base_dictionary_.LoadCommands(dict, nullptr, error);
 }
 
 bool CommandManager::LoadBaseCommands(const std::string& json,
@@ -78,22 +78,19 @@
 }
 
 bool CommandManager::LoadCommands(const base::DictionaryValue& dict,
-                                  const std::string& category,
                                   ErrorPtr* error) {
-  bool result =
-      dictionary_.LoadCommands(dict, category, &base_dictionary_, error);
+  bool result = dictionary_.LoadCommands(dict, &base_dictionary_, error);
   for (const auto& cb : on_command_changed_)
     cb.Run();
   return result;
 }
 
 bool CommandManager::LoadCommands(const std::string& json,
-                                  const std::string& category,
                                   ErrorPtr* error) {
   std::unique_ptr<const base::DictionaryValue> dict = LoadJsonDict(json, error);
   if (!dict)
     return false;
-  return LoadCommands(*dict, category, error);
+  return LoadCommands(*dict, error);
 }
 
 void CommandManager::Startup(provider::ConfigStore* config_store) {
@@ -104,7 +101,7 @@
 
   // Loading the rest of commands.
   for (const auto& defs : config_store->LoadCommandDefs())
-    CHECK(this->LoadCommands(defs.second, defs.first, nullptr));
+    CHECK(this->LoadCommands(defs, nullptr));
 }
 
 void CommandManager::AddCommand(

diff --git a/libweave/src/commands/command_manager.h b/libweave/src/commands/command_manager.h
index ea1392c..2485233 100644
--- a/libweave/src/commands/command_manager.h
+++ b/libweave/src/commands/command_manager.h

@@ -61,19 +61,13 @@
   // the base command definitions from.
   bool LoadBaseCommands(const std::string& json, ErrorPtr* error);
 
-  // Loads device command schema for particular category.
-  // See CommandDictionary::LoadCommands for detailed description of the
-  // parameters.
+  // Loads device command schema.
   bool LoadCommands(const base::DictionaryValue& dict,
-                    const std::string& category,
                     ErrorPtr* error);
 
   // Same as the overload above, but takes a path to a json file to read
-  // 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".
+  // the base command definitions from.
   bool LoadCommands(const std::string& json,
-                    const std::string& category,
                     ErrorPtr* error);
 
   // Startup method to be called by buffet daemon at startup.

diff --git a/libweave/src/commands/command_manager_unittest.cc b/libweave/src/commands/command_manager_unittest.cc
index 8d64650..ef77f4b 100644
--- a/libweave/src/commands/command_manager_unittest.cc
+++ b/libweave/src/commands/command_manager_unittest.cc

@@ -72,7 +72,7 @@
 TEST(CommandManager, LoadCommandsDict) {
   CommandManager manager;
   auto json = CreateDictionaryValue(kTestVendorCommands);
-  EXPECT_TRUE(manager.LoadCommands(*json, "category", nullptr));
+  EXPECT_TRUE(manager.LoadCommands(*json, nullptr));
 }
 
 TEST(CommandManager, LoadCommandsJson) {
@@ -107,7 +107,7 @@
       }
     }
   })";
-  EXPECT_TRUE(manager.LoadCommands(json_str, "test", nullptr));
+  EXPECT_TRUE(manager.LoadCommands(json_str, nullptr));
   EXPECT_EQ(2, manager.GetCommandDictionary().GetSize());
   EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("base.reboot"));
   EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("robot._jump"));
@@ -117,8 +117,8 @@
   CommandManager manager;
   provider::test::MockConfigStore config_store;
   EXPECT_CALL(config_store, LoadCommandDefs())
-      .WillOnce(Return(std::map<std::string, std::string>{
-          {"category", kTestVendorCommands}, {"test", kTestTestCommands}}));
+      .WillOnce(Return(
+          std::vector<std::string>{kTestVendorCommands, kTestTestCommands}));
   manager.Startup(&config_store);
   EXPECT_EQ(3, manager.GetCommandDictionary().GetSize());
   EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("robot._jump"));
@@ -152,7 +152,7 @@
       }
     }
   })");
-  ASSERT_TRUE(manager.LoadCommands(*json, "test", nullptr));
+  ASSERT_TRUE(manager.LoadCommands(*json, nullptr));
   EXPECT_EQ(2, update_count);
   const CommandDictionary& dict = manager.GetCommandDictionary();
   EXPECT_TRUE(manager.SetCommandVisibility(

diff --git a/libweave/src/commands/command_queue_unittest.cc b/libweave/src/commands/command_queue_unittest.cc
index f88a74e..dc02d9c 100644
--- a/libweave/src/commands/command_queue_unittest.cc
+++ b/libweave/src/commands/command_queue_unittest.cc

@@ -39,9 +39,8 @@
   CommandQueue queue_;
 
  private:
-  CommandDefinition command_definition_{"powerd", ObjectSchema::Create(),
-                                        ObjectSchema::Create(),
-                                        ObjectSchema::Create()};
+  CommandDefinition command_definition_{
+      ObjectSchema::Create(), ObjectSchema::Create(), ObjectSchema::Create()};
 };
 
 // Keeps track of commands being added to and removed from the queue_.

diff --git a/libweave/src/device_registration_info_unittest.cc b/libweave/src/device_registration_info_unittest.cc
index 34ea31a..f5c53fa 100644
--- a/libweave/src/device_registration_info_unittest.cc
+++ b/libweave/src/device_registration_info_unittest.cc

@@ -367,7 +367,7 @@
       }
     }
   })");
-  EXPECT_TRUE(command_manager_->LoadCommands(*json_cmds, "", nullptr));
+  EXPECT_TRUE(command_manager_->LoadCommands(*json_cmds, nullptr));
 
   std::string ticket_url = dev_reg_->GetServiceURL("registrationTickets/") +
                            test_data::kClaimTicketId;
@@ -516,7 +516,7 @@
       }
     }
   })");
-  EXPECT_TRUE(command_manager_->LoadCommands(*json_cmds, "", nullptr));
+  EXPECT_TRUE(command_manager_->LoadCommands(*json_cmds, nullptr));
 
   const std::string command_url = dev_reg_->GetServiceURL("commands/1234");
 

diff --git a/libweave/src/weave_unittest.cc b/libweave/src/weave_unittest.cc
index e731803..9ab0a2a 100644
--- a/libweave/src/weave_unittest.cc
+++ b/libweave/src/weave_unittest.cc

@@ -161,14 +161,13 @@
     EXPECT_CALL(config_store_, SaveSettings("")).WillRepeatedly(Return());
 
     EXPECT_CALL(config_store_, LoadCommandDefs())
-        .WillOnce(Return(
-            std::map<std::string, std::string>{{kCategory, kCommandDefs}}));
+        .WillOnce(Return(std::vector<std::string>{kCommandDefs}));
 
     EXPECT_CALL(config_store_, LoadStateDefs())
-        .WillOnce(Return(std::vector<std::string>{{kStateDefs}}));
+        .WillOnce(Return(std::vector<std::string>{kStateDefs}));
 
     EXPECT_CALL(config_store_, LoadStateDefaults())
-        .WillOnce(Return(std::vector<std::string>{{kStateDefaults}}));
+        .WillOnce(Return(std::vector<std::string>{kStateDefaults}));
   }
 
   void InitNetwork() {