diff --git a/buffet/commands/command_definition_unittest.cc b/buffet/commands/command_definition_unittest.cc
index 171164d..e422324 100644
--- a/buffet/commands/command_definition_unittest.cc
+++ b/buffet/commands/command_definition_unittest.cc
@@ -6,8 +6,7 @@
 
 #include <gtest/gtest.h>
 
-using buffet::ObjectSchema;
-using buffet::CommandDefinition;
+namespace buffet {
 
 TEST(CommandVisibility, DefaultConstructor) {
   CommandDefinition::Visibility visibility;
@@ -91,3 +90,5 @@
   def.SetVisibility(CommandDefinition::Visibility::GetLocal());
   EXPECT_EQ("local", def.GetVisibility().ToString());
 }
+
+}  // namespace buffet
diff --git a/buffet/commands/command_dictionary_unittest.cc b/buffet/commands/command_dictionary_unittest.cc
index 914bdd3..6a2c8d7 100644
--- a/buffet/commands/command_dictionary_unittest.cc
+++ b/buffet/commands/command_dictionary_unittest.cc
@@ -8,10 +8,12 @@
 
 #include "buffet/commands/unittest_utils.h"
 
-using buffet::unittests::CreateDictionaryValue;
+namespace buffet {
+
+using unittests::CreateDictionaryValue;
 
 TEST(CommandDictionary, Empty) {
-  buffet::CommandDictionary dict;
+  CommandDictionary dict;
   EXPECT_TRUE(dict.IsEmpty());
   EXPECT_EQ(nullptr, dict.FindCommand("robot.jump"));
   EXPECT_TRUE(dict.GetCommandNamesByCategory("robotd").empty());
@@ -32,7 +34,7 @@
       }
     }
   })");
-  buffet::CommandDictionary dict;
+  CommandDictionary dict;
   EXPECT_TRUE(dict.LoadCommands(*json, "robotd", nullptr, nullptr));
   EXPECT_EQ(1, dict.GetSize());
   EXPECT_NE(nullptr, dict.FindCommand("robot.jump"));
@@ -56,7 +58,7 @@
 }
 
 TEST(CommandDictionary, LoadCommands_Failures) {
-  buffet::CommandDictionary dict;
+  CommandDictionary dict;
   chromeos::ErrorPtr error;
 
   // Command definition is not an object.
@@ -93,7 +95,7 @@
 
 TEST(CommandDictionaryDeathTest, LoadCommands_RedefineInDifferentCategory) {
   // Redefine commands in different category.
-  buffet::CommandDictionary dict;
+  CommandDictionary dict;
   chromeos::ErrorPtr error;
   auto json = CreateDictionaryValue("{'robot':{'jump':{}}}");
   dict.LoadCommands(*json, "category1", nullptr, &error);
@@ -104,8 +106,8 @@
 
 TEST(CommandDictionary, LoadCommands_CustomCommandNaming) {
   // Custom command must start with '_'.
-  buffet::CommandDictionary base_dict;
-  buffet::CommandDictionary dict;
+  CommandDictionary base_dict;
+  CommandDictionary dict;
   chromeos::ErrorPtr error;
   auto json = CreateDictionaryValue(R"({
     'base': {
@@ -133,8 +135,8 @@
 
 TEST(CommandDictionary, LoadCommands_RedefineStdCommand) {
   // Redefine commands parameter type.
-  buffet::CommandDictionary base_dict;
-  buffet::CommandDictionary dict;
+  CommandDictionary base_dict;
+  CommandDictionary dict;
   chromeos::ErrorPtr error;
   auto json = CreateDictionaryValue(R"({
     'base': {
@@ -201,10 +203,10 @@
       }
     }
   })");
-  buffet::CommandDictionary base_dict;
+  CommandDictionary base_dict;
   base_dict.LoadCommands(*json_base, "base", nullptr, nullptr);
 
-  auto json = buffet::unittests::CreateDictionaryValue(R"({
+  auto json = unittests::CreateDictionaryValue(R"({
     'base': {
       'reboot': {
         'parameters': {'delay': {'minimum': 10}},
@@ -218,28 +220,29 @@
       }
     }
   })");
-  buffet::CommandDictionary dict;
+  CommandDictionary dict;
   dict.LoadCommands(*json, "device", &base_dict, nullptr);
 
-  using buffet::CommandDefinition;
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return true; }, false, nullptr);
   EXPECT_NE(nullptr, json.get());
-  EXPECT_EQ("{'base':{'reboot':{'parameters':{'delay':{'minimum':10}}}},"
-            "'robot':{'_jump':{'parameters':{'_height':'integer'}}}}",
-            buffet::unittests::ValueToString(json.get()));
+  EXPECT_EQ(
+      "{'base':{'reboot':{'parameters':{'delay':{'minimum':10}}}},"
+      "'robot':{'_jump':{'parameters':{'_height':'integer'}}}}",
+      unittests::ValueToString(json.get()));
 
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return true; }, true, nullptr);
   EXPECT_NE(nullptr, json.get());
-  EXPECT_EQ("{'base':{'reboot':{'parameters':{'delay':{"
-            "'maximum':100,'minimum':10,'type':'integer'}}}},"
-            "'robot':{'_jump':{'parameters':{'_height':{'type':'integer'}}}}}",
-            buffet::unittests::ValueToString(json.get()));
+  EXPECT_EQ(
+      "{'base':{'reboot':{'parameters':{'delay':{"
+      "'maximum':100,'minimum':10,'type':'integer'}}}},"
+      "'robot':{'_jump':{'parameters':{'_height':{'type':'integer'}}}}}",
+      unittests::ValueToString(json.get()));
 }
 
 TEST(CommandDictionary, GetCommandsAsJsonWithVisibility) {
-  auto json = buffet::unittests::CreateDictionaryValue(R"({
+  auto json = unittests::CreateDictionaryValue(R"({
     'test': {
       'command1': {
         'parameters': {},
@@ -283,63 +286,66 @@
       }
     }
   })");
-  buffet::CommandDictionary dict;
+  CommandDictionary dict;
   ASSERT_TRUE(dict.LoadCommands(*json, "test", nullptr, nullptr));
 
-  using buffet::CommandDefinition;
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return true; }, false, nullptr);
   ASSERT_NE(nullptr, json.get());
-  EXPECT_EQ("{'test':{"
-            "'command1':{'parameters':{}},"
-            "'command2':{'parameters':{}},"
-            "'command3':{'parameters':{}},"
-            "'command4':{'parameters':{}},"
-            "'command5':{'parameters':{}},"
-            "'command6':{'parameters':{}},"
-            "'command7':{'parameters':{}},"
-            "'command8':{'parameters':{}}"
-            "}}",
-            buffet::unittests::ValueToString(json.get()));
+  EXPECT_EQ(
+      "{'test':{"
+      "'command1':{'parameters':{}},"
+      "'command2':{'parameters':{}},"
+      "'command3':{'parameters':{}},"
+      "'command4':{'parameters':{}},"
+      "'command5':{'parameters':{}},"
+      "'command6':{'parameters':{}},"
+      "'command7':{'parameters':{}},"
+      "'command8':{'parameters':{}}"
+      "}}",
+      unittests::ValueToString(json.get()));
 
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return def->GetVisibility().local; },
       false, nullptr);
   ASSERT_NE(nullptr, json.get());
-  EXPECT_EQ("{'test':{"
-            "'command2':{'parameters':{}},"
-            "'command4':{'parameters':{}},"
-            "'command6':{'parameters':{}},"
-            "'command8':{'parameters':{}}"
-            "}}",
-            buffet::unittests::ValueToString(json.get()));
+  EXPECT_EQ(
+      "{'test':{"
+      "'command2':{'parameters':{}},"
+      "'command4':{'parameters':{}},"
+      "'command6':{'parameters':{}},"
+      "'command8':{'parameters':{}}"
+      "}}",
+      unittests::ValueToString(json.get()));
 
   json = dict.GetCommandsAsJson(
       [](const CommandDefinition* def) { return def->GetVisibility().cloud; },
       false, nullptr);
   ASSERT_NE(nullptr, json.get());
-  EXPECT_EQ("{'test':{"
-            "'command3':{'parameters':{}},"
-            "'command4':{'parameters':{}},"
-            "'command7':{'parameters':{}},"
-            "'command8':{'parameters':{}}"
-            "}}",
-            buffet::unittests::ValueToString(json.get()));
+  EXPECT_EQ(
+      "{'test':{"
+      "'command3':{'parameters':{}},"
+      "'command4':{'parameters':{}},"
+      "'command7':{'parameters':{}},"
+      "'command8':{'parameters':{}}"
+      "}}",
+      unittests::ValueToString(json.get()));
 
   json = dict.GetCommandsAsJson(
     [](const CommandDefinition* def) {
       return def->GetVisibility().local && def->GetVisibility().cloud;
     }, false, nullptr);
   ASSERT_NE(nullptr, json.get());
