Rename "chromeos" -> "brillo" in include paths and namespaces

libchromeos is transitioning to libbrillo and chromeos namespaces
and include directory is changing to brillo.

BUG: 24872993
TEST=built on aosp and dragonboard, unit tests passed
     the generated proxies/adaptors in other projects compile correctly

Change-Id: Idd11c5eebc1e5b80825321dd25f06a8af6f1cd26

14 files changed, 163 insertions, 165 deletions

diff --git a/chromeos-dbus-bindings/adaptor_generator.cc b/chromeos-dbus-bindings/adaptor_generator.cc
index 44897a1..0f980b5 100644
--- a/chromeos-dbus-bindings/adaptor_generator.cc
+++ b/chromeos-dbus-bindings/adaptor_generator.cc
@@ -9,7 +9,7 @@
 #include <base/logging.h>
 #include <base/strings/string_util.h>
 #include <base/strings/stringprintf.h>
-#include <chromeos/strings/string_utils.h>
+#include <brillo/strings/string_utils.h>
 
 #include "chromeos-dbus-bindings/dbus_signature.h"
 #include "chromeos-dbus-bindings/indented_text.h"
@@ -43,10 +43,10 @@ bool AdaptorGenerator::GenerateAdaptors(
   text.AddBlankLine();
   text.AddLine("#include <base/macros.h>");
   text.AddLine("#include <dbus/object_path.h>");
-  text.AddLine("#include <chromeos/any.h>");
-  text.AddLine("#include <chromeos/dbus/dbus_object.h>");
-  text.AddLine("#include <chromeos/dbus/exported_object_manager.h>");
-  text.AddLine("#include <chromeos/variant_dictionary.h>");
+  text.AddLine("#include <brillo/any.h>");
+  text.AddLine("#include <brillo/dbus/dbus_object.h>");
+  text.AddLine("#include <brillo/dbus/exported_object_manager.h>");
+  text.AddLine("#include <brillo/variant_dictionary.h>");
 
   for (const auto& interface : interfaces)
     GenerateInterfaceAdaptor(interface, &text);
@@ -136,9 +136,9 @@ void AdaptorGenerator::AddRegisterWithDBusObject(
     IndentedText *text) {
   text->AddBlankLine();
   text->AddLine(
-    "void RegisterWithDBusObject(chromeos::dbus_utils::DBusObject* object) {");
+    "void RegisterWithDBusObject(brillo::dbus_utils::DBusObject* object) {");
   text->PushOffset(kBlockOffset);
-  text->AddLine("chromeos::dbus_utils::DBusInterface* itf =");
+  text->AddLine("brillo::dbus_utils::DBusInterface* itf =");
   text->AddLineWithOffset(
       StringPrintf("object->AddOrGetInterface(\"%s\");",
                    interface.name.c_str()), kLineContinuationOffset);
@@ -213,7 +213,7 @@ void AdaptorGenerator::RegisterInterface(const string& itf_name,
       text->PushOffset(kLineContinuationOffset);
       text->AddLine(
           StringPrintf(
-              "chromeos::dbus_utils::ExportedPropertyBase::Access::%s);",
+              "brillo::dbus_utils::ExportedPropertyBase::Access::%s);",
               write_access.c_str()));
       text->PopOffset();
       text->AddLine(StringPrintf("%s_.SetValidator(", variable_name.c_str()));
@@ -258,7 +258,7 @@ void AdaptorGenerator::AddInterfaceMethods(const Interface& interface,
         }
         break;
       case Interface::Method::Kind::kNormal:
-        method_params.push_back("chromeos::ErrorPtr* error");
+        method_params.push_back("brillo::ErrorPtr* error");
         if (method.include_dbus_message)
           method_params.push_back("dbus::Message* message");
         return_type = "bool";
@@ -271,9 +271,9 @@ void AdaptorGenerator::AddInterfaceMethods(const Interface& interface,
           out_types.push_back(param_type);
         }
         method_params.push_back(base::StringPrintf(
-            "std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<%s>> "
+            "std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<%s>> "
             "response",
-             chromeos::string_utils::Join(", ", out_types).c_str()));
+             brillo::string_utils::Join(", ", out_types).c_str()));
         if (method.include_dbus_message)
           method_params.push_back("dbus::Message* message");
         output_arguments_copy.clear();
@@ -281,7 +281,7 @@ void AdaptorGenerator::AddInterfaceMethods(const Interface& interface,
       }
       case Interface::Method::Kind::kRaw:
         method_params.push_back("dbus::MethodCall* method_call");
-        method_params.push_back("chromeos::dbus_utils::ResponseSender sender");
+        method_params.push_back("brillo::dbus_utils::ResponseSender sender");
         // Raw methods don't take static parameters or return values directly.
         input_arguments_copy.clear();
         output_arguments_copy.clear();
@@ -361,7 +361,7 @@ void AdaptorGenerator::AddSendSignalMethods(
       block.PopOffset();
     }
 
-    string args = chromeos::string_utils::Join(", ", param_names);
+    string args = brillo::string_utils::Join(", ", param_names);
     block.PushOffset(kBlockOffset);
     block.AddLine(StringPrintf("auto signal = signal_%s_.lock();",
                                 signal.name.c_str()));
@@ -383,7 +383,7 @@ void AdaptorGenerator::AddSignalDataMembers(const Interface& interface,
   for (const auto& signal : interface.signals) {
     string signal_type_name = StringPrintf("Signal%sType", signal.name.c_str());
     string signal_type_alias_begin =
-        StringPrintf("using %s = chromeos::dbus_utils::DBusSignal<",
+        StringPrintf("using %s = brillo::dbus_utils::DBusSignal<",
                      signal_type_name.c_str());
     string signal_type_alias_end = ">;";
     vector<string> params;
@@ -464,7 +464,7 @@ void AdaptorGenerator::AddPropertyMethodImplementation(
       // validator callback function signature.
       block.AddLine(
           StringPrintf(
-              "chromeos::ErrorPtr* /*error*/, const %s& /*value*/) {",
+              "brillo::ErrorPtr* /*error*/, const %s& /*value*/) {",
               type.c_str()));
       block.PopOffset();
       block.PushOffset(kBlockOffset);
@@ -488,7 +488,7 @@ void AdaptorGenerator::AddPropertyDataMembers(const Interface& interface,
     string variable_name = NameParser{property.name}.MakeVariableName();
 
     block.AddLine(
-        StringPrintf("chromeos::dbus_utils::ExportedProperty<%s> %s_;",
+        StringPrintf("brillo::dbus_utils::ExportedProperty<%s> %s_;",
                      type.c_str(), variable_name.c_str()));
   }
   if (!interface.properties.empty())
diff --git a/chromeos-dbus-bindings/adaptor_generator_unittest.cc b/chromeos-dbus-bindings/adaptor_generator_unittest.cc
index 9d9fad7..4baf847 100644
--- a/chromeos-dbus-bindings/adaptor_generator_unittest.cc
+++ b/chromeos-dbus-bindings/adaptor_generator_unittest.cc
@@ -43,10 +43,10 @@ const char kExpectedContent[] = R"literal_string(
 
 #include <base/macros.h>
 #include <dbus/object_path.h>
-#include <chromeos/any.h>
-#include <chromeos/dbus/dbus_object.h>
-#include <chromeos/dbus/exported_object_manager.h>
-#include <chromeos/variant_dictionary.h>
+#include <brillo/any.h>
+#include <brillo/dbus/dbus_object.h>
+#include <brillo/dbus/exported_object_manager.h>
+#include <brillo/variant_dictionary.h>
 
 namespace org {
 namespace chromium {
@@ -57,19 +57,19 @@ class TestInterface {
   virtual ~TestInterface() = default;
 
   virtual bool Kaneda(
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       dbus::Message* message,
       const std::string& in_iwata,
       const std::vector<dbus::ObjectPath>& in_clarke,
       std::string* out_3) = 0;
   virtual bool Tetsuo(
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int32_t in_1,
       int64_t* out_2) = 0;
   virtual bool Kei(
-      chromeos::ErrorPtr* error) = 0;
+      brillo::ErrorPtr* error) = 0;
   virtual bool Kiyoko(
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int64_t* out_akira,
       std::string* out_2) = 0;
 };
@@ -79,8 +79,8 @@ class TestAdaptor {
  public:
   TestAdaptor(TestInterface* interface) : interface_(interface) {}
 
-  void RegisterWithDBusObject(chromeos::dbus_utils::DBusObject* object) {
-    chromeos::dbus_utils::DBusInterface* itf =
+  void RegisterWithDBusObject(brillo::dbus_utils::DBusObject* object) {
+    brillo::dbus_utils::DBusInterface* itf =
         object->AddOrGetInterface("org.chromium.Test");
 
     itf->AddSimpleMethodHandlerWithErrorAndMessage(
@@ -105,7 +105,7 @@ class TestAdaptor {
 
     itf->AddProperty(CharacterNameName(), &character_name_);
     write_property_.SetAccessMode(
-        chromeos::dbus_utils::ExportedPropertyBase::Access::kReadWrite);
+        brillo::dbus_utils::ExportedPropertyBase::Access::kReadWrite);
     write_property_.SetValidator(
         base::Bind(&TestAdaptor::ValidateWriteProperty,
                    base::Unretained(this)));
@@ -141,7 +141,7 @@ class TestAdaptor {
     write_property_.SetValue(write_property);
   }
   virtual bool ValidateWriteProperty(
-      chromeos::ErrorPtr* /*error*/, const std::string& /*value*/) {
+      brillo::ErrorPtr* /*error*/, const std::string& /*value*/) {
     return true;
   }
 
@@ -150,16 +150,16 @@ class TestAdaptor {
   }
 
  private:
-  using SignalUpdateType = chromeos::dbus_utils::DBusSignal<>;
+  using SignalUpdateType = brillo::dbus_utils::DBusSignal<>;
   std::weak_ptr<SignalUpdateType> signal_Update_;
 
-  using SignalMappingType = chromeos::dbus_utils::DBusSignal<
+  using SignalMappingType = brillo::dbus_utils::DBusSignal<
       std::string /*key*/,
       std::vector<dbus::ObjectPath>>;
   std::weak_ptr<SignalMappingType> signal_Mapping_;
 
-  chromeos::dbus_utils::ExportedProperty<std::string> character_name_;
-  chromeos::dbus_utils::ExportedProperty<std::string> write_property_;
+  brillo::dbus_utils::ExportedProperty<std::string> character_name_;
+  brillo::dbus_utils::ExportedProperty<std::string> write_property_;
 
   TestInterface* interface_;  // Owned by container of this adapter.
 
@@ -180,10 +180,10 @@ class Test2Interface {
   virtual std::string Kaneda2(
       const std::string& in_iwata) const = 0;
   virtual void Tetsuo2(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<int64_t>> response,
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<int64_t>> response,
       int32_t in_1) = 0;
   virtual void Kei2(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<bool>> response,
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<bool>> response,
       dbus::Message* message) = 0;
 };
 
@@ -192,8 +192,8 @@ class Test2Adaptor {
  public:
   Test2Adaptor(Test2Interface* interface) : interface_(interface) {}
 
-  void RegisterWithDBusObject(chromeos::dbus_utils::DBusObject* object) {
-    chromeos::dbus_utils::DBusInterface* itf =
+  void RegisterWithDBusObject(brillo::dbus_utils::DBusObject* object) {
+    brillo::dbus_utils::DBusInterface* itf =
         object->AddOrGetInterface("org.chromium.Test2");
 
     itf->AddSimpleMethodHandler(
diff --git a/chromeos-dbus-bindings/dbus_signature.cc b/chromeos-dbus-bindings/dbus_signature.cc
index a6e59d4..81b969f 100644
--- a/chromeos-dbus-bindings/dbus_signature.cc
+++ b/chromeos-dbus-bindings/dbus_signature.cc
@@ -6,7 +6,7 @@
 
 #include <base/logging.h>
 #include <base/strings/stringprintf.h>
-#include <chromeos/strings/string_utils.h>
+#include <brillo/strings/string_utils.h>
 #include <dbus/dbus-protocol.h>
 
 using base::StringPrintf;
@@ -30,9 +30,8 @@ const char DbusSignature::kUnixFdTypename[] = "dbus::FileDescriptor";
 const char DbusSignature::kUnsigned16Typename[] = "uint16_t";
 const char DbusSignature::kUnsigned32Typename[] = "uint32_t";
 const char DbusSignature::kUnsigned64Typename[] = "uint64_t";
-const char DbusSignature::kVariantTypename[] = "chromeos::Any";
-const char DbusSignature::kVariantDictTypename[] =
-    "chromeos::VariantDictionary";
+const char DbusSignature::kVariantTypename[] = "brillo::Any";
+const char DbusSignature::kVariantDictTypename[] = "brillo::VariantDictionary";
 const char DbusSignature::kTupleTypename[] = "std::tuple";
 
 DbusSignature::DbusSignature()
@@ -231,9 +230,8 @@ bool DbusSignature::GetStructTypenameForSignature(
   DCHECK_EQ(DBUS_STRUCT_END_CHAR, *cur);
   ++cur;
 
-  *output = StringPrintf(
-      "%s<%s>", kTupleTypename,
-      chromeos::string_utils::Join(", ", children).c_str());
+  *output = StringPrintf("%s<%s>", kTupleTypename,
+                         brillo::string_utils::Join(", ", children).c_str());
 
   if (next) {
     *next = cur;
diff --git a/chromeos-dbus-bindings/dbus_signature_unittest.cc b/chromeos-dbus-bindings/dbus_signature_unittest.cc
index 96ebbe5..a74772a 100644
--- a/chromeos-dbus-bindings/dbus_signature_unittest.cc
+++ b/chromeos-dbus-bindings/dbus_signature_unittest.cc
@@ -91,17 +91,17 @@ TEST_F(DbusSignatureTest, ParseSuccesses) {
     { "aay",            "std::vector<std::vector<uint8_t>>" },
     { "ao",             "std::vector<ObjectPathType>" },
     { "a{oa{sa{sv}}}",  "std::map<ObjectPathType, std::map<std::string, "
-                          "chromeos::VariantDictionary>>" },
+                          "brillo::VariantDictionary>>" },
     { "a{os}",          "std::map<ObjectPathType, std::string>" },
     { "as",             "std::vector<std::string>" },
     { "a{ss}",          "std::map<std::string, std::string>" },
     { "a{sa{ss}}",      "std::map<std::string, std::map<std::string, "
                           "std::string>>"},
-    { "a{sa{sv}}",      "std::map<std::string, chromeos::VariantDictionary>" },
-    { "a{sv}",          "chromeos::VariantDictionary" },
-    { "a{sv}Garbage",   "chromeos::VariantDictionary" },
+    { "a{sa{sv}}",      "std::map<std::string, brillo::VariantDictionary>" },
+    { "a{sv}",          "brillo::VariantDictionary" },
+    { "a{sv}Garbage",   "brillo::VariantDictionary" },
     { "at",             "std::vector<uint64_t>" },
-    { "a{iv}",          "std::map<int32_t, chromeos::Any>" },
+    { "a{iv}",          "std::map<int32_t, brillo::Any>" },
     { "(ib)",           "std::tuple<int32_t, bool>" },
     { "(ibs)",          "std::tuple<int32_t, bool, std::string>" },
   };
diff --git a/chromeos-dbus-bindings/generate_chromeos_dbus_bindings.cc b/chromeos-dbus-bindings/generate_chromeos_dbus_bindings.cc
index 8789b82..b22c141 100644
--- a/chromeos-dbus-bindings/generate_chromeos_dbus_bindings.cc
+++ b/chromeos-dbus-bindings/generate_chromeos_dbus_bindings.cc
@@ -12,7 +12,7 @@
 #include <base/logging.h>
 #include <base/strings/string_util.h>
 #include <base/values.h>
-#include <chromeos/syslog_logging.h>
+#include <brillo/syslog_logging.h>
 
 #include "chromeos-dbus-bindings/adaptor_generator.h"
 #include "chromeos-dbus-bindings/method_name_generator.h"
@@ -128,7 +128,7 @@ int main(int argc, char** argv) {
 
   // Setup logging to stderr. This also parses some implicit flags using the
   // CommandLine singleton.
-  chromeos::InitLog(chromeos::kLogToStderr | chromeos::kLogHeader);
+  brillo::InitLog(brillo::kLogToStderr | brillo::kLogHeader);
 
   if (cl->HasSwitch(switches::kHelp)) {
     LOG(INFO) << switches::kHelpMessage;
diff --git a/chromeos-dbus-bindings/header_generator.cc b/chromeos-dbus-bindings/header_generator.cc
index 0a24597..d69cd1c 100644
--- a/chromeos-dbus-bindings/header_generator.cc
+++ b/chromeos-dbus-bindings/header_generator.cc
@@ -10,7 +10,7 @@
 #include <base/files/file_util.h>
 #include <base/strings/string_util.h>
 #include <base/strings/stringprintf.h>
-#include <chromeos/strings/string_utils.h>
+#include <brillo/strings/string_utils.h>
 
 #include "chromeos-dbus-bindings/indented_text.h"
 
diff --git a/chromeos-dbus-bindings/indented_text.cc b/chromeos-dbus-bindings/indented_text.cc
index 8d42091..2af6419 100644
--- a/chromeos-dbus-bindings/indented_text.cc
+++ b/chromeos-dbus-bindings/indented_text.cc
@@ -10,7 +10,7 @@
 
 #include <base/logging.h>
 #include <base/strings/string_util.h>
-#include <chromeos/strings/string_utils.h>
+#include <brillo/strings/string_utils.h>
 
 using std::string;
 using std::vector;
@@ -61,7 +61,7 @@ void IndentedText::AddComments(const std::string& doc_string) {
   // For all subsequent lines, remove the same whitespace prefix as found
   // at the first line of the comment but keep any additional spaces to
   // maintain the comment layout.
-  auto lines = chromeos::string_utils::Split(doc_string, "\n", false, false);
+  auto lines = brillo::string_utils::Split(doc_string, "\n", false, false);
   vector<string> lines_out;
   lines_out.reserve(lines.size());
   bool first_nonempty_found = false;
diff --git a/chromeos-dbus-bindings/name_parser.cc b/chromeos-dbus-bindings/name_parser.cc
index 35cbb61..7f71e49 100644
--- a/chromeos-dbus-bindings/name_parser.cc
+++ b/chromeos-dbus-bindings/name_parser.cc
@@ -8,7 +8,7 @@
 
 #include <base/strings/string_util.h>
 #include <base/strings/stringprintf.h>
-#include <chromeos/strings/string_utils.h>
+#include <brillo/strings/string_utils.h>
 
 #include "chromeos-dbus-bindings/indented_text.h"
 
@@ -27,7 +27,7 @@ void AddCloseNamespace(IndentedText *text, const std::string& name) {
 }  // anonymous namespace
 
 NameParser::NameParser(const std::string& name)
-    : namespaces{chromeos::string_utils::Split(name, ".")} {
+    : namespaces{brillo::string_utils::Split(name, ".")} {
   CHECK(!namespaces.empty()) << "Empty name specified";
   type_name = namespaces.back();
   namespaces.pop_back();
@@ -36,7 +36,7 @@ NameParser::NameParser(const std::string& name)
 std::string NameParser::MakeFullyQualified(const std::string& name) const {
   std::vector<std::string> parts = namespaces;
   parts.push_back(name);
-  return chromeos::string_utils::Join("::", parts);
+  return brillo::string_utils::Join("::", parts);
 }
 
 std::string NameParser::MakeFullCppName() const {
diff --git a/chromeos-dbus-bindings/proxy_generator.cc b/chromeos-dbus-bindings/proxy_generator.cc
index 717740d..9ce0117 100644
--- a/chromeos-dbus-bindings/proxy_generator.cc
+++ b/chromeos-dbus-bindings/proxy_generator.cc
@@ -10,7 +10,7 @@
 #include <base/format_macros.h>
 #include <base/logging.h>
 #include <base/strings/stringprintf.h>
-#include <chromeos/strings/string_utils.h>
+#include <brillo/strings/string_utils.h>
 
 #include "chromeos-dbus-bindings/dbus_signature.h"
 #include "chromeos-dbus-bindings/indented_text.h"
@@ -64,12 +64,12 @@ bool ProxyGenerator::GenerateProxies(
   text.AddLine("#include <base/logging.h>");
   text.AddLine("#include <base/macros.h>");
   text.AddLine("#include <base/memory/ref_counted.h>");
-  text.AddLine("#include <chromeos/any.h>");
-  text.AddLine("#include <chromeos/dbus/dbus_method_invoker.h>");
-  text.AddLine("#include <chromeos/dbus/dbus_property.h>");
-  text.AddLine("#include <chromeos/dbus/dbus_signal_handler.h>");
-  text.AddLine("#include <chromeos/errors/error.h>");
-  text.AddLine("#include <chromeos/variant_dictionary.h>");
+  text.AddLine("#include <brillo/any.h>");
+  text.AddLine("#include <brillo/dbus/dbus_method_invoker.h>");
+  text.AddLine("#include <brillo/dbus/dbus_property.h>");
+  text.AddLine("#include <brillo/dbus/dbus_signal_handler.h>");
+  text.AddLine("#include <brillo/errors/error.h>");
+  text.AddLine("#include <brillo/variant_dictionary.h>");
   text.AddLine("#include <dbus/bus.h>");
   text.AddLine("#include <dbus/message.h>");
   text.AddLine("#include <dbus/object_manager.h>");
@@ -119,9 +119,9 @@ bool ProxyGenerator::GenerateMocks(const ServiceConfig& config,
   text.AddLine("#include <base/callback_forward.h>");
   text.AddLine("#include <base/logging.h>");
   text.AddLine("#include <base/macros.h>");
-  text.AddLine("#include <chromeos/any.h>");
-  text.AddLine("#include <chromeos/errors/error.h>");
-  text.AddLine("#include <chromeos/variant_dictionary.h>");
+  text.AddLine("#include <brillo/any.h>");
+  text.AddLine("#include <brillo/errors/error.h>");
+  text.AddLine("#include <brillo/variant_dictionary.h>");
   text.AddLine("#include <gmock/gmock.h>");
   text.AddBlankLine();
 
@@ -477,7 +477,7 @@ void ProxyGenerator::AddSignalHandlerRegistration(
   if (!declaration_only) {
     block.PopOffset();  // Method signature arguments
     block.PushOffset(kBlockOffset);
-    block.AddLine("chromeos::dbus_utils::ConnectToSignal(");
+    block.AddLine("brillo::dbus_utils::ConnectToSignal(");
     block.PushOffset(kLineContinuationOffset);
     block.AddLine("dbus_object_proxy_,");
     block.AddLine(StringPrintf("\"%s\",", interface_name.c_str()));
@@ -529,7 +529,7 @@ void ProxyGenerator::AddPropertySet(const ServiceConfig& config,
     string type;
     CHECK(signature.Parse(prop.type, &type));
     block.AddLine(
-        StringPrintf("chromeos::dbus_utils::Property<%s> %s;",
+        StringPrintf("brillo::dbus_utils::Property<%s> %s;",
                      type.c_str(),
                      NameParser{prop.name}.MakeVariableName().c_str()));
   }
@@ -619,7 +619,7 @@ void ProxyGenerator::AddMethodProxy(const Interface::Method& method,
     block.AddLine(StringPrintf(
         "%s* %s,", argument_type.c_str(), argument_name.c_str()));
   }
-  block.AddLine("chromeos::ErrorPtr* error,");
+  block.AddLine("brillo::ErrorPtr* error,");
   block.AddLine(
       StringPrintf("int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT)%s",
                    declaration_only ? " = 0;" : " override {"));
@@ -628,7 +628,7 @@ void ProxyGenerator::AddMethodProxy(const Interface::Method& method,
     block.PushOffset(kBlockOffset);
 
     block.AddLine(
-        "auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(");
+        "auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(");
     block.PushOffset(kLineContinuationOffset);
     block.AddLine("timeout_ms,");
     block.AddLine("dbus_object_proxy_,");
@@ -643,9 +643,9 @@ void ProxyGenerator::AddMethodProxy(const Interface::Method& method,
     block.PopOffset();
 
     block.AddLine("return response && "
-                  "chromeos::dbus_utils::ExtractMethodCallResults(");
+                  "brillo::dbus_utils::ExtractMethodCallResults(");
     block.PushOffset(kLineContinuationOffset);
-    block.AddLine(chromeos::string_utils::Join(", ", out_param_names) + ");");
+    block.AddLine(brillo::string_utils::Join(", ", out_param_names) + ");");
     block.PopOffset();
     block.PopOffset();
     block.AddLine("}");
@@ -688,9 +688,9 @@ void ProxyGenerator::AddAsyncMethodProxy(const Interface::Method& method,
   }
   block.AddLine(StringPrintf(
       "const base::Callback<void(%s)>& success_callback,",
-      chromeos::string_utils::Join(", ", out_params).c_str()));
+      brillo::string_utils::Join(", ", out_params).c_str()));
   block.AddLine(
-      "const base::Callback<void(chromeos::Error*)>& error_callback,");
+      "const base::Callback<void(brillo::Error*)>& error_callback,");
   block.AddLine(
       StringPrintf("int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT)%s",
                    declaration_only ? " = 0;" : " override {"));
@@ -698,7 +698,7 @@ void ProxyGenerator::AddAsyncMethodProxy(const Interface::Method& method,
   if (!declaration_only) {
     block.PushOffset(kBlockOffset);
 
-    block.AddLine("chromeos::dbus_utils::CallMethodWithTimeout(");
+    block.AddLine("brillo::dbus_utils::CallMethodWithTimeout(");
     block.PushOffset(kLineContinuationOffset);
     block.AddLine("timeout_ms,");
     block.AddLine("dbus_object_proxy_,");
@@ -741,7 +741,7 @@ void ProxyGenerator::AddMethodMock(const Interface::Method& method,
       base::StringAppendF(&argument_type, " /*out_%s*/", argument.name.c_str());
     arguments.push_back(argument_type);
   }
-  arguments.push_back("chromeos::ErrorPtr* /*error*/");
+  arguments.push_back("brillo::ErrorPtr* /*error*/");
   arguments.push_back("int /*timeout_ms*/");
   AddMockMethodDeclaration(method.name, "bool", arguments, text);
 }
@@ -771,9 +771,9 @@ void ProxyGenerator::AddAsyncMethodMock(const Interface::Method& method,
   }
   arguments.push_back(StringPrintf(
       "const base::Callback<void(%s)>& /*success_callback*/",
-      chromeos::string_utils::Join(", ", out_params).c_str()));
+      brillo::string_utils::Join(", ", out_params).c_str()));
   arguments.push_back(
-      "const base::Callback<void(chromeos::Error*)>& /*error_callback*/");
+      "const base::Callback<void(brillo::Error*)>& /*error_callback*/");
   arguments.push_back("int /*timeout_ms*/");
   AddMockMethodDeclaration(method.name + "Async", "void", arguments, text);
 }
@@ -813,7 +813,7 @@ void ProxyGenerator::AddMockMethodDeclaration(const string& method_name,
     block.AddLine("}");
   } else {
     block.AddLineAndPushOffsetTo(
-        StringPrintf("MOCK_METHOD%ju(%s,",
+        StringPrintf("MOCK_METHOD%zu(%s,",
                      arguments.size(), method_name.c_str()),
         1, '(');
     block.AddLineAndPushOffsetTo(
diff --git a/chromeos-dbus-bindings/proxy_generator_mock_unittest.cc b/chromeos-dbus-bindings/proxy_generator_mock_unittest.cc
index 541b827..76f0ee5 100644
--- a/chromeos-dbus-bindings/proxy_generator_mock_unittest.cc
+++ b/chromeos-dbus-bindings/proxy_generator_mock_unittest.cc
@@ -38,9 +38,9 @@ const char kExpectedContent[] = R"literal_string(
 #include <base/callback_forward.h>
 #include <base/logging.h>
 #include <base/macros.h>
-#include <chromeos/any.h>
-#include <chromeos/errors/error.h>
-#include <chromeos/variant_dictionary.h>
+#include <brillo/any.h>
+#include <brillo/errors/error.h>
+#include <brillo/variant_dictionary.h>
 #include <gmock/gmock.h>
 
 #include "proxies.h"
@@ -57,37 +57,37 @@ class TestInterfaceProxyMock : public TestInterfaceProxyInterface {
                bool(const std::string& /*in_space_walk*/,
                     const std::vector<dbus::ObjectPath>& /*in_ramblin_man*/,
                     std::string*,
-                    chromeos::ErrorPtr* /*error*/,
+                    brillo::ErrorPtr* /*error*/,
                     int /*timeout_ms*/));
   MOCK_METHOD5(ElementsAsync,
                void(const std::string& /*in_space_walk*/,
                     const std::vector<dbus::ObjectPath>& /*in_ramblin_man*/,
                     const base::Callback<void(const std::string&)>& /*success_callback*/,
-                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    const base::Callback<void(brillo::Error*)>& /*error_callback*/,
                     int /*timeout_ms*/));
   MOCK_METHOD3(ReturnToPatagonia,
                bool(int64_t*,
-                    chromeos::ErrorPtr* /*error*/,
+                    brillo::ErrorPtr* /*error*/,
                     int /*timeout_ms*/));
   MOCK_METHOD3(ReturnToPatagoniaAsync,
                void(const base::Callback<void(int64_t)>& /*success_callback*/,
-                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    const base::Callback<void(brillo::Error*)>& /*error_callback*/,
                     int /*timeout_ms*/));
   MOCK_METHOD3(NiceWeatherForDucks,
                bool(bool,
-                    chromeos::ErrorPtr* /*error*/,
+                    brillo::ErrorPtr* /*error*/,
                     int /*timeout_ms*/));
   MOCK_METHOD4(NiceWeatherForDucksAsync,
                void(bool,
                     const base::Callback<void()>& /*success_callback*/,
-                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    const base::Callback<void(brillo::Error*)>& /*error_callback*/,
                     int /*timeout_ms*/));
   MOCK_METHOD2(ExperimentNumberSix,
-               bool(chromeos::ErrorPtr* /*error*/,
+               bool(brillo::ErrorPtr* /*error*/,
                     int /*timeout_ms*/));
   MOCK_METHOD3(ExperimentNumberSixAsync,
                void(const base::Callback<void()>& /*success_callback*/,
-                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    const base::Callback<void(brillo::Error*)>& /*error_callback*/,
                     int /*timeout_ms*/));
   bool AllTheWayUpToEleven(bool /*in_arg1*/,
                            bool /*in_arg2*/,
@@ -98,7 +98,7 @@ class TestInterfaceProxyMock : public TestInterfaceProxyInterface {
                            bool /*in_arg7*/,
                            bool /*in_arg8*/,
                            bool* /*out_arg9*/,
-                           chromeos::ErrorPtr* /*error*/,
+                           brillo::ErrorPtr* /*error*/,
                            int /*timeout_ms*/) override {
     LOG(WARNING) << "AllTheWayUpToEleven(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
     return false;
@@ -112,7 +112,7 @@ class TestInterfaceProxyMock : public TestInterfaceProxyInterface {
                                 bool /*in_arg7*/,
                                 bool /*in_arg8*/,
                                 const base::Callback<void(bool /*arg9*/)>& /*success_callback*/,
-                                const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                                const base::Callback<void(brillo::Error*)>& /*error_callback*/,
                                 int /*timeout_ms*/) override {
     LOG(WARNING) << "AllTheWayUpToElevenAsync(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
   }
@@ -141,11 +141,11 @@ class TestInterface2ProxyMock : public TestInterface2ProxyInterface {
   MOCK_METHOD4(GetPersonInfo,
                bool(std::string* /*out_name*/,
                     int32_t* /*out_age*/,
-                    chromeos::ErrorPtr* /*error*/,
+                    brillo::ErrorPtr* /*error*/,
                     int /*timeout_ms*/));
   MOCK_METHOD3(GetPersonInfoAsync,
                void(const base::Callback<void(const std::string& /*name*/, int32_t /*age*/)>& /*success_callback*/,
-                    const base::Callback<void(chromeos::Error*)>& /*error_callback*/,
+                    const base::Callback<void(brillo::Error*)>& /*error_callback*/,
                     int /*timeout_ms*/));
 
  private:
diff --git a/chromeos-dbus-bindings/proxy_generator_unittest.cc b/chromeos-dbus-bindings/proxy_generator_unittest.cc
index 75b7e9f..ccbd1fe 100644
--- a/chromeos-dbus-bindings/proxy_generator_unittest.cc
+++ b/chromeos-dbus-bindings/proxy_generator_unittest.cc
@@ -41,12 +41,12 @@ const char kExpectedContent[] = R"literal_string(
 #include <base/logging.h>
 #include <base/macros.h>
 #include <base/memory/ref_counted.h>
-#include <chromeos/any.h>
-#include <chromeos/dbus/dbus_method_invoker.h>
-#include <chromeos/dbus/dbus_property.h>
-#include <chromeos/dbus/dbus_signal_handler.h>
-#include <chromeos/errors/error.h>
-#include <chromeos/variant_dictionary.h>
+#include <brillo/any.h>
+#include <brillo/dbus/dbus_method_invoker.h>
+#include <brillo/dbus/dbus_property.h>
+#include <brillo/dbus/dbus_signal_handler.h>
+#include <brillo/errors/error.h>
+#include <brillo/variant_dictionary.h>
 #include <dbus/bus.h>
 #include <dbus/message.h>
 #include <dbus/object_manager.h>
@@ -65,48 +65,48 @@ class TestInterfaceProxyInterface {
       const std::string& in_space_walk,
       const std::vector<dbus::ObjectPath>& in_ramblin_man,
       std::string* out_3,
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 
   virtual void ElementsAsync(
       const std::string& in_space_walk,
       const std::vector<dbus::ObjectPath>& in_ramblin_man,
       const base::Callback<void(const std::string&)>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 
   virtual bool ReturnToPatagonia(
       int64_t* out_1,
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 
   virtual void ReturnToPatagoniaAsync(
       const base::Callback<void(int64_t)>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 
   virtual bool NiceWeatherForDucks(
       bool in_1,
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 
   virtual void NiceWeatherForDucksAsync(
       bool in_1,
       const base::Callback<void()>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 
   // Comment line1
   // line2
   virtual bool ExperimentNumberSix(
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 
   // Comment line1
   // line2
   virtual void ExperimentNumberSixAsync(
       const base::Callback<void()>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 
   virtual void RegisterCloserSignalHandler(
@@ -143,7 +143,7 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
   void RegisterCloserSignalHandler(
       const base::Closure& signal_callback,
       dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
-    chromeos::dbus_utils::ConnectToSignal(
+    brillo::dbus_utils::ConnectToSignal(
         dbus_object_proxy_,
         "org.chromium.TestInterface",
         "Closer",
@@ -155,7 +155,7 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
       const base::Callback<void(const std::vector<std::string>&,
                                 uint8_t)>& signal_callback,
       dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
-    chromeos::dbus_utils::ConnectToSignal(
+    brillo::dbus_utils::ConnectToSignal(
         dbus_object_proxy_,
         "org.chromium.TestInterface",
         "TheCurseOfKaZar",
@@ -177,9 +177,9 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
       const std::string& in_space_walk,
       const std::vector<dbus::ObjectPath>& in_ramblin_man,
       std::string* out_3,
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface",
@@ -187,7 +187,7 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
         error,
         in_space_walk,
         in_ramblin_man);
-    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+    return response && brillo::dbus_utils::ExtractMethodCallResults(
         response.get(), error, out_3);
   }
 
@@ -195,9 +195,9 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
       const std::string& in_space_walk,
       const std::vector<dbus::ObjectPath>& in_ramblin_man,
       const base::Callback<void(const std::string&)>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    chromeos::dbus_utils::CallMethodWithTimeout(
+    brillo::dbus_utils::CallMethodWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface",
@@ -210,23 +210,23 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
 
   bool ReturnToPatagonia(
       int64_t* out_1,
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface",
         "ReturnToPatagonia",
         error);
-    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+    return response && brillo::dbus_utils::ExtractMethodCallResults(
         response.get(), error, out_1);
   }
 
   void ReturnToPatagoniaAsync(
       const base::Callback<void(int64_t)>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    chromeos::dbus_utils::CallMethodWithTimeout(
+    brillo::dbus_utils::CallMethodWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface",
@@ -237,25 +237,25 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
 
   bool NiceWeatherForDucks(
       bool in_1,
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface",
         "NiceWeatherForDucks",
         error,
         in_1);
-    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+    return response && brillo::dbus_utils::ExtractMethodCallResults(
         response.get(), error);
   }
 
   void NiceWeatherForDucksAsync(
       bool in_1,
       const base::Callback<void()>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    chromeos::dbus_utils::CallMethodWithTimeout(
+    brillo::dbus_utils::CallMethodWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface",
@@ -268,15 +268,15 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
   // Comment line1
   // line2
   bool ExperimentNumberSix(
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface",
         "ExperimentNumberSix",
         error);
-    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+    return response && brillo::dbus_utils::ExtractMethodCallResults(
         response.get(), error);
   }
 
@@ -284,9 +284,9 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
   // line2
   void ExperimentNumberSixAsync(
       const base::Callback<void()>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    chromeos::dbus_utils::CallMethodWithTimeout(
+    brillo::dbus_utils::CallMethodWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface",
@@ -318,12 +318,12 @@ class TestInterface2ProxyInterface {
   virtual bool GetPersonInfo(
       std::string* out_name,
       int32_t* out_age,
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 
   virtual void GetPersonInfoAsync(
       const base::Callback<void(const std::string& /*name*/, int32_t /*age*/)>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
 };
 
@@ -363,23 +363,23 @@ class TestInterface2Proxy final : public TestInterface2ProxyInterface {
   bool GetPersonInfo(
       std::string* out_name,
       int32_t* out_age,
-      chromeos::ErrorPtr* error,
+      brillo::ErrorPtr* error,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    auto response = chromeos::dbus_utils::CallMethodAndBlockWithTimeout(
+    auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface2",
         "GetPersonInfo",
         error);
-    return response && chromeos::dbus_utils::ExtractMethodCallResults(
+    return response && brillo::dbus_utils::ExtractMethodCallResults(
         response.get(), error, out_name, out_age);
   }
 
   void GetPersonInfoAsync(
       const base::Callback<void(const std::string& /*name*/, int32_t /*age*/)>& success_callback,
-      const base::Callback<void(chromeos::Error*)>& error_callback,
+      const base::Callback<void(brillo::Error*)>& error_callback,
       int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
-    chromeos::dbus_utils::CallMethodWithTimeout(
+    brillo::dbus_utils::CallMethodWithTimeout(
         timeout_ms,
         dbus_object_proxy_,
         "org.chromium.TestInterface2",
@@ -411,12 +411,12 @@ const char kExpectedContentWithService[] = R"literal_string(
 #include <base/logging.h>
 #include <base/macros.h>
 #include <base/memory/ref_counted.h>
-#include <chromeos/any.h>
-#include <chromeos/dbus/dbus_method_invoker.h>
-#include <chromeos/dbus/dbus_property.h>
-#include <chromeos/dbus/dbus_signal_handler.h>
-#include <chromeos/errors/error.h>
-#include <chromeos/variant_dictionary.h>
+#include <brillo/any.h>
+#include <brillo/dbus/dbus_method_invoker.h>
+#include <brillo/dbus/dbus_property.h>
+#include <brillo/dbus/dbus_signal_handler.h>
+#include <brillo/errors/error.h>
+#include <brillo/variant_dictionary.h>
 #include <dbus/bus.h>
 #include <dbus/message.h>
 #include <dbus/object_manager.h>
@@ -457,7 +457,7 @@ class TestInterfaceProxy final : public TestInterfaceProxyInterface {
   void RegisterCloserSignalHandler(
       const base::Closure& signal_callback,
       dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
-    chromeos::dbus_utils::ConnectToSignal(
+    brillo::dbus_utils::ConnectToSignal(
         dbus_object_proxy_,
         "org.chromium.TestInterface",
         "Closer",
@@ -550,12 +550,12 @@ const char kExpectedContentWithObjectManager[] = R"literal_string(
 #include <base/logging.h>
 #include <base/macros.h>
 #include <base/memory/ref_counted.h>
-#include <chromeos/any.h>
-#include <chromeos/dbus/dbus_method_invoker.h>
-#include <chromeos/dbus/dbus_property.h>
-#include <chromeos/dbus/dbus_signal_handler.h>
-#include <chromeos/errors/error.h>
-#include <chromeos/variant_dictionary.h>
+#include <brillo/any.h>
+#include <brillo/dbus/dbus_method_invoker.h>
+#include <brillo/dbus/dbus_property.h>
+#include <brillo/dbus/dbus_signal_handler.h>
+#include <brillo/errors/error.h>
+#include <brillo/variant_dictionary.h>
 #include <dbus/bus.h>
 #include <dbus/message.h>
 #include <dbus/object_manager.h>
@@ -603,7 +603,7 @@ class Itf1Proxy final : public Itf1ProxyInterface {
       RegisterProperty(DataName(), &data);
     }
 
-    chromeos::dbus_utils::Property<std::string> data;
+    brillo::dbus_utils::Property<std::string> data;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(PropertySet);
@@ -626,7 +626,7 @@ class Itf1Proxy final : public Itf1ProxyInterface {
   void RegisterCloserSignalHandler(
       const base::Closure& signal_callback,
       dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
-    chromeos::dbus_utils::ConnectToSignal(
+    brillo::dbus_utils::ConnectToSignal(
         dbus_object_proxy_,
         "org.chromium.Itf1",
         "Closer",
@@ -932,12 +932,12 @@ const char kExpectedContentWithObjectManagerAndServiceName[] = R"literal_string(
 #include <base/logging.h>
 #include <base/macros.h>
 #include <base/memory/ref_counted.h>
-#include <chromeos/any.h>
-#include <chromeos/dbus/dbus_method_invoker.h>
-#include <chromeos/dbus/dbus_property.h>
-#include <chromeos/dbus/dbus_signal_handler.h>
-#include <chromeos/errors/error.h>
-#include <chromeos/variant_dictionary.h>
+#include <brillo/any.h>
+#include <brillo/dbus/dbus_method_invoker.h>
+#include <brillo/dbus/dbus_property.h>
+#include <brillo/dbus/dbus_signal_handler.h>
+#include <brillo/errors/error.h>
+#include <brillo/variant_dictionary.h>
 #include <dbus/bus.h>
 #include <dbus/message.h>
 #include <dbus/object_manager.h>
@@ -998,7 +998,7 @@ class Itf1Proxy final : public Itf1ProxyInterface {
   void RegisterCloserSignalHandler(
       const base::Closure& signal_callback,
       dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
-    chromeos::dbus_utils::ConnectToSignal(
+    brillo::dbus_utils::ConnectToSignal(
         dbus_object_proxy_,
         "org.chromium.Itf1",
         "Closer",
diff --git a/chromeos-dbus-bindings/test_utils.cc b/chromeos-dbus-bindings/test_utils.cc
index 5d019df..34d8a22 100644
--- a/chromeos-dbus-bindings/test_utils.cc
+++ b/chromeos-dbus-bindings/test_utils.cc
@@ -10,7 +10,7 @@
 #include <base/files/file_path.h>
 #include <base/files/file_util.h>
 #include <base/logging.h>
-#include <chromeos/process.h>
+#include <brillo/process.h>
 #include <gtest/gtest.h>
 
 using std::string;
@@ -28,7 +28,7 @@ string GetUnifiedDiff(const string& a, const string& b) {
   WriteFile(path_a, a.data(), a.size());
   WriteFile(path_b, b.data(), b.size());
 
-  chromeos::ProcessImpl proc;
+  brillo::ProcessImpl proc;
   proc.AddArg("diff");
   proc.AddArg("-u");
   proc.AddArg(path_a.value());
diff --git a/chromeos-dbus-bindings/testrunner.cc b/chromeos-dbus-bindings/testrunner.cc
index 0777904..a51db6d 100644
--- a/chromeos-dbus-bindings/testrunner.cc
+++ b/chromeos-dbus-bindings/testrunner.cc
@@ -4,13 +4,13 @@
 
 #include <base/at_exit.h>
 #include <base/command_line.h>
-#include <chromeos/syslog_logging.h>
+#include <brillo/syslog_logging.h>
 #include <gtest/gtest.h>
 
 int main(int argc, char** argv) {
   base::AtExitManager exit_manager;
   base::CommandLine::Init(argc, argv);
-  chromeos::InitLog(chromeos::kLogToStderr);
+  brillo::InitLog(brillo::kLogToStderr);
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
diff --git a/chromeos-dbus-bindings/xml_interface_parser.cc b/chromeos-dbus-bindings/xml_interface_parser.cc
index cb07e31..3f574e1 100644
--- a/chromeos-dbus-bindings/xml_interface_parser.cc
+++ b/chromeos-dbus-bindings/xml_interface_parser.cc
@@ -10,7 +10,7 @@
 #include <base/files/file_util.h>
 #include <base/logging.h>
 #include <base/strings/string_util.h>
-#include <chromeos/strings/string_utils.h>
+#include <brillo/strings/string_utils.h>
 
 using std::string;
 using std::vector;
@@ -53,7 +53,7 @@ const char XmlInterfaceParser::kMethodKindRaw[] = "raw";
 namespace {
 
 string GetElementPath(const vector<string>& path) {
-  return chromeos::string_utils::Join("/", path);
+  return brillo::string_utils::Join("/", path);
 }
 
 }  // anonymous namespace