-  EXPECT_EQ("{'test':{"
-            "'command4':{'parameters':{}},"
-            "'command8':{'parameters':{}}"
-            "}}",
-            buffet::unittests::ValueToString(json.get()));
+  EXPECT_EQ(
+      "{'test':{"
+      "'command4':{'parameters':{}},"
+      "'command8':{'parameters':{}}"
+      "}}",
+      unittests::ValueToString(json.get()));
 }
 
 TEST(CommandDictionary, LoadCommandsWithVisibility) {
-  buffet::CommandDictionary dict;
+  CommandDictionary dict;
   auto json = CreateDictionaryValue(R"({
     'base': {
       'command1': {
@@ -392,7 +398,7 @@
 }
 
 TEST(CommandDictionary, LoadCommandsWithVisibility_Inheritance) {
-  buffet::CommandDictionary base_dict;
+  CommandDictionary base_dict;
   auto json = CreateDictionaryValue(R"({
     'base': {
       'command1': {
@@ -424,7 +430,7 @@
   })");
   EXPECT_TRUE(base_dict.LoadCommands(*json, "testd", nullptr, nullptr));
 
-  buffet::CommandDictionary dict;
+  CommandDictionary dict;
   json = CreateDictionaryValue(R"({
     'base': {
       'command1': {
@@ -481,7 +487,7 @@
 }
 
 TEST(CommandDictionary, LoadCommandsWithVisibility_Failures) {
-  buffet::CommandDictionary dict;
+  CommandDictionary dict;
   chromeos::ErrorPtr error;
 
   auto json = CreateDictionaryValue(R"({
@@ -501,3 +507,5 @@
             error->GetInnerError()->GetMessage());
   error.reset();
 }
+
+}  // namespace buffet
diff --git a/buffet/commands/command_manager_unittest.cc b/buffet/commands/command_manager_unittest.cc
index 57e0d06..5b45cee 100644
--- a/buffet/commands/command_manager_unittest.cc
+++ b/buffet/commands/command_manager_unittest.cc
@@ -12,7 +12,9 @@
 
 #include "buffet/commands/unittest_utils.h"
 
-using buffet::unittests::CreateDictionaryValue;
+namespace buffet {
+
+using unittests::CreateDictionaryValue;
 
 namespace {
 
@@ -69,18 +71,18 @@
 }  // namespace
 
 TEST(CommandManager, Empty) {
-  buffet::CommandManager manager;
+  CommandManager manager;
   EXPECT_TRUE(manager.GetCommandDictionary().IsEmpty());
 }
 
 TEST(CommandManager, LoadBaseCommandsJSON) {
-  buffet::CommandManager manager;
+  CommandManager manager;
   auto json = CreateDictionaryValue(kTestBaseCommands);
   EXPECT_TRUE(manager.LoadBaseCommands(*json, nullptr));
 }
 
 TEST(CommandManager, LoadBaseCommandsFile) {
-  buffet::CommandManager manager;
+  CommandManager manager;
   auto json = CreateDictionaryValue(kTestBaseCommands);
   base::FilePath temp_file = SaveJsonToTempFile(*json);
   EXPECT_TRUE(manager.LoadBaseCommands(temp_file, nullptr));
@@ -88,13 +90,13 @@
 }
 
 TEST(CommandManager, LoadCommandsJSON) {
-  buffet::CommandManager manager;
+  CommandManager manager;
   auto json = CreateDictionaryValue(kTestVendorCommands);
   EXPECT_TRUE(manager.LoadCommands(*json, "category", nullptr));
 }
 
 TEST(CommandManager, LoadCommandsFile) {
-  buffet::CommandManager manager;
+  CommandManager manager;
   // Load some standard command definitions first.
   auto json = CreateDictionaryValue(R"({
     'base': {
@@ -133,7 +135,7 @@
 }
 
 TEST(CommandManager, ShouldLoadStandardAndTestDefinitions) {
-  buffet::CommandManager manager;
+  CommandManager manager;
   base::ScopedTempDir temp;
   CHECK(temp.CreateUniqueTempDir());
   base::FilePath base_path{temp.path().Append("base_defs")};
@@ -159,7 +161,7 @@
 }
 
 TEST(CommandManager, UpdateCommandVisibility) {
-  buffet::CommandManager manager;
+  CommandManager manager;
   int update_count = 0;
   auto on_command_change = [&update_count]() { update_count++; };
   auto token = manager.AddOnCommandDefChanged(base::Bind(on_command_change));
@@ -185,10 +187,9 @@
   })");
   ASSERT_TRUE(manager.LoadCommands(*json, "test", nullptr));
   EXPECT_EQ(1, update_count);
-  const buffet::CommandDictionary& dict = manager.GetCommandDictionary();
+  const CommandDictionary& dict = manager.GetCommandDictionary();
   EXPECT_TRUE(manager.SetCommandVisibility(
-      {"foo._baz"},
-      buffet::CommandDefinition::Visibility::GetLocal(), nullptr));
+      {"foo._baz"}, CommandDefinition::Visibility::GetLocal(), nullptr));
   EXPECT_EQ(2, update_count);
   EXPECT_EQ("local", dict.FindCommand("foo._baz")->GetVisibility().ToString());
   EXPECT_EQ("all", dict.FindCommand("foo._bar")->GetVisibility().ToString());
@@ -197,8 +198,8 @@
   chromeos::ErrorPtr error;
   ASSERT_FALSE(manager.SetCommandVisibility(
       {"foo._baz", "foo._bar", "test.cmd"},
-      buffet::CommandDefinition::Visibility::GetLocal(), &error));
-  EXPECT_EQ(buffet::errors::commands::kInvalidCommandName, error->GetCode());
+      CommandDefinition::Visibility::GetLocal(), &error));
+  EXPECT_EQ(errors::commands::kInvalidCommandName, error->GetCode());
   EXPECT_EQ("Command 'test.cmd' is unknown", error->GetMessage());
   // The visibility state of commands shouldn't have changed.
   EXPECT_EQ(2, update_count);
@@ -207,11 +208,12 @@
   EXPECT_EQ("none", dict.FindCommand("bar._quux")->GetVisibility().ToString());
 
   EXPECT_TRUE(manager.SetCommandVisibility(
-      {"foo._baz", "bar._quux"},
-      buffet::CommandDefinition::Visibility::GetCloud(), nullptr));
+      {"foo._baz", "bar._quux"}, CommandDefinition::Visibility::GetCloud(),
+      nullptr));
   EXPECT_EQ(3, update_count);
   EXPECT_EQ("cloud", dict.FindCommand("foo._baz")->GetVisibility().ToString());
   EXPECT_EQ("all", dict.FindCommand("foo._bar")->GetVisibility().ToString());
   EXPECT_EQ("cloud", dict.FindCommand("bar._quux")->GetVisibility().ToString());
 }
 
+}  // namespace buffet
diff --git a/buffet/commands/dbus_command_dispatcher_unittest.cc b/buffet/commands/dbus_command_dispatcher_unittest.cc
index 262b85d..2391bb1 100644
--- a/buffet/commands/dbus_command_dispatcher_unittest.cc
+++ b/buffet/commands/dbus_command_dispatcher_unittest.cc
@@ -19,15 +19,15 @@
 #include "buffet/commands/unittest_utils.h"
 #include "buffet/dbus_constants.h"
 
-using buffet::unittests::CreateDictionaryValue;
+namespace buffet {
+
 using chromeos::dbus_utils::AsyncEventSequencer;
+using testing::_;
 using testing::AnyNumber;
 using testing::InSequence;
 using testing::Invoke;
 using testing::Return;
-using testing::_;
-
-namespace buffet {
+using unittests::CreateDictionaryValue;
 
 namespace {
 const char kCommandCategory[] = "test_category";
diff --git a/buffet/commands/dbus_command_proxy_unittest.cc b/buffet/commands/dbus_command_proxy_unittest.cc
index c2ca7d8..1f94ca7 100644
--- a/buffet/commands/dbus_command_proxy_unittest.cc
+++ b/buffet/commands/dbus_command_proxy_unittest.cc
@@ -19,16 +19,16 @@
 #include "buffet/commands/unittest_utils.h"
 #include "buffet/dbus_constants.h"
 
+namespace buffet {
+
 using ::testing::AnyNumber;
-using ::testing::Return;
 using ::testing::Invoke;
+using ::testing::Return;
 using ::testing::_;
 
-using buffet::unittests::CreateDictionaryValue;
-using chromeos::dbus_utils::AsyncEventSequencer;
 using chromeos::VariantDictionary;
-
-namespace buffet {
+using chromeos::dbus_utils::AsyncEventSequencer;
+using unittests::CreateDictionaryValue;
 
 namespace {
 
diff --git a/buffet/commands/object_schema_unittest.cc b/buffet/commands/object_schema_unittest.cc
index 850f64e..06d2ca7 100644
--- a/buffet/commands/object_schema_unittest.cc
+++ b/buffet/commands/object_schema_unittest.cc
@@ -19,14 +19,16 @@
 #include "buffet/commands/schema_constants.h"
 #include "buffet/commands/unittest_utils.h"
 
-using buffet::unittests::CreateValue;
-using buffet::unittests::CreateDictionaryValue;
-using buffet::unittests::ValueToString;
+namespace buffet {
+
+using unittests::CreateValue;
+using unittests::CreateDictionaryValue;
+using unittests::ValueToString;
 
 namespace {
 
-template<typename T>
-std::vector<T> GetArrayValues(const buffet::native_types::Array& arr) {
+template <typename T>
+std::vector<T> GetArrayValues(const native_types::Array& arr) {
   std::vector<T> values;
   values.reserve(arr.size());
   for (const auto& prop_value : arr) {
@@ -35,10 +37,10 @@
   return values;
 }
 
-template<typename T>
-std::vector<T> GetOneOfValues(const buffet::PropType* prop_type) {
-  auto one_of = static_cast<const buffet::ConstraintOneOf*>(
-      prop_type->GetConstraint(buffet::ConstraintType::OneOf));
+template <typename T>
+std::vector<T> GetOneOfValues(const PropType* prop_type) {
+  auto one_of = static_cast<const ConstraintOneOf*>(
+      prop_type->GetConstraint(ConstraintType::OneOf));
   if (!one_of)
     return {};
 
@@ -48,7 +50,7 @@
 }  // anonymous namespace
 
 TEST(CommandSchema, IntPropType_Empty) {
-  buffet::IntPropType prop;
+  IntPropType prop;
   EXPECT_TRUE(prop.GetConstraints().empty());
   EXPECT_FALSE(prop.HasOverriddenAttributes());
   EXPECT_FALSE(prop.IsBasedOnSchema());
@@ -56,7 +58,7 @@
 }
 
 TEST(CommandSchema, IntPropType_Types) {
-  buffet::IntPropType prop;
+  IntPropType prop;
   EXPECT_EQ(nullptr, prop.GetBoolean());
   EXPECT_EQ(&prop, prop.GetInt());
   EXPECT_EQ(nullptr, prop.GetDouble());
@@ -66,11 +68,11 @@
 }
 
 TEST(CommandSchema, IntPropType_ToJson) {
-  buffet::IntPropType prop;
+  IntPropType prop;
   EXPECT_EQ("'integer'", ValueToString(prop.ToJson(false, nullptr).get()));
   EXPECT_EQ("{'type':'integer'}",
             ValueToString(prop.ToJson(true, nullptr).get()));
-  buffet::IntPropType param2;
+  IntPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_EQ("{}", ValueToString(param2.ToJson(false, nullptr).get()));
   param2.FromJson(CreateDictionaryValue("{'minimum':3}").get(),
@@ -96,9 +98,9 @@
 }
 
 TEST(CommandSchema, IntPropType_FromJson) {
-  buffet::IntPropType prop;
+  IntPropType prop;
   prop.AddMinMaxConstraint(2, 8);
-  buffet::IntPropType param2;
+  IntPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_FALSE(param2.HasOverriddenAttributes());
   EXPECT_TRUE(param2.IsBasedOnSchema());
@@ -126,7 +128,7 @@
 }
 
 TEST(CommandSchema, IntPropType_Validate) {
-  buffet::IntPropType prop;
+  IntPropType prop;
   prop.AddMinMaxConstraint(2, 4);
   chromeos::ErrorPtr error;
   EXPECT_FALSE(prop.ValidateValue(CreateValue("-1").get(), &error));
@@ -158,7 +160,7 @@
 }
 
 TEST(CommandSchema, IntPropType_CreateValue) {
-  buffet::IntPropType prop;
+  IntPropType prop;
   chromeos::ErrorPtr error;
   auto val = prop.CreateValue(2, &error);
   ASSERT_NE(nullptr, val.get());
@@ -168,13 +170,13 @@
   val = prop.CreateValue("blah", &error);
   EXPECT_EQ(nullptr, val.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 TEST(CommandSchema, BoolPropType_Empty) {
-  buffet::BooleanPropType prop;
+  BooleanPropType prop;
   EXPECT_TRUE(prop.GetConstraints().empty());
   EXPECT_FALSE(prop.HasOverriddenAttributes());
   EXPECT_FALSE(prop.IsBasedOnSchema());
@@ -182,7 +184,7 @@
 }
 
 TEST(CommandSchema, BoolPropType_Types) {
-  buffet::BooleanPropType prop;
+  BooleanPropType prop;
   EXPECT_EQ(nullptr, prop.GetInt());
   EXPECT_EQ(&prop, prop.GetBoolean());
   EXPECT_EQ(nullptr, prop.GetDouble());
@@ -192,11 +194,11 @@
 }
 
 TEST(CommandSchema, BoolPropType_ToJson) {
-  buffet::BooleanPropType prop;
+  BooleanPropType prop;
   EXPECT_EQ("'boolean'", ValueToString(prop.ToJson(false, nullptr).get()));
   EXPECT_EQ("{'type':'boolean'}",
             ValueToString(prop.ToJson(true, nullptr).get()));
-  buffet::BooleanPropType param2;
+  BooleanPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_EQ("{}", ValueToString(param2.ToJson(false, nullptr).get()));
   param2.FromJson(CreateDictionaryValue("{'enum':[true,false]}").get(), &prop,
@@ -211,17 +213,17 @@
 }
 
 TEST(CommandSchema, BoolPropType_FromJson) {
-  buffet::BooleanPropType prop;
+  BooleanPropType prop;
   prop.FromJson(CreateDictionaryValue("{'enum':[true]}").get(), &prop,
                 nullptr);
-  buffet::BooleanPropType param2;
+  BooleanPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_FALSE(param2.HasOverriddenAttributes());
   EXPECT_TRUE(param2.IsBasedOnSchema());
   EXPECT_EQ(std::vector<bool>{true}, GetOneOfValues<bool>(&prop));
 
-  buffet::BooleanPropType prop_base;
-  buffet::BooleanPropType param3;
+  BooleanPropType prop_base;
+  BooleanPropType param3;
   ASSERT_TRUE(param3.FromJson(CreateDictionaryValue("{'default':false}").get(),
                               &prop_base, nullptr));
   EXPECT_TRUE(param3.HasOverriddenAttributes());
@@ -230,7 +232,7 @@
 }
 
 TEST(CommandSchema, BoolPropType_Validate) {
-  buffet::BooleanPropType prop;
+  BooleanPropType prop;
   prop.FromJson(CreateDictionaryValue("{'enum':[true]}").get(), &prop,
                 nullptr);
   chromeos::ErrorPtr error;
@@ -250,7 +252,7 @@
 }
 
 TEST(CommandSchema, BoolPropType_CreateValue) {
-  buffet::BooleanPropType prop;
+  BooleanPropType prop;
   chromeos::ErrorPtr error;
   auto val = prop.CreateValue(true, &error);
   ASSERT_NE(nullptr, val.get());
@@ -260,13 +262,13 @@
   val = prop.CreateValue("blah", &error);
   EXPECT_EQ(nullptr, val.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 TEST(CommandSchema, DoublePropType_Empty) {
-  buffet::DoublePropType prop;
+  DoublePropType prop;
   EXPECT_DOUBLE_EQ(std::numeric_limits<double>::lowest(), prop.GetMinValue());
   EXPECT_DOUBLE_EQ((std::numeric_limits<double>::max)(), prop.GetMaxValue());
   EXPECT_FALSE(prop.HasOverriddenAttributes());
@@ -275,7 +277,7 @@
 }
 
 TEST(CommandSchema, DoublePropType_Types) {
-  buffet::DoublePropType prop;
+  DoublePropType prop;
   EXPECT_EQ(nullptr, prop.GetInt());
   EXPECT_EQ(nullptr, prop.GetBoolean());
   EXPECT_EQ(&prop, prop.GetDouble());
@@ -285,11 +287,11 @@
 }
 
 TEST(CommandSchema, DoublePropType_ToJson) {
-  buffet::DoublePropType prop;
+  DoublePropType prop;
   EXPECT_EQ("'number'", ValueToString(prop.ToJson(false, nullptr).get()));
   EXPECT_EQ("{'type':'number'}",
             ValueToString(prop.ToJson(true, nullptr).get()));
-  buffet::DoublePropType param2;
+  DoublePropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_EQ("{}", ValueToString(param2.ToJson(false, nullptr).get()));
   param2.FromJson(CreateDictionaryValue("{'minimum':3}").get(), &prop,
@@ -311,9 +313,9 @@
 }
 
 TEST(CommandSchema, DoublePropType_FromJson) {
-  buffet::DoublePropType prop;
+  DoublePropType prop;
   prop.AddMinMaxConstraint(2.5, 8.7);
-  buffet::DoublePropType param2;
+  DoublePropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_FALSE(param2.HasOverriddenAttributes());
   EXPECT_TRUE(param2.IsBasedOnSchema());
@@ -347,7 +349,7 @@
 }
 
 TEST(CommandSchema, DoublePropType_Validate) {
-  buffet::DoublePropType prop;
+  DoublePropType prop;
   prop.AddMinMaxConstraint(-1.2, 1.3);
   chromeos::ErrorPtr error;
   EXPECT_FALSE(prop.ValidateValue(CreateValue("-2").get(), &error));
@@ -373,7 +375,7 @@
 }
 
 TEST(CommandSchema, DoublePropType_CreateValue) {
-  buffet::DoublePropType prop;
+  DoublePropType prop;
   chromeos::ErrorPtr error;
   auto val = prop.CreateValue(2.0, &error);
   ASSERT_NE(nullptr, val.get());
@@ -383,13 +385,13 @@
   val = prop.CreateValue("blah", &error);
   EXPECT_EQ(nullptr, val.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 TEST(CommandSchema, StringPropType_Empty) {
-  buffet::StringPropType prop;
+  StringPropType prop;
   EXPECT_EQ(0, prop.GetMinLength());
   EXPECT_EQ((std::numeric_limits<int>::max)(), prop.GetMaxLength());
   EXPECT_FALSE(prop.HasOverriddenAttributes());
@@ -398,7 +400,7 @@
 }
 
 TEST(CommandSchema, StringPropType_Types) {
-  buffet::StringPropType prop;
+  StringPropType prop;
   EXPECT_EQ(nullptr, prop.GetInt());
   EXPECT_EQ(nullptr, prop.GetBoolean());
   EXPECT_EQ(nullptr, prop.GetDouble());
@@ -408,11 +410,11 @@
 }
 
 TEST(CommandSchema, StringPropType_ToJson) {
-  buffet::StringPropType prop;
+  StringPropType prop;
   EXPECT_EQ("'string'", ValueToString(prop.ToJson(false, nullptr).get()));
   EXPECT_EQ("{'type':'string'}",
             ValueToString(prop.ToJson(true, nullptr).get()));
-  buffet::StringPropType param2;
+  StringPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_EQ("{}", ValueToString(param2.ToJson(false, nullptr).get()));
   param2.FromJson(CreateDictionaryValue("{'minLength':3}").get(), &prop,
@@ -434,9 +436,9 @@
 }
 
 TEST(CommandSchema, StringPropType_FromJson) {
-  buffet::StringPropType prop;
+  StringPropType prop;
   prop.AddLengthConstraint(2, 8);
-  buffet::StringPropType param2;
+  StringPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_FALSE(param2.HasOverriddenAttributes());
   EXPECT_TRUE(param2.IsBasedOnSchema());
@@ -470,7 +472,7 @@
 }
 
 TEST(CommandSchema, StringPropType_Validate) {
-  buffet::StringPropType prop;
+  StringPropType prop;
   prop.AddLengthConstraint(1, 3);
   chromeos::ErrorPtr error;
   EXPECT_FALSE(prop.ValidateValue(CreateValue("''").get(), &error));
@@ -502,7 +504,7 @@
 }
 
 TEST(CommandSchema, StringPropType_CreateValue) {
-  buffet::StringPropType prop;
+  StringPropType prop;
   chromeos::ErrorPtr error;
   auto val = prop.CreateValue(std::string{"blah"}, &error);
   ASSERT_NE(nullptr, val.get());
@@ -512,20 +514,20 @@
   val = prop.CreateValue(4, &error);
   EXPECT_EQ(nullptr, val.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 TEST(CommandSchema, ObjectPropType_Empty) {
-  buffet::ObjectPropType prop;
+  ObjectPropType prop;
   EXPECT_TRUE(prop.HasOverriddenAttributes());
   EXPECT_FALSE(prop.IsBasedOnSchema());
   EXPECT_EQ(nullptr, prop.GetDefaultValue());
 }
 
 TEST(CommandSchema, ObjectPropType_Types) {
-  buffet::ObjectPropType prop;
+  ObjectPropType prop;
   EXPECT_EQ(nullptr, prop.GetInt());
   EXPECT_EQ(nullptr, prop.GetBoolean());
   EXPECT_EQ(nullptr, prop.GetDouble());
@@ -535,20 +537,20 @@
 }
 
 TEST(CommandSchema, ObjectPropType_ToJson) {
-  buffet::ObjectPropType prop;
+  ObjectPropType prop;
   EXPECT_EQ("{'additionalProperties':false,'properties':{}}",
             ValueToString(prop.ToJson(false, nullptr).get()));
   EXPECT_EQ("{'additionalProperties':false,'properties':{},'type':'object'}",
             ValueToString(prop.ToJson(true, nullptr).get()));
   EXPECT_FALSE(prop.IsBasedOnSchema());
-  buffet::ObjectPropType prop2;
+  ObjectPropType prop2;
   prop2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_EQ("{}", ValueToString(prop2.ToJson(false, nullptr).get()));
   EXPECT_TRUE(prop2.IsBasedOnSchema());
 
-  auto schema = buffet::ObjectSchema::Create();
-  schema->AddProp("expires", buffet::PropType::Create(buffet::ValueType::Int));
-  auto pw = buffet::PropType::Create(buffet::ValueType::String);
+  auto schema = ObjectSchema::Create();
+  schema->AddProp("expires", PropType::Create(ValueType::Int));
+  auto pw = PropType::Create(ValueType::String);
   pw->GetString()->AddLengthConstraint(6, 100);
   schema->AddProp("password", std::move(pw));
   prop2.SetObjectSchema(std::move(schema));
@@ -561,7 +563,7 @@
             "'type':'object'}",
             ValueToString(prop2.ToJson(true, nullptr).get()));
 
-  buffet::ObjectPropType prop3;
+  ObjectPropType prop3;
   ASSERT_TRUE(prop3.FromJson(CreateDictionaryValue(
       "{'default':{'expires':3,'password':'abracadabra'}}").get(), &prop2,
       nullptr));
@@ -574,7 +576,7 @@
             "'type':'object'}",
             ValueToString(prop3.ToJson(true, nullptr).get()));
 
-  buffet::ObjectPropType prop4;
+  ObjectPropType prop4;
   ASSERT_TRUE(prop4.FromJson(CreateDictionaryValue(
       "{'additionalProperties':true,"
       "'default':{'expires':3,'password':'abracadabra'}}").get(), &prop2,
@@ -593,30 +595,30 @@
 }
 
 TEST(CommandSchema, ObjectPropType_FromJson) {
-  buffet::ObjectPropType base_prop;
+  ObjectPropType base_prop;
   EXPECT_TRUE(base_prop.FromJson(CreateDictionaryValue(
       "{'properties':{'name':'string','age':'integer'}}").get(), nullptr,
       nullptr));
   auto schema = base_prop.GetObject()->GetObjectSchemaPtr();
-  const buffet::PropType* prop = schema->GetProp("name");
-  EXPECT_EQ(buffet::ValueType::String, prop->GetType());
+  const PropType* prop = schema->GetProp("name");
+  EXPECT_EQ(ValueType::String, prop->GetType());
   prop = schema->GetProp("age");
-  EXPECT_EQ(buffet::ValueType::Int, prop->GetType());
+  EXPECT_EQ(ValueType::Int, prop->GetType());
 
-  buffet::ObjectPropType prop2;
+  ObjectPropType prop2;
   ASSERT_TRUE(prop2.FromJson(CreateDictionaryValue(
       "{'properties':{'name':'string','age':'integer'},"
       "'default':{'name':'Bob','age':33}}").get(), nullptr, nullptr));
   ASSERT_NE(nullptr, prop2.GetDefaultValue());
-  const buffet::ObjectValue* defval = prop2.GetDefaultValue()->GetObject();
+  const ObjectValue* defval = prop2.GetDefaultValue()->GetObject();
   ASSERT_NE(nullptr, defval);
-  buffet::native_types::Object objval = defval->GetValue();
+  native_types::Object objval = defval->GetValue();
   EXPECT_EQ("Bob", objval["name"]->GetString()->GetValue());
   EXPECT_EQ(33, objval["age"]->GetInt()->GetValue());
 }
 
 TEST(CommandSchema, ObjectPropType_Validate) {
-  buffet::ObjectPropType prop;
+  ObjectPropType prop;
   prop.FromJson(CreateDictionaryValue(
       "{'properties':{'expires':'integer',"
       "'password':{'maxLength':100,'minLength':6}}}").get(), nullptr,
@@ -652,7 +654,7 @@
 }
 
 TEST(CommandSchema, ObjectPropType_Validate_Enum) {
-  buffet::ObjectPropType prop;
+  ObjectPropType prop;
   EXPECT_TRUE(prop.FromJson(CreateDictionaryValue(
       "{'properties':{'width':'integer','height':'integer'},"
       "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}").get(),
@@ -673,45 +675,45 @@
 }
 
 TEST(CommandSchema, ObjectPropType_CreateValue) {
-  buffet::ObjectPropType prop;
-  buffet::IntPropType int_type;
+  ObjectPropType prop;
+  IntPropType int_type;
   ASSERT_TRUE(prop.FromJson(CreateDictionaryValue(
       "{'properties':{'width':'integer','height':'integer'},"
       "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}").get(),
       nullptr, nullptr));
-  buffet::native_types::Object obj{
-    {"width", int_type.CreateValue(10, nullptr)},
-    {"height", int_type.CreateValue(20, nullptr)},
+  native_types::Object obj{
+      {"width", int_type.CreateValue(10, nullptr)},
+      {"height", int_type.CreateValue(20, nullptr)},
   };
 
   chromeos::ErrorPtr error;
   auto val = prop.CreateValue(obj, &error);
   ASSERT_NE(nullptr, val.get());
   EXPECT_EQ(nullptr, error.get());
-  EXPECT_EQ(obj, val->GetValueAsAny().Get<buffet::native_types::Object>());
+  EXPECT_EQ(obj, val->GetValueAsAny().Get<native_types::Object>());
 
   val = prop.CreateValue("blah", &error);
   EXPECT_EQ(nullptr, val.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 TEST(CommandSchema, ArrayPropType_Empty) {
-  buffet::ArrayPropType prop;
+  ArrayPropType prop;
   EXPECT_FALSE(prop.HasOverriddenAttributes());
   EXPECT_FALSE(prop.IsBasedOnSchema());
   EXPECT_EQ(nullptr, prop.GetDefaultValue());
   EXPECT_EQ(nullptr, prop.GetItemTypePtr());
-  prop.SetItemType(buffet::PropType::Create(buffet::ValueType::Int));
+  prop.SetItemType(PropType::Create(ValueType::Int));
   EXPECT_TRUE(prop.HasOverriddenAttributes());
   EXPECT_FALSE(prop.IsBasedOnSchema());
   EXPECT_NE(nullptr, prop.GetItemTypePtr());
 }
 
 TEST(CommandSchema, ArrayPropType_Types) {
-  buffet::ArrayPropType prop;
+  ArrayPropType prop;
   EXPECT_EQ(nullptr, prop.GetInt());
   EXPECT_EQ(nullptr, prop.GetBoolean());
   EXPECT_EQ(nullptr, prop.GetDouble());
@@ -721,14 +723,14 @@
 }
 
 TEST(CommandSchema, ArrayPropType_ToJson) {
-  buffet::ArrayPropType prop;
-  prop.SetItemType(buffet::PropType::Create(buffet::ValueType::Int));
+  ArrayPropType prop;
+  prop.SetItemType(PropType::Create(ValueType::Int));
   EXPECT_EQ("{'items':'integer'}",
             ValueToString(prop.ToJson(false, nullptr).get()));
   EXPECT_EQ("{'items':{'type':'integer'},'type':'array'}",
             ValueToString(prop.ToJson(true, nullptr).get()));
   EXPECT_FALSE(prop.IsBasedOnSchema());
-  buffet::ArrayPropType prop2;
+  ArrayPropType prop2;
   prop2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_EQ("{}", ValueToString(prop2.ToJson(false, nullptr).get()));
   EXPECT_TRUE(prop2.IsBasedOnSchema());
@@ -741,24 +743,24 @@
 }
 
 TEST(CommandSchema, ArrayPropType_FromJson) {
-  buffet::ArrayPropType prop;
+  ArrayPropType prop;
   EXPECT_TRUE(prop.FromJson(
       CreateDictionaryValue("{'items':'integer'}").get(), nullptr, nullptr));
-  EXPECT_EQ(buffet::ValueType::Int, prop.GetItemTypePtr()->GetType());
+  EXPECT_EQ(ValueType::Int, prop.GetItemTypePtr()->GetType());
 
-  buffet::ArrayPropType prop2;
+  ArrayPropType prop2;
   ASSERT_TRUE(prop2.FromJson(CreateDictionaryValue(
     "{'items':'string','default':['foo', 'bar', 'baz']}").get(), nullptr,
       nullptr));
   ASSERT_NE(nullptr, prop2.GetDefaultValue());
-  const buffet::ArrayValue* defval = prop2.GetDefaultValue()->GetArray();
+  const ArrayValue* defval = prop2.GetDefaultValue()->GetArray();
   ASSERT_NE(nullptr, defval);
   EXPECT_EQ((std::vector<std::string>{"foo", "bar", "baz"}),
             GetArrayValues<std::string>(defval->GetValue()));
 }
 
 TEST(CommandSchema, ArrayPropType_Validate) {
-  buffet::ArrayPropType prop;
+  ArrayPropType prop;
   prop.FromJson(CreateDictionaryValue(
       "{'items':{'minimum':2.3, 'maximum':10.5}}").get(), nullptr,
       nullptr);
@@ -781,7 +783,7 @@
 }
 
 TEST(CommandSchema, ArrayPropType_Validate_Enum) {
-  buffet::ArrayPropType prop;
+  ArrayPropType prop;
   prop.FromJson(CreateDictionaryValue(
       "{'items':'integer', 'enum':[[1], [2,3], [4,5,6]]}").get(), nullptr,
       nullptr);
@@ -802,60 +804,64 @@
 }
 
 TEST(CommandSchema, ArrayPropType_CreateValue) {
-  buffet::ArrayPropType prop;
+  ArrayPropType prop;
   ASSERT_TRUE(prop.FromJson(CreateDictionaryValue(
       "{'items':{'properties':{'width':'integer','height':'integer'}}}").get(),
       nullptr, nullptr));
 
   chromeos::ErrorPtr error;
-  buffet::native_types::Array arr;
+  native_types::Array arr;
 
   auto val = prop.CreateValue(arr, &error);
   ASSERT_NE(nullptr, val.get());
   EXPECT_EQ(nullptr, error.get());
-  EXPECT_EQ(arr, val->GetValueAsAny().Get<buffet::native_types::Array>());
+  EXPECT_EQ(arr, val->GetValueAsAny().Get<native_types::Array>());
   EXPECT_EQ("[]", ValueToString(val->ToJson(nullptr).get()));
 
-  buffet::IntPropType int_type;
-  buffet::ObjectPropType obj_type;
+  IntPropType int_type;
+  ObjectPropType obj_type;
   ASSERT_TRUE(obj_type.FromJson(CreateDictionaryValue(
       "{'properties':{'width':'integer','height':'integer'}}").get(),
       nullptr, nullptr));
-  arr.push_back(obj_type.CreateValue(buffet::native_types::Object{
-    {"width", int_type.CreateValue(10, nullptr)},
-    {"height", int_type.CreateValue(20, nullptr)},
-  }, nullptr));
-  arr.push_back(obj_type.CreateValue(buffet::native_types::Object{
-    {"width", int_type.CreateValue(17, nullptr)},
-    {"height", int_type.CreateValue(18, nullptr)},
-  }, nullptr));
+  arr.push_back(obj_type.CreateValue(
+      native_types::Object{
+          {"width", int_type.CreateValue(10, nullptr)},
+          {"height", int_type.CreateValue(20, nullptr)},
+      },
+      nullptr));
+  arr.push_back(obj_type.CreateValue(
+      native_types::Object{
+          {"width", int_type.CreateValue(17, nullptr)},
+          {"height", int_type.CreateValue(18, nullptr)},
+      },
+      nullptr));
 
   val = prop.CreateValue(arr, &error);
   ASSERT_NE(nullptr, val.get());
   EXPECT_EQ(nullptr, error.get());
-  EXPECT_EQ(arr, val->GetValueAsAny().Get<buffet::native_types::Array>());
+  EXPECT_EQ(arr, val->GetValueAsAny().Get<native_types::Array>());
   EXPECT_EQ("[{'height':20,'width':10},{'height':18,'width':17}]",
             ValueToString(val->ToJson(nullptr).get()));
 
   val = prop.CreateValue("blah", &error);
   EXPECT_EQ(nullptr, val.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
 }
 
 TEST(CommandSchema, ArrayPropType_NestedArrays_NotSupported) {
-  buffet::ArrayPropType prop;
+  ArrayPropType prop;
   chromeos::ErrorPtr error;
   EXPECT_FALSE(prop.FromJson(CreateDictionaryValue(
       "{'items':{'items':'integer'}}").get(), nullptr, &error));
-  EXPECT_EQ(buffet::errors::commands::kInvalidObjectSchema, error->GetCode());
+  EXPECT_EQ(errors::commands::kInvalidObjectSchema, error->GetCode());
   error.reset();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeName) {
-  buffet::ObjectSchema schema;
+  ObjectSchema schema;
   const char* schema_str = "{"
       "'param1':'integer',"
       "'param2':'number',"
@@ -863,9 +869,9 @@
       "}";
   EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
                               nullptr));
-  EXPECT_EQ(buffet::ValueType::Int, schema.GetProp("param1")->GetType());
-  EXPECT_EQ(buffet::ValueType::Double, schema.GetProp("param2")->GetType());
-  EXPECT_EQ(buffet::ValueType::String, schema.GetProp("param3")->GetType());
+  EXPECT_EQ(ValueType::Int, schema.GetProp("param1")->GetType());
+  EXPECT_EQ(ValueType::Double, schema.GetProp("param2")->GetType());
+  EXPECT_EQ(ValueType::String, schema.GetProp("param3")->GetType());
   EXPECT_EQ("integer", schema.GetProp("param1")->GetTypeAsString());
   EXPECT_EQ("number", schema.GetProp("param2")->GetTypeAsString());
   EXPECT_EQ("string", schema.GetProp("param3")->GetTypeAsString());
@@ -884,7 +890,7 @@
 }
 
 TEST(CommandSchema, ObjectSchema_FromJson_Full_TypeName) {
-  buffet::ObjectSchema schema;
+  ObjectSchema schema;
   const char* schema_str = "{"
       "'param1':{'type':'integer'},"
       "'param2':{'type':'number'},"
@@ -894,11 +900,11 @@
       "}";
   EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
                               nullptr));
-  EXPECT_EQ(buffet::ValueType::Int, schema.GetProp("param1")->GetType());
-  EXPECT_EQ(buffet::ValueType::Double, schema.GetProp("param2")->GetType());
-  EXPECT_EQ(buffet::ValueType::String, schema.GetProp("param3")->GetType());
-  EXPECT_EQ(buffet::ValueType::Array, schema.GetProp("param4")->GetType());
-  EXPECT_EQ(buffet::ValueType::Object, schema.GetProp("param5")->GetType());
+  EXPECT_EQ(ValueType::Int, schema.GetProp("param1")->GetType());
+  EXPECT_EQ(ValueType::Double, schema.GetProp("param2")->GetType());
+  EXPECT_EQ(ValueType::String, schema.GetProp("param3")->GetType());
+  EXPECT_EQ(ValueType::Array, schema.GetProp("param4")->GetType());
+  EXPECT_EQ(ValueType::Object, schema.GetProp("param5")->GetType());
   EXPECT_EQ("integer", schema.GetProp("param1")->GetTypeAsString());
   EXPECT_EQ("number", schema.GetProp("param2")->GetTypeAsString());
   EXPECT_EQ("string", schema.GetProp("param3")->GetTypeAsString());
@@ -919,7 +925,7 @@
 }
 
 TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeDeduction_Scalar) {
-  buffet::ObjectSchema schema;
+  ObjectSchema schema;
   const char* schema_str = "{"
       "'param1' :{'minimum':2},"
       "'param2' :{'maximum':10},"
@@ -995,7 +1001,7 @@
   EXPECT_EQ(10, schema.GetProp("param10")->GetString()->GetMaxLength());
   EXPECT_EQ(3, schema.GetProp("param11")->GetString()->GetMinLength());
   EXPECT_EQ(8, schema.GetProp("param11")->GetString()->GetMaxLength());
-  const buffet::PropValue* val = schema.GetProp("param12")->GetDefaultValue();
+  const PropValue* val = schema.GetProp("param12")->GetDefaultValue();
   EXPECT_EQ(12, val->GetInt()->GetValue());
   val = schema.GetProp("param13")->GetDefaultValue();
   EXPECT_DOUBLE_EQ(13.5, val->GetDouble()->GetValue());
@@ -1013,7 +1019,7 @@
 }
 
 TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeDeduction_Array) {
-  buffet::ObjectSchema schema;
+  ObjectSchema schema;
   const char* schema_str = "{"
       "'param1' :[0,1,2,3],"
       "'param2' :[0.0,1.1,2.2],"
@@ -1104,7 +1110,7 @@
       "'param21':{'default':49},"
       "'param22':'integer'"
       "}";
-  buffet::ObjectSchema base_schema;
+  ObjectSchema base_schema;
   EXPECT_TRUE(base_schema.FromJson(CreateDictionaryValue(base_schema_str).get(),
                                    nullptr, nullptr));
   const char* schema_str = "{"
@@ -1131,7 +1137,7 @@
       "'param21':{'default':8},"
       "'param22':{'default':123}"
       "}";
-  buffet::ObjectSchema schema;
+  ObjectSchema schema;
   EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(),
                               &base_schema, nullptr));
   EXPECT_EQ(nullptr, schema.GetProp("param0"));
@@ -1202,7 +1208,7 @@
 }
 
 TEST(CommandSchema, ObjectSchema_UseDefaults) {
-  buffet::ObjectPropType prop;
+  ObjectPropType prop;
   const char* schema_str = "{'properties':{"
       "'param1':{'default':true},"
       "'param2':{'default':2},"
@@ -1218,15 +1224,15 @@
   // Omit all.
   auto value = prop.CreateValue();
   ASSERT_TRUE(value->FromJson(CreateDictionaryValue("{}").get(), nullptr));
-  buffet::native_types::Object obj = value->GetObject()->GetValue();
+  native_types::Object obj = value->GetObject()->GetValue();
   EXPECT_TRUE(obj["param1"]->GetBoolean()->GetValue());
   EXPECT_EQ(2, obj["param2"]->GetInt()->GetValue());
   EXPECT_DOUBLE_EQ(3.3, obj["param3"]->GetDouble()->GetValue());
   EXPECT_EQ("four", obj["param4"]->GetString()->GetValue());
-  buffet::native_types::Object param5 = obj["param5"]->GetObject()->GetValue();
+  native_types::Object param5 = obj["param5"]->GetObject()->GetValue();
   EXPECT_EQ(5, param5["x"]->GetInt()->GetValue());
   EXPECT_EQ(6, param5["y"]->GetInt()->GetValue());
-  buffet::native_types::Array param6 = obj["param6"]->GetArray()->GetValue();
+  native_types::Array param6 = obj["param6"]->GetArray()->GetValue();
   EXPECT_EQ((std::vector<int>{1, 2, 3}), GetArrayValues<int>(param6));
 
   // Specify some.
@@ -1272,7 +1278,7 @@
 }
 
 TEST(CommandSchema, ObjectSchema_FromJson_BaseSchema_Failures) {
-  buffet::ObjectSchema schema;
+  ObjectSchema schema;
   chromeos::ErrorPtr error;
   const char* schema_str = "{"
       "'param1':{}"
@@ -1386,3 +1392,5 @@
   EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
   error.reset();
 }
+
+}  // namespace buffet
diff --git a/buffet/commands/schema_utils_unittest.cc b/buffet/commands/schema_utils_unittest.cc
index 8405722..9698317 100644
--- a/buffet/commands/schema_utils_unittest.cc
+++ b/buffet/commands/schema_utils_unittest.cc
@@ -18,172 +18,170 @@
 #include "buffet/commands/schema_constants.h"
 #include "buffet/commands/unittest_utils.h"
 
-using buffet::unittests::CreateDictionaryValue;
-using buffet::unittests::CreateValue;
-using buffet::unittests::ValueToString;
+namespace buffet {
+
+using unittests::CreateDictionaryValue;
+using unittests::CreateValue;
+using unittests::ValueToString;
 using chromeos::VariantDictionary;
 
 TEST(CommandSchemaUtils, TypedValueToJson_Scalar) {
-  EXPECT_EQ("true",
-            ValueToString(buffet::TypedValueToJson(true, nullptr).get()));
-  EXPECT_EQ("false",
-            ValueToString(buffet::TypedValueToJson(false, nullptr).get()));
+  EXPECT_EQ("true", ValueToString(TypedValueToJson(true, nullptr).get()));
+  EXPECT_EQ("false", ValueToString(TypedValueToJson(false, nullptr).get()));
 
-  EXPECT_EQ("0", ValueToString(buffet::TypedValueToJson(0, nullptr).get()));
-  EXPECT_EQ("-10", ValueToString(buffet::TypedValueToJson(-10, nullptr).get()));
-  EXPECT_EQ("20", ValueToString(buffet::TypedValueToJson(20, nullptr).get()));
+  EXPECT_EQ("0", ValueToString(TypedValueToJson(0, nullptr).get()));
+  EXPECT_EQ("-10", ValueToString(TypedValueToJson(-10, nullptr).get()));
+  EXPECT_EQ("20", ValueToString(TypedValueToJson(20, nullptr).get()));
 
-  EXPECT_EQ("0.0", ValueToString(buffet::TypedValueToJson(0.0, nullptr).get()));
-  EXPECT_EQ("1.2", ValueToString(buffet::TypedValueToJson(1.2, nullptr).get()));
+  EXPECT_EQ("0.0", ValueToString(TypedValueToJson(0.0, nullptr).get()));
+  EXPECT_EQ("1.2", ValueToString(TypedValueToJson(1.2, nullptr).get()));
 
   EXPECT_EQ("'abc'",
-            ValueToString(buffet::TypedValueToJson(std::string("abc"),
-                                                   nullptr).get()));
+            ValueToString(TypedValueToJson(std::string("abc"), nullptr).get()));
 
   std::vector<bool> bool_array{true, false};
   EXPECT_EQ("[true,false]",
-            ValueToString(buffet::TypedValueToJson(bool_array, nullptr).get()));
+            ValueToString(TypedValueToJson(bool_array, nullptr).get()));
 
   std::vector<int> int_array{1, 2, 5};
   EXPECT_EQ("[1,2,5]",
-            ValueToString(buffet::TypedValueToJson(int_array, nullptr).get()));
+            ValueToString(TypedValueToJson(int_array, nullptr).get()));
 
   std::vector<double> dbl_array{1.1, 2.2};
   EXPECT_EQ("[1.1,2.2]",
-            ValueToString(buffet::TypedValueToJson(dbl_array, nullptr).get()));
+            ValueToString(TypedValueToJson(dbl_array, nullptr).get()));
 
   std::vector<std::string> str_array{"a", "bc"};
   EXPECT_EQ("['a','bc']",
-            ValueToString(buffet::TypedValueToJson(str_array, nullptr).get()));
+            ValueToString(TypedValueToJson(str_array, nullptr).get()));
 }
 
 TEST(CommandSchemaUtils, TypedValueToJson_Object) {
-  buffet::IntPropType int_type;
-  buffet::native_types::Object object;
+  IntPropType int_type;
+  native_types::Object object;
 
   object.insert(std::make_pair("width", int_type.CreateValue(640, nullptr)));
   object.insert(std::make_pair("height", int_type.CreateValue(480, nullptr)));
   EXPECT_EQ("{'height':480,'width':640}",
-            ValueToString(buffet::TypedValueToJson(object, nullptr).get()));
+            ValueToString(TypedValueToJson(object, nullptr).get()));
 }
 
 TEST(CommandSchemaUtils, TypedValueToJson_Array) {
-  buffet::IntPropType int_type;
-  buffet::native_types::Array arr;
+  IntPropType int_type;
+  native_types::Array arr;
 
   arr.push_back(int_type.CreateValue(640, nullptr));
   arr.push_back(int_type.CreateValue(480, nullptr));
-  EXPECT_EQ("[640,480]",
-            ValueToString(buffet::TypedValueToJson(arr, nullptr).get()));
+  EXPECT_EQ("[640,480]", ValueToString(TypedValueToJson(arr, nullptr).get()));
 }
 
 TEST(CommandSchemaUtils, TypedValueFromJson_Bool) {
   bool value;
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("true").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("true").get(), nullptr, &value, nullptr));
   EXPECT_TRUE(value);
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("false").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("false").get(), nullptr, &value, nullptr));
   EXPECT_FALSE(value);
 
   chromeos::ErrorPtr error;
-  EXPECT_FALSE(buffet::TypedValueFromJson(CreateValue("0").get(), nullptr,
-                                          &value, &error));
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_FALSE(
+      TypedValueFromJson(CreateValue("0").get(), nullptr, &value, &error));
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
   error.reset();
 }
 
 TEST(CommandSchemaUtils, TypedValueFromJson_Int) {
   int value;
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("0").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("0").get(), nullptr, &value, nullptr));
   EXPECT_EQ(0, value);
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("23").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("23").get(), nullptr, &value, nullptr));
   EXPECT_EQ(23, value);
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("-1234").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("-1234").get(), nullptr, &value, nullptr));
   EXPECT_EQ(-1234, value);
 
   chromeos::ErrorPtr error;
-  EXPECT_FALSE(buffet::TypedValueFromJson(CreateValue("'abc'").get(), nullptr,
-                                          &value, &error));
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_FALSE(
+      TypedValueFromJson(CreateValue("'abc'").get(), nullptr, &value, &error));
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
   error.reset();
 }
 
 TEST(CommandSchemaUtils, TypedValueFromJson_Double) {
   double value;
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("0").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("0").get(), nullptr, &value, nullptr));
   EXPECT_DOUBLE_EQ(0.0, value);
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("0.0").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("0.0").get(), nullptr, &value, nullptr));
   EXPECT_DOUBLE_EQ(0.0, value);
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("23").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("23").get(), nullptr, &value, nullptr));
   EXPECT_EQ(23.0, value);
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("23.1").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("23.1").get(), nullptr, &value, nullptr));
   EXPECT_EQ(23.1, value);
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("-1.23E+02").get(),
-                                         nullptr, &value, nullptr));
+  EXPECT_TRUE(TypedValueFromJson(CreateValue("-1.23E+02").get(), nullptr,
+                                 &value, nullptr));
   EXPECT_EQ(-123.0, value);
 
   chromeos::ErrorPtr error;
-  EXPECT_FALSE(buffet::TypedValueFromJson(CreateValue("'abc'").get(), nullptr,
-                                          &value, &error));
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_FALSE(
+      TypedValueFromJson(CreateValue("'abc'").get(), nullptr, &value, &error));
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
   error.reset();
 }
 
 TEST(CommandSchemaUtils, TypedValueFromJson_String) {
   std::string value;
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("''").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("''").get(), nullptr, &value, nullptr));
   EXPECT_EQ("", value);
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("'23'").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("'23'").get(), nullptr, &value, nullptr));
   EXPECT_EQ("23", value);
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(CreateValue("'abc'").get(), nullptr,
-                                         &value, nullptr));
+  EXPECT_TRUE(
+      TypedValueFromJson(CreateValue("'abc'").get(), nullptr, &value, nullptr));
   EXPECT_EQ("abc", value);
 
   chromeos::ErrorPtr error;
-  EXPECT_FALSE(buffet::TypedValueFromJson(CreateValue("12").get(), nullptr,
-                                          &value, &error));
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_FALSE(
+      TypedValueFromJson(CreateValue("12").get(), nullptr, &value, &error));
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
   error.reset();
 }
 
 TEST(CommandSchemaUtils, TypedValueFromJson_Object) {
-  buffet::native_types::Object value;
-  std::unique_ptr<buffet::ObjectSchema> schema{new buffet::ObjectSchema};
+  native_types::Object value;
+  std::unique_ptr<ObjectSchema> schema{new ObjectSchema};
 
-  buffet::IntPropType age_prop;
+  IntPropType age_prop;
   age_prop.AddMinMaxConstraint(0, 150);
   schema->AddProp("age", age_prop.Clone());
 
-  buffet::StringPropType name_prop;
+  StringPropType name_prop;
   name_prop.AddLengthConstraint(1, 30);
   schema->AddProp("name", name_prop.Clone());
 
-  buffet::ObjectPropType type;
+  ObjectPropType type;
   type.SetObjectSchema(std::move(schema));
-  EXPECT_TRUE(buffet::TypedValueFromJson(
-      CreateValue("{'age':20,'name':'Bob'}").get(), &type, &value, nullptr));
-  buffet::native_types::Object value2;
+  EXPECT_TRUE(TypedValueFromJson(CreateValue("{'age':20,'name':'Bob'}").get(),
+                                 &type, &value, nullptr));
+  native_types::Object value2;
   value2.insert(std::make_pair("age", age_prop.CreateValue(20, nullptr)));
   value2.insert(std::make_pair("name",
                                name_prop.CreateValue(std::string("Bob"),
@@ -191,58 +189,58 @@
   EXPECT_EQ(value2, value);
 
   chromeos::ErrorPtr error;
-  EXPECT_FALSE(buffet::TypedValueFromJson(CreateValue("'abc'").get(), nullptr,
-                                          &value, &error));
-  EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+  EXPECT_FALSE(
+      TypedValueFromJson(CreateValue("'abc'").get(), nullptr, &value, &error));
+  EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
   error.reset();
 }
 
 TEST(CommandSchemaUtils, TypedValueFromJson_Array) {
-  buffet::native_types::Array arr;
-  buffet::StringPropType str_type;
+  native_types::Array arr;
+  StringPropType str_type;
   str_type.AddLengthConstraint(3, 100);
-  buffet::ArrayPropType type;
+  ArrayPropType type;
   type.SetItemType(str_type.Clone());
 
-  EXPECT_TRUE(buffet::TypedValueFromJson(
-      CreateValue("['foo', 'bar']").get(), &type, &arr, nullptr));
-  buffet::native_types::Array arr2;
+  EXPECT_TRUE(TypedValueFromJson(CreateValue("['foo', 'bar']").get(), &type,
+                                 &arr, nullptr));
+  native_types::Array arr2;
   arr2.push_back(str_type.CreateValue(std::string{"foo"}, nullptr));
   arr2.push_back(str_type.CreateValue(std::string{"bar"}, nullptr));
   EXPECT_EQ(arr2, arr);
 
   chromeos::ErrorPtr error;
-  EXPECT_FALSE(buffet::TypedValueFromJson(
-      CreateValue("['baz', 'ab']").get(), &type, &arr, &error));
-  EXPECT_EQ(buffet::errors::commands::kOutOfRange, error->GetCode());
+  EXPECT_FALSE(TypedValueFromJson(CreateValue("['baz', 'ab']").get(), &type,
+                                  &arr, &error));
+  EXPECT_EQ(errors::commands::kOutOfRange, error->GetCode());
   error.reset();
 }
 
 TEST(CommandSchemaUtils, PropValueToDBusVariant) {
-  buffet::IntPropType int_type;
+  IntPropType int_type;
   auto prop_value = int_type.CreateValue(5, nullptr);
   EXPECT_EQ(5, PropValueToDBusVariant(prop_value.get()).Get<int>());
 
-  buffet::BooleanPropType bool_type;
+  BooleanPropType bool_type;
   prop_value = bool_type.CreateValue(true, nullptr);
   EXPECT_TRUE(PropValueToDBusVariant(prop_value.get()).Get<bool>());
 
-  buffet::DoublePropType dbl_type;
+  DoublePropType dbl_type;
   prop_value = dbl_type.CreateValue(5.5, nullptr);
   EXPECT_DOUBLE_EQ(5.5, PropValueToDBusVariant(prop_value.get()).Get<double>());
 
-  buffet::StringPropType str_type;
+  StringPropType str_type;
   prop_value = str_type.CreateValue(std::string{"foo"}, nullptr);
   EXPECT_EQ("foo", PropValueToDBusVariant(prop_value.get()).Get<std::string>());
 
-  buffet::ObjectPropType obj_type;
+  ObjectPropType obj_type;
   ASSERT_TRUE(obj_type.FromJson(CreateDictionaryValue(
       "{'properties':{'width':'integer','height':'integer'},"
       "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}").get(),
       nullptr, nullptr));
-  buffet::native_types::Object obj{
-    {"width", int_type.CreateValue(10, nullptr)},
-    {"height", int_type.CreateValue(20, nullptr)},
+  native_types::Object obj{
+      {"width", int_type.CreateValue(10, nullptr)},
+      {"height", int_type.CreateValue(20, nullptr)},
   };
   prop_value = obj_type.CreateValue(obj, nullptr);
   VariantDictionary dict =
@@ -250,9 +248,9 @@
   EXPECT_EQ(20, dict["height"].Get<int>());
   EXPECT_EQ(10, dict["width"].Get<int>());
 
-  buffet::ArrayPropType arr_type;
+  ArrayPropType arr_type;
   arr_type.SetItemType(str_type.Clone());
-  buffet::native_types::Array arr;
+  native_types::Array arr;
   arr.push_back(str_type.CreateValue(std::string{"foo"}, nullptr));
   arr.push_back(str_type.CreateValue(std::string{"bar"}, nullptr));
   arr.push_back(str_type.CreateValue(std::string{"baz"}, nullptr));
@@ -264,7 +262,7 @@
 }
 
 TEST(CommandSchemaUtils, PropValueFromDBusVariant_Int) {
-  buffet::IntPropType int_type;
+  IntPropType int_type;
   ASSERT_TRUE(int_type.FromJson(CreateDictionaryValue("{'enum':[1,2]}").get(),
                                 nullptr, nullptr));
 
@@ -276,11 +274,11 @@
   prop_value = PropValueFromDBusVariant(&int_type, 5, &error);
   EXPECT_EQ(nullptr, prop_value.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kOutOfRange, error->GetCode());
+  EXPECT_EQ(errors::commands::kOutOfRange, error->GetCode());
 }
 
 TEST(CommandSchemaUtils, PropValueFromDBusVariant_Bool) {
-  buffet::BooleanPropType bool_type;
+  BooleanPropType bool_type;
   ASSERT_TRUE(bool_type.FromJson(CreateDictionaryValue("{'enum':[true]}").get(),
                                  nullptr, nullptr));
 
@@ -292,11 +290,11 @@
   prop_value = PropValueFromDBusVariant(&bool_type, false, &error);
   EXPECT_EQ(nullptr, prop_value.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kOutOfRange, error->GetCode());
+  EXPECT_EQ(errors::commands::kOutOfRange, error->GetCode());
 }
 
 TEST(CommandSchemaUtils, PropValueFromDBusVariant_Double) {
-  buffet::DoublePropType dbl_type;
+  DoublePropType dbl_type;
   ASSERT_TRUE(dbl_type.FromJson(CreateDictionaryValue("{'maximum':2.0}").get(),
                                  nullptr, nullptr));
 
@@ -308,11 +306,11 @@
   prop_value = PropValueFromDBusVariant(&dbl_type, 10.0, &error);
   EXPECT_EQ(nullptr, prop_value.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kOutOfRange, error->GetCode());
+  EXPECT_EQ(errors::commands::kOutOfRange, error->GetCode());
 }
 
 TEST(CommandSchemaUtils, PropValueFromDBusVariant_String) {
-  buffet::StringPropType str_type;
+  StringPropType str_type;
   ASSERT_TRUE(str_type.FromJson(CreateDictionaryValue("{'minLength': 4}").get(),
                                  nullptr, nullptr));
 
@@ -325,11 +323,11 @@
   prop_value = PropValueFromDBusVariant(&str_type, std::string{"foo"}, &error);
   EXPECT_EQ(nullptr, prop_value.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kOutOfRange, error->GetCode());
+  EXPECT_EQ(errors::commands::kOutOfRange, error->GetCode());
 }
 
 TEST(CommandSchemaUtils, PropValueFromDBusVariant_Object) {
-  buffet::ObjectPropType obj_type;
+  ObjectPropType obj_type;
   ASSERT_TRUE(obj_type.FromJson(CreateDictionaryValue(
       "{'properties':{'width':'integer','height':'integer'},"
       "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}").get(),
@@ -341,7 +339,7 @@
   };
   auto prop_value = PropValueFromDBusVariant(&obj_type, obj, nullptr);
   ASSERT_NE(nullptr, prop_value.get());
-  auto value = prop_value->GetValueAsAny().Get<buffet::native_types::Object>();
+  auto value = prop_value->GetValueAsAny().Get<native_types::Object>();
   EXPECT_EQ(100, value["width"].get()->GetValueAsAny().Get<int>());
   EXPECT_EQ(200, value["height"].get()->GetValueAsAny().Get<int>());
 
@@ -350,18 +348,18 @@
   prop_value = PropValueFromDBusVariant(&obj_type, obj, &error);
   EXPECT_EQ(nullptr, prop_value.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kOutOfRange, error->GetCode());
+  EXPECT_EQ(errors::commands::kOutOfRange, error->GetCode());
 }
 
 TEST(CommandSchemaUtils, PropValueFromDBusVariant_Array) {
-  buffet::ArrayPropType arr_type;
-  buffet::IntPropType int_type;
+  ArrayPropType arr_type;
+  IntPropType int_type;
   int_type.AddMinMaxConstraint(0, 100);
   arr_type.SetItemType(int_type.Clone());
   std::vector<int> data{0, 1, 1, 100};
   auto prop_value = PropValueFromDBusVariant(&arr_type, data, nullptr);
   ASSERT_NE(nullptr, prop_value.get());
-  auto arr = prop_value->GetValueAsAny().Get<buffet::native_types::Array>();
+  auto arr = prop_value->GetValueAsAny().Get<native_types::Array>();
   ASSERT_EQ(4u, arr.size());
   EXPECT_EQ(0, arr[0]->GetInt()->GetValue());
   EXPECT_EQ(1, arr[1]->GetInt()->GetValue());
@@ -373,5 +371,7 @@
   prop_value = PropValueFromDBusVariant(&arr_type, data, &error);
   EXPECT_EQ(nullptr, prop_value.get());
   ASSERT_NE(nullptr, error.get());
-  EXPECT_EQ(buffet::errors::commands::kOutOfRange, error->GetCode());
+  EXPECT_EQ(errors::commands::kOutOfRange, error->GetCode());
 }
+
+}  // namespace buffet
diff --git a/buffet/device_registration_info_unittest.cc b/buffet/device_registration_info_unittest.cc
index 0deaa6e..f82a39b 100644
--- a/buffet/device_registration_info_unittest.cc
+++ b/buffet/device_registration_info_unittest.cc
@@ -21,12 +21,12 @@
 #include "buffet/states/state_manager.h"
 #include "buffet/storage_impls.h"
 
+namespace buffet {
+
 using chromeos::http::request_header::kAuthorization;
 using chromeos::http::fake::ServerRequest;
 using chromeos::http::fake::ServerResponse;
 
-namespace buffet {
-
 namespace {
 
 namespace test_data {
@@ -313,8 +313,7 @@
   EXPECT_FALSE(DeviceRegistrationInfo::TestHelper::CheckRegistration(
       dev_reg_.get(), &error));
   EXPECT_EQ(1, transport_->GetRequestCount());
-  EXPECT_TRUE(error->HasError(buffet::kErrorDomainOAuth2,
-                              "unable_to_authenticate"));
+  EXPECT_TRUE(error->HasError(kErrorDomainOAuth2, "unable_to_authenticate"));
   EXPECT_EQ(RegistrationStatus::kConnecting, dev_reg_->GetRegistrationStatus());
 }
 
@@ -332,8 +331,7 @@
   EXPECT_FALSE(DeviceRegistrationInfo::TestHelper::CheckRegistration(
       dev_reg_.get(), &error));
   EXPECT_EQ(1, transport_->GetRequestCount());
-  EXPECT_TRUE(error->HasError(buffet::kErrorDomainOAuth2,
-                              "invalid_grant"));
+  EXPECT_TRUE(error->HasError(kErrorDomainOAuth2, "invalid_grant"));
   EXPECT_EQ(RegistrationStatus::kInvalidCredentials,
             dev_reg_->GetRegistrationStatus());
 }
@@ -402,11 +400,12 @@
     base::DictionaryValue* commandDefs = nullptr;
     EXPECT_TRUE(json->GetDictionary("deviceDraft.commandDefs", &commandDefs));
     EXPECT_FALSE(commandDefs->empty());
-    EXPECT_EQ("{'base':{'reboot':{'parameters':{"
-              "'delay':{'minimum':10,'type':'integer'}}}},"
-              "'robot':{'_jump':{'parameters':{"
-              "'_height':{'type':'integer'}}}}}",
-              buffet::unittests::ValueToString(commandDefs));
+    EXPECT_EQ(
+        "{'base':{'reboot':{'parameters':{"
+        "'delay':{'minimum':10,'type':'integer'}}}},"
+        "'robot':{'_jump':{'parameters':{"
+        "'_height':{'type':'integer'}}}}}",
+        unittests::ValueToString(commandDefs));
 
     base::DictionaryValue json_resp;
     json_resp.SetString("id", test_data::kClaimTicketId);
@@ -422,7 +421,7 @@
     response->ReplyJson(chromeos::http::status_code::Ok, &json_resp);
   };
 
-  auto json_base = buffet::unittests::CreateDictionaryValue(R"({
+  auto json_base = unittests::CreateDictionaryValue(R"({
     'base': {
       'reboot': {
         'parameters': {'delay': 'integer'},
@@ -435,7 +434,7 @@
     }
   })");
   EXPECT_TRUE(command_manager_->LoadBaseCommands(*json_base, nullptr));
-  auto json_cmds = buffet::unittests::CreateDictionaryValue(R"({
+  auto json_cmds = unittests::CreateDictionaryValue(R"({
     'base': {
       'reboot': {
         'parameters': {'delay': {'minimum': 10}},
@@ -504,7 +503,7 @@
 
 TEST_F(DeviceRegistrationInfoTest, UpdateCommand) {
   EXPECT_TRUE(dev_reg_->Load());
-  auto json_cmds = buffet::unittests::CreateDictionaryValue(R"({
+  auto json_cmds = unittests::CreateDictionaryValue(R"({
     'robot': {
       '_jump': {
         'parameters': {'_height': 'integer'},
@@ -516,7 +515,7 @@
 
   const std::string command_url = dev_reg_->GetServiceURL("commands/1234");
 
-  auto commands_json = buffet::unittests::CreateValue(R"([{
+  auto commands_json = unittests::CreateValue(R"([{
     'name':'robot._jump',
     'id':'1234',
     'parameters': {'_height': 100}
diff --git a/buffet/states/state_manager_unittest.cc b/buffet/states/state_manager_unittest.cc
index b035175..12d3845 100644
--- a/buffet/states/state_manager_unittest.cc
+++ b/buffet/states/state_manager_unittest.cc
@@ -16,13 +16,13 @@
 #include "buffet/states/error_codes.h"
 #include "buffet/states/mock_state_change_queue_interface.h"
 
-using buffet::unittests::CreateDictionaryValue;
-using buffet::unittests::ValueToString;
-using testing::Return;
-using testing::_;
-
 namespace buffet {
 
+using testing::_;
+using testing::Return;
+using unittests::CreateDictionaryValue;
+using unittests::ValueToString;
+
 namespace {
 std::unique_ptr<base::DictionaryValue> GetTestSchema() {
   return CreateDictionaryValue(R"({
diff --git a/buffet/states/state_package_unittest.cc b/buffet/states/state_package_unittest.cc
index d2d36e4..7856531 100644
--- a/buffet/states/state_package_unittest.cc
+++ b/buffet/states/state_package_unittest.cc
@@ -15,11 +15,11 @@
 #include "buffet/commands/unittest_utils.h"
 #include "buffet/states/error_codes.h"
 
-using buffet::unittests::CreateDictionaryValue;
-using buffet::unittests::ValueToString;
-
 namespace buffet {
 
+using unittests::CreateDictionaryValue;
+using unittests::ValueToString;
+
 class StatePackageTestHelper {
  public:
   // Returns the state property definitions (types/constraints/etc).
diff --git a/buffet/xmpp/xmpp_client_unittest.cc b/buffet/xmpp/xmpp_client_unittest.cc
index ef26f2e..26dfacf 100644
--- a/buffet/xmpp/xmpp_client_unittest.cc
+++ b/buffet/xmpp/xmpp_client_unittest.cc
@@ -13,13 +13,13 @@
 #include "buffet/xmpp/xmpp_client.h"
 #include "buffet/xmpp/xmpp_connection.h"
 
+namespace buffet {
+
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SetArgPointee;
 using ::testing::_;
 
-namespace buffet {
-
 namespace {
 
 constexpr char kAccountName[] = "Account@Name";