apmanager: 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 for aosp and brillo, all unit tests pass on dragonboard
Change-Id: I4c6efbc5bbf80d251e5d91bc3db49f02bc0e4732

26 files changed, 169 insertions, 169 deletions

diff --git a/config.cc b/config.cc
index f3e2027..ba865e0 100644
--- a/config.cc
+++ b/config.cc
@@ -28,9 +28,9 @@
 #include "apmanager/device.h"
 #include "apmanager/manager.h"
 
-using chromeos::dbus_utils::AsyncEventSequencer;
-using chromeos::dbus_utils::ExportedObjectManager;
-using chromeos::ErrorPtr;
+using brillo::dbus_utils::AsyncEventSequencer;
+using brillo::dbus_utils::ExportedObjectManager;
+using brillo::ErrorPtr;
 using std::string;
 
 namespace apmanager {
@@ -124,8 +124,8 @@ bool Config::GetFrequencyFromChannel(uint16_t channel, uint32_t* freq) {
 
 bool Config::ValidateSsid(ErrorPtr* error, const string& value) {
   if (value.length() < kSsidMinLength || value.length() > kSsidMaxLength) {
-    chromeos::Error::AddToPrintf(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+    brillo::Error::AddToPrintf(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
         "SSID must contain between %d and %d characters",
         kSsidMinLength, kSsidMaxLength);
     return false;
@@ -135,8 +135,8 @@ bool Config::ValidateSsid(ErrorPtr* error, const string& value) {
 
 bool Config::ValidateSecurityMode(ErrorPtr* error, const string& value) {
   if (value != kSecurityModeNone && value != kSecurityModeRSN) {
-    chromeos::Error::AddToPrintf(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+    brillo::Error::AddToPrintf(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
         "Invalid/unsupported security mode [%s]", value.c_str());
     return false;
   }
@@ -146,8 +146,8 @@ bool Config::ValidateSecurityMode(ErrorPtr* error, const string& value) {
 bool Config::ValidatePassphrase(ErrorPtr* error, const string& value) {
   if (value.length() < kPassphraseMinLength ||
       value.length() > kPassphraseMaxLength) {
-    chromeos::Error::AddToPrintf(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+    brillo::Error::AddToPrintf(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
         "Passphrase must contain between %d and %d characters",
         kPassphraseMinLength, kPassphraseMaxLength);
     return false;
@@ -159,8 +159,8 @@ bool Config::ValidateHwMode(ErrorPtr* error, const string& value) {
   if (value != kHwMode80211a && value != kHwMode80211b &&
       value != kHwMode80211g && value != kHwMode80211n &&
       value != kHwMode80211ac) {
-    chromeos::Error::AddToPrintf(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+    brillo::Error::AddToPrintf(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
         "Invalid HW mode [%s]", value.c_str());
     return false;
   }
@@ -169,8 +169,8 @@ bool Config::ValidateHwMode(ErrorPtr* error, const string& value) {
 
 bool Config::ValidateOperationMode(ErrorPtr* error, const string& value) {
   if (value != kOperationModeServer && value != kOperationModeBridge) {
-    chromeos::Error::AddToPrintf(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+    brillo::Error::AddToPrintf(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
         "Invalid operation mode [%s]", value.c_str());
     return false;
   }
@@ -182,8 +182,8 @@ bool Config::ValidateChannel(ErrorPtr* error, const uint16_t& value) {
       (value >= kBand5GHzChannelLow && value <= kBand5GHzChannelHigh)) {
     return true;
   }
-  chromeos::Error::AddToPrintf(
-      error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+  brillo::Error::AddToPrintf(
+      error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
       "Invalid channel [%d]", value);
   return false;
 }
@@ -193,7 +193,7 @@ void Config::RegisterAsync(ExportedObjectManager* object_manager,
                            AsyncEventSequencer* sequencer) {
   CHECK(!dbus_object_) << "Already registered";
   dbus_object_.reset(
-      new chromeos::dbus_utils::DBusObject(
+      new brillo::dbus_utils::DBusObject(
           object_manager,
           bus,
           dbus_path_));
@@ -206,8 +206,8 @@ bool Config::GenerateConfigFile(ErrorPtr* error, string* config_str) {
   // SSID.
   string ssid = GetSsid();
   if (ssid.empty()) {
-    chromeos::Error::AddTo(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+    brillo::Error::AddTo(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
         "SSID not specified");
     return false;
   }
@@ -217,8 +217,8 @@ bool Config::GenerateConfigFile(ErrorPtr* error, string* config_str) {
   // Bridge interface is required for bridge mode operation.
   if (GetOperationMode() == kOperationModeBridge) {
     if (GetBridgeInterface().empty()) {
-      chromeos::Error::AddTo(
-          error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+      brillo::Error::AddTo(
+          error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
           "Bridge interface not specified, required for bridge mode");
       return false;
     }
@@ -304,8 +304,8 @@ bool Config::AppendHwMode(ErrorPtr* error, std::string* config_str) {
     // Get HT Capability.
     string ht_cap;
     if (!device_->GetHTCapability(GetChannel(), &ht_cap)) {
-      chromeos::Error::AddTo(
-          error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+      brillo::Error::AddTo(
+          error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
           "Failed to get HT Capability");
       return false;
     }
@@ -323,8 +323,8 @@ bool Config::AppendHwMode(ErrorPtr* error, std::string* config_str) {
     // TODO(zqiu): Determine VHT Capabilities based on the interface PHY's
     // capababilites.
   } else {
-    chromeos::Error::AddToPrintf(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+    brillo::Error::AddToPrintf(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
         "Invalid hardware mode: %s", hw_mode.c_str());
     return false;
   }
@@ -362,23 +362,23 @@ bool Config::AppendInterface(ErrorPtr* error,
     // Ask manager for unused ap capable device.
     device_ = manager_->GetAvailableDevice();
     if (!device_) {
-      chromeos::Error::AddTo(
-          error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+      brillo::Error::AddTo(
+          error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
           "No device available");
       return false;
     }
   } else {
     device_ = manager_->GetDeviceFromInterfaceName(interface);
     if (!device_) {
-      chromeos::Error::AddToPrintf(
-          error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+      brillo::Error::AddToPrintf(
+          error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
           "Unable to find device for the specified interface [%s]",
           interface.c_str());
       return false;
     }
     if (device_->GetInUse()) {
-      chromeos::Error::AddToPrintf(
-          error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+      brillo::Error::AddToPrintf(
+          error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
           "Device [%s] for interface [%s] already in use",
           device_->GetDeviceName().c_str(),
           interface.c_str());
@@ -406,8 +406,8 @@ bool Config::AppendSecurityMode(ErrorPtr* error,
   if (security_mode == kSecurityModeRSN) {
     string passphrase = GetPassphrase();
     if (passphrase.empty()) {
-      chromeos::Error::AddToPrintf(
-          error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+      brillo::Error::AddToPrintf(
+          error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
           "Passphrase not set for security mode: %s", security_mode.c_str());
       return false;
     }
@@ -428,8 +428,8 @@ bool Config::AppendSecurityMode(ErrorPtr* error,
     return true;
   }
 
-  chromeos::Error::AddToPrintf(
-      error, FROM_HERE, chromeos::errors::dbus::kDomain, kConfigError,
+  brillo::Error::AddToPrintf(
+      error, FROM_HERE, brillo::errors::dbus::kDomain, kConfigError,
       "Invalid security mode: %s", security_mode.c_str());
   return false;
 }
diff --git a/config.h b/config.h
index 777927b..228f12d 100644
--- a/config.h
+++ b/config.h
@@ -21,7 +21,7 @@
 #include <string>
 
 #include <base/macros.h>
-#include <chromeos/errors/error.h>
+#include <brillo/errors/error.h>
 
 #include "dbus_bindings/org.chromium.apmanager.Config.h"
 
@@ -38,17 +38,17 @@ class Config
   virtual ~Config();
 
   // Override ConfigAdaptor Validate functions.
-  bool ValidateSsid(chromeos::ErrorPtr* error,
+  bool ValidateSsid(brillo::ErrorPtr* error,
                     const std::string& value) override;
-  bool ValidateSecurityMode(chromeos::ErrorPtr* error,
+  bool ValidateSecurityMode(brillo::ErrorPtr* error,
                             const std::string& value) override;
-  bool ValidatePassphrase(chromeos::ErrorPtr* error,
+  bool ValidatePassphrase(brillo::ErrorPtr* error,
                           const std::string& value) override;
-  bool ValidateHwMode(chromeos::ErrorPtr* error,
+  bool ValidateHwMode(brillo::ErrorPtr* error,
                       const std::string& value) override;
-  bool ValidateOperationMode(chromeos::ErrorPtr* error,
+  bool ValidateOperationMode(brillo::ErrorPtr* error,
                              const std::string& value) override;
-  bool ValidateChannel(chromeos::ErrorPtr* error,
+  bool ValidateChannel(brillo::ErrorPtr* error,
                        const uint16_t& value) override;
 
   // Calculate the frequency based on the given |channel|. Return true and set
@@ -57,14 +57,14 @@ class Config
 
   // Register Config DBus object.
   void RegisterAsync(
-      chromeos::dbus_utils::ExportedObjectManager* object_manager,
+      brillo::dbus_utils::ExportedObjectManager* object_manager,
       const scoped_refptr<dbus::Bus>& bus,
-      chromeos::dbus_utils::AsyncEventSequencer* sequencer);
+      brillo::dbus_utils::AsyncEventSequencer* sequencer);
 
   // Generate a config file string for a hostapd instance. Raise appropriate
   // error when encounter invalid configuration. Return true if success,
   // false otherwise.
-  virtual bool GenerateConfigFile(chromeos::ErrorPtr* error,
+  virtual bool GenerateConfigFile(brillo::ErrorPtr* error,
                                   std::string* config_str);
 
   // Claim and release the device needed for this configuration.
@@ -135,24 +135,24 @@ class Config
   static const int kPassphraseMaxLength;
 
   // Append default hostapd configurations to the config file.
-  bool AppendHostapdDefaults(chromeos::ErrorPtr* error,
+  bool AppendHostapdDefaults(brillo::ErrorPtr* error,
                              std::string* config_str);
 
   // Append hardware mode related configurations to the config file.
-  bool AppendHwMode(chromeos::ErrorPtr* error, std::string* config_str);
+  bool AppendHwMode(brillo::ErrorPtr* error, std::string* config_str);
 
   // Determine/append interface configuration to the config file.
-  bool AppendInterface(chromeos::ErrorPtr* error, std::string* config_str);
+  bool AppendInterface(brillo::ErrorPtr* error, std::string* config_str);
 
   // Append security related configurations to the config file.
-  bool AppendSecurityMode(chromeos::ErrorPtr* error, std::string* config_str);
+  bool AppendSecurityMode(brillo::ErrorPtr* error, std::string* config_str);
 
   Manager* manager_;
   dbus::ObjectPath dbus_path_;
   std::string control_interface_;
   // Interface selected for hostapd.
   std::string selected_interface_;
-  std::unique_ptr<chromeos::dbus_utils::DBusObject> dbus_object_;
+  std::unique_ptr<brillo::dbus_utils::DBusObject> dbus_object_;
   scoped_refptr<Device> device_;
 
   DISALLOW_COPY_AND_ASSIGN(Config);
diff --git a/config_unittest.cc b/config_unittest.cc
index 6c98d41..b8b58ca 100644
--- a/config_unittest.cc
+++ b/config_unittest.cc
@@ -141,7 +141,7 @@ class ConfigTest : public testing::Test {
 
 MATCHER_P(IsConfigErrorStartingWith, message, "") {
   return arg != nullptr &&
-         arg->GetDomain() == chromeos::errors::dbus::kDomain &&
+         arg->GetDomain() == brillo::errors::dbus::kDomain &&
          arg->GetCode() == kConfigError &&
          base::StartsWithASCII(arg->GetMessage(), message, false);
 }
@@ -170,7 +170,7 @@ TEST_F(ConfigTest, GetFrequencyFromChannel) {
 }
 
 TEST_F(ConfigTest, ValidateSsid) {
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   // SSID must contain between 1 and 32 characters.
   EXPECT_TRUE(config_.ValidateSsid(&error, "s"));
   EXPECT_TRUE(config_.ValidateSsid(&error, std::string(32, 'c')));
@@ -179,14 +179,14 @@ TEST_F(ConfigTest, ValidateSsid) {
 }
 
 TEST_F(ConfigTest, ValidateSecurityMode) {
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_TRUE(config_.ValidateSecurityMode(&error, kSecurityModeNone));
   EXPECT_TRUE(config_.ValidateSecurityMode(&error, kSecurityModeRSN));
   EXPECT_FALSE(config_.ValidateSecurityMode(&error, "InvalidSecurityMode"));
 }
 
 TEST_F(ConfigTest, ValidatePassphrase) {
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   // Passpharse must contain between 8 and 63 characters.
   EXPECT_TRUE(config_.ValidatePassphrase(&error, std::string(8, 'c')));
   EXPECT_TRUE(config_.ValidatePassphrase(&error, std::string(63, 'c')));
@@ -195,7 +195,7 @@ TEST_F(ConfigTest, ValidatePassphrase) {
 }
 
 TEST_F(ConfigTest, ValidateHwMode) {
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_TRUE(config_.ValidateHwMode(&error, kHwMode80211a));
   EXPECT_TRUE(config_.ValidateHwMode(&error, kHwMode80211b));
   EXPECT_TRUE(config_.ValidateHwMode(&error, kHwMode80211g));
@@ -205,14 +205,14 @@ TEST_F(ConfigTest, ValidateHwMode) {
 }
 
 TEST_F(ConfigTest, ValidateOperationMode) {
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_TRUE(config_.ValidateOperationMode(&error, kOperationModeServer));
   EXPECT_TRUE(config_.ValidateOperationMode(&error, kOperationModeBridge));
   EXPECT_FALSE(config_.ValidateOperationMode(&error, "InvalidMode"));
 }
 
 TEST_F(ConfigTest, ValidateChannel) {
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_TRUE(config_.ValidateChannel(&error, 1));
   EXPECT_TRUE(config_.ValidateChannel(&error, 13));
   EXPECT_TRUE(config_.ValidateChannel(&error, 34));
@@ -229,7 +229,7 @@ TEST_F(ConfigTest, NoSsid) {
   config_.SetInterfaceName(kInterface);
 
   std::string config_content;
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_FALSE(config_.GenerateConfigFile(&error, &config_content));
   EXPECT_THAT(error, IsConfigErrorStartingWith("SSID not specified"));
 }
@@ -241,7 +241,7 @@ TEST_F(ConfigTest, NoInterface) {
   config_.SetHwMode(kHwMode80211g);
 
   // No device available, fail to generate config file.
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   std::string config_content;
   EXPECT_CALL(manager_, GetAvailableDevice()).WillOnce(Return(nullptr));
   EXPECT_FALSE(config_.GenerateConfigFile(&error, &config_content));
@@ -251,7 +251,7 @@ TEST_F(ConfigTest, NoInterface) {
   // Device available, config file should be generated without any problem.
   scoped_refptr<MockDevice> device = new MockDevice();
   device->SetPreferredApInterface(kInterface);
-  chromeos::ErrorPtr error1;
+  brillo::ErrorPtr error1;
   EXPECT_CALL(manager_, GetAvailableDevice()).WillOnce(Return(device));
   EXPECT_TRUE(config_.GenerateConfigFile(&error1, &config_content));
   EXPECT_NE(std::string::npos, config_content.find(
@@ -271,7 +271,7 @@ TEST_F(ConfigTest, InvalidInterface) {
   config_.SetInterfaceName(kInterface);
 
   // No device available, fail to generate config file.
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   std::string config_content;
   EXPECT_CALL(manager_, GetDeviceFromInterfaceName(kInterface))
       .WillOnce(Return(nullptr));
@@ -290,7 +290,7 @@ TEST_F(ConfigTest, BridgeMode) {
   config_.SetOperationMode(kOperationModeBridge);
 
   // Bridge interface required for bridge mode.
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   std::string config_content;
   EXPECT_FALSE(config_.GenerateConfigFile(&error, &config_content));
   EXPECT_THAT(error,
@@ -300,7 +300,7 @@ TEST_F(ConfigTest, BridgeMode) {
   config_.SetBridgeInterface(kBridgeInterface);
   // Setup mock device.
   SetupDevice(kInterface);
-  chromeos::ErrorPtr error1;
+  brillo::ErrorPtr error1;
   std::string config_content1;
   EXPECT_TRUE(config_.GenerateConfigFile(&error1, &config_content1));
   EXPECT_NE(std::string::npos, config_content1.find(
@@ -321,7 +321,7 @@ TEST_F(ConfigTest, 80211gConfig) {
   SetupDevice(kInterface);
 
   std::string config_content;
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_TRUE(config_.GenerateConfigFile(&error, &config_content));
   EXPECT_NE(std::string::npos, config_content.find(
                                    kExpected80211gConfigContent))
@@ -342,7 +342,7 @@ TEST_F(ConfigTest, 80211gConfigWithControlInterface) {
   SetupDevice(kInterface);
 
   std::string config_content;
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_TRUE(config_.GenerateConfigFile(&error, &config_content));
   EXPECT_NE(std::string::npos, config_content.find(
                                    kExpected80211gCtrlIfaceConfigContent))
@@ -363,7 +363,7 @@ TEST_F(ConfigTest, 80211nConfig) {
   // 5GHz channel.
   config_.SetChannel(k5GHzChannel);
   std::string ghz5_config_content;
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   std::string ht_capab_5ghz(k5GHzHTCapab);
   EXPECT_CALL(*device_.get(), GetHTCapability(k5GHzChannel, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(ht_capab_5ghz), Return(true)));
@@ -379,7 +379,7 @@ TEST_F(ConfigTest, 80211nConfig) {
   // 2.4GHz channel.
   config_.SetChannel(k24GHzChannel);
   std::string ghz24_config_content;
-  chromeos::ErrorPtr error1;
+  brillo::ErrorPtr error1;
   std::string ht_capab_24ghz(k24GHzHTCapab);
   EXPECT_CALL(*device_.get(), GetHTCapability(k24GHzChannel, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(ht_capab_24ghz), Return(true)));
@@ -405,13 +405,13 @@ TEST_F(ConfigTest, RsnConfig) {
 
   // Failed due to no passphrase specified.
   std::string config_content;
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_FALSE(config_.GenerateConfigFile(&error, &config_content));
   EXPECT_THAT(error, IsConfigErrorStartingWith(
       base::StringPrintf("Passphrase not set for security mode: %s",
                          kSecurityModeRSN)));
 
-  chromeos::ErrorPtr error1;
+  brillo::ErrorPtr error1;
   config_.SetPassphrase(kPassphrase);
   EXPECT_TRUE(config_.GenerateConfigFile(&error1, &config_content));
   EXPECT_NE(std::string::npos, config_content.find(
diff --git a/daemon.cc b/daemon.cc
index 7c90321..d131cc9 100644
--- a/daemon.cc
+++ b/daemon.cc
@@ -44,7 +44,7 @@ Daemon::Daemon(const base::Closure& startup_callback)
 }
 
 int Daemon::OnInit() {
-  int return_code = chromeos::DBusServiceDaemon::OnInit();
+  int return_code = brillo::DBusServiceDaemon::OnInit();
   if (return_code != EX_OK) {
     return return_code;
   }
@@ -60,11 +60,11 @@ int Daemon::OnInit() {
 
 void Daemon::OnShutdown(int* return_code) {
   manager_.reset();
-  chromeos::DBusServiceDaemon::OnShutdown(return_code);
+  brillo::DBusServiceDaemon::OnShutdown(return_code);
 }
 
 void Daemon::RegisterDBusObjectsAsync(
-    chromeos::dbus_utils::AsyncEventSequencer* sequencer) {
+    brillo::dbus_utils::AsyncEventSequencer* sequencer) {
   manager_.reset(new apmanager::Manager());
   manager_->RegisterAsync(object_manager_.get(), bus_, sequencer);
 }
diff --git a/daemon.h b/daemon.h
index 1630443..137adaa 100644
--- a/daemon.h
+++ b/daemon.h
@@ -18,13 +18,13 @@
 #define APMANAGER_DAEMON_H_
 
 #include <base/callback_forward.h>
-#include <chromeos/daemons/dbus_daemon.h>
+#include <brillo/daemons/dbus_daemon.h>
 
 #include "apmanager/manager.h"
 
 namespace apmanager {
 
-class Daemon : public chromeos::DBusServiceDaemon {
+class Daemon : public brillo::DBusServiceDaemon {
  public:
   // User and group to run the apmanager process.
   static const char kAPManagerGroupName[];
@@ -37,7 +37,7 @@ class Daemon : public chromeos::DBusServiceDaemon {
   int OnInit() override;
   void OnShutdown(int* return_code) override;
   void RegisterDBusObjectsAsync(
-      chromeos::dbus_utils::AsyncEventSequencer* sequencer) override;
+      brillo::dbus_utils::AsyncEventSequencer* sequencer) override;
 
  private:
   friend class DaemonTest;
diff --git a/device.cc b/device.cc
index 29a50da..fc82c43 100644
--- a/device.cc
+++ b/device.cc
@@ -17,15 +17,15 @@
 #include "apmanager/device.h"
 
 #include <base/strings/stringprintf.h>
-#include <chromeos/strings/string_utils.h>
+#include <brillo/strings/string_utils.h>
 #include <shill/net/attribute_list.h>
 #include <shill/net/ieee80211.h>
 
 #include "apmanager/config.h"
 #include "apmanager/manager.h"
 
-using chromeos::dbus_utils::AsyncEventSequencer;
-using chromeos::dbus_utils::ExportedObjectManager;
+using brillo::dbus_utils::AsyncEventSequencer;
+using brillo::dbus_utils::ExportedObjectManager;
 using org::chromium::apmanager::ManagerAdaptor;
 using shill::ByteString;
 using std::string;
@@ -52,7 +52,7 @@ void Device::RegisterAsync(ExportedObjectManager* object_manager,
                          ManagerAdaptor::GetObjectPath().value().c_str(),
                          device_identifier));
   dbus_object_.reset(
-      new chromeos::dbus_utils::DBusObject(
+      new brillo::dbus_utils::DBusObject(
           object_manager,
           bus,
           dbus_path_));
@@ -290,7 +290,7 @@ bool Device::GetHTCapability(uint16_t channel, string* ht_cap) {
   }
 
   *ht_cap = base::StringPrintf("[%s]",
-      chromeos::string_utils::Join(" ", ht_capability).c_str());
+      brillo::string_utils::Join(" ", ht_capability).c_str());
   return true;
 }
 
diff --git a/device.h b/device.h
index de54713..51fb432 100644
--- a/device.h
+++ b/device.h
@@ -71,9 +71,9 @@ class Device : public base::RefCounted<Device>,
 
   // Register Device DBus object.
   void RegisterAsync(
-      chromeos::dbus_utils::ExportedObjectManager* object_manager,
+      brillo::dbus_utils::ExportedObjectManager* object_manager,
       const scoped_refptr<dbus::Bus>& bus,
-      chromeos::dbus_utils::AsyncEventSequencer* sequencer,
+      brillo::dbus_utils::AsyncEventSequencer* sequencer,
       int device_identifier);
 
   // Register/deregister WiFi interface on this device.
@@ -124,7 +124,7 @@ class Device : public base::RefCounted<Device>,
   std::vector<WiFiInterface> interface_list_;
 
   dbus::ObjectPath dbus_path_;
-  std::unique_ptr<chromeos::dbus_utils::DBusObject> dbus_object_;
+  std::unique_ptr<brillo::dbus_utils::DBusObject> dbus_object_;
 
   // Flag indicating if this device supports AP mode interface or not.
   bool supports_ap_mode_;
diff --git a/dhcp_server.h b/dhcp_server.h
index 881edbb..90a33c6 100644
--- a/dhcp_server.h
+++ b/dhcp_server.h
@@ -57,7 +57,7 @@ class DHCPServer {
   uint16_t server_address_index_;
   std::string interface_name_;
   shill::IPAddress server_address_;
-  std::unique_ptr<chromeos::Process> dnsmasq_process_;
+  std::unique_ptr<brillo::Process> dnsmasq_process_;
   shill::RTNLHandler* rtnl_handler_;
   FileWriter* file_writer_;
   ProcessFactory* process_factory_;
diff --git a/dhcp_server_unittest.cc b/dhcp_server_unittest.cc
index 5829d8a..d4cd2c5 100644
--- a/dhcp_server_unittest.cc
+++ b/dhcp_server_unittest.cc
@@ -22,7 +22,7 @@
 
 #include <base/strings/string_util.h>
 #include <base/strings/stringprintf.h>
-#include <chromeos/process_mock.h>
+#include <brillo/process_mock.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <shill/net/mock_rtnl_handler.h>
@@ -30,7 +30,7 @@
 #include "apmanager/mock_file_writer.h"
 #include "apmanager/mock_process_factory.h"
 
-using chromeos::ProcessMock;
+using brillo::ProcessMock;
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Return;
@@ -86,7 +86,7 @@ class DHCPServerTest : public testing::Test {
   }
 
   void StartDummyProcess() {
-    dhcp_server_->dnsmasq_process_.reset(new chromeos::ProcessImpl);
+    dhcp_server_->dnsmasq_process_.reset(new brillo::ProcessImpl);
     dhcp_server_->dnsmasq_process_->AddArg(kBinSleep);
     dhcp_server_->dnsmasq_process_->AddArg("12345");
     CHECK(dhcp_server_->dnsmasq_process_->Start());
diff --git a/firewall_manager.cc b/firewall_manager.cc
index 412f007..ded545c 100644
--- a/firewall_manager.cc
+++ b/firewall_manager.cc
@@ -17,7 +17,7 @@
 #include "apmanager/firewall_manager.h"
 
 #include <base/bind.h>
-#include <chromeos/errors/error.h>
+#include <brillo/errors/error.h>
 
 #if !defined(__ANDROID__)
 #include "apmanager/permission_broker_dbus_proxy.h"
diff --git a/firewalld_dbus_proxy.cc b/firewalld_dbus_proxy.cc
index 3207b1d..114e0b2 100644
--- a/firewalld_dbus_proxy.cc
+++ b/firewalld_dbus_proxy.cc
@@ -17,7 +17,7 @@
 #include "apmanager/firewalld_dbus_proxy.h"
 
 #include <base/bind.h>
-#include <chromeos/errors/error.h>
+#include <brillo/errors/error.h>
 
 #include "apmanager/event_dispatcher.h"
 
@@ -56,7 +56,7 @@ bool FirewalldDBusProxy::RequestUdpPortAccess(const string& interface,
   }
 
   bool success = false;
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   if (!proxy_->PunchUdpHole(port, interface, &success, &error)) {
     LOG(ERROR) << "Failed to request UDP port access: "
                << error->GetCode() << " " << error->GetMessage();
@@ -79,7 +79,7 @@ bool FirewalldDBusProxy::ReleaseUdpPortAccess(const string& interface,
     return false;
   }
 
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   bool success;
   if (!proxy_->PlugUdpHole(port, interface, &success, &error)) {
     LOG(ERROR) << "Failed to release UDP port access: "
diff --git a/main.cc b/main.cc
index dfc15c7..5199f2f 100644
--- a/main.cc
+++ b/main.cc
@@ -19,8 +19,8 @@
 #include <base/bind.h>
 #include <base/command_line.h>
 #include <base/logging.h>
-#include <chromeos/minijail/minijail.h>
-#include <chromeos/syslog_logging.h>
+#include <brillo/minijail/minijail.h>
+#include <brillo/syslog_logging.h>
 
 #include "apmanager/daemon.h"
 
@@ -57,16 +57,16 @@ const char kSeccompFilePath[] = "/usr/share/policy/apmanager-seccomp.policy";
 
 // Always logs to the syslog and logs to stderr if
 // we are running in the foreground.
-void SetupLogging(chromeos::Minijail* minijail,
+void SetupLogging(brillo::Minijail* minijail,
                   bool foreground,
                   const char* daemon_name) {
   int log_flags = 0;
-  log_flags |= chromeos::kLogToSyslog;
-  log_flags |= chromeos::kLogHeader;
+  log_flags |= brillo::kLogToSyslog;
+  log_flags |= brillo::kLogHeader;
   if (foreground) {
-    log_flags |= chromeos::kLogToStderr;
+    log_flags |= brillo::kLogToStderr;
   }
-  chromeos::InitLog(log_flags);
+  brillo::InitLog(log_flags);
 
 #if !defined(__ANDROID__)
   // Logger utility doesn't exist on Android, so do not run it on Android.
@@ -103,7 +103,7 @@ void SetupLogging(chromeos::Minijail* minijail,
 #endif  // __ANDROID__
 }
 
-void DropPrivileges(chromeos::Minijail* minijail) {
+void DropPrivileges(brillo::Minijail* minijail) {
   struct minijail* jail = minijail->New();
   minijail->DropRoot(jail, apmanager::Daemon::kAPManagerUserName,
                      apmanager::Daemon::kAPManagerGroupName);
@@ -118,7 +118,7 @@ void DropPrivileges(chromeos::Minijail* minijail) {
 }
 
 void OnStartup(const char* daemon_name, base::CommandLine* cl) {
-  chromeos::Minijail* minijail = chromeos::Minijail::GetInstance();
+  brillo::Minijail* minijail = brillo::Minijail::GetInstance();
   SetupLogging(minijail, cl->HasSwitch(switches::kForeground), daemon_name);
 
   LOG(INFO) << __func__ << ": Dropping privileges";
diff --git a/manager.cc b/manager.cc
index f87de11..a4c8b48 100644
--- a/manager.cc
+++ b/manager.cc
@@ -24,9 +24,9 @@
 #include "dbus/apmanager/dbus-constants.h"
 #endif  // __ANDROID__
 
-using chromeos::dbus_utils::AsyncEventSequencer;
-using chromeos::dbus_utils::ExportedObjectManager;
-using chromeos::dbus_utils::DBusMethodResponse;
+using brillo::dbus_utils::AsyncEventSequencer;
+using brillo::dbus_utils::ExportedObjectManager;
+using brillo::dbus_utils::DBusMethodResponse;
 using std::string;
 
 namespace apmanager {
@@ -49,7 +49,7 @@ void Manager::RegisterAsync(ExportedObjectManager* object_manager,
                             AsyncEventSequencer* sequencer) {
   CHECK(!dbus_object_) << "Already registered";
   dbus_object_.reset(
-      new chromeos::dbus_utils::DBusObject(
+      new brillo::dbus_utils::DBusObject(
           object_manager,
           bus,
           org::chromium::apmanager::ManagerAdaptor::GetObjectPath()));
@@ -95,7 +95,7 @@ void Manager::CreateService(
   service_identifier_++;
 }
 
-bool Manager::RemoveService(chromeos::ErrorPtr* error,
+bool Manager::RemoveService(brillo::ErrorPtr* error,
                             dbus::Message* message,
                             const dbus::ObjectPath& in_service) {
   for (auto it = services_.begin(); it != services_.end(); ++it) {
@@ -105,8 +105,8 @@ bool Manager::RemoveService(chromeos::ErrorPtr* error,
       CHECK(watcher != service_watchers_.end())
           << "DBus watcher not created for service: " << (*it)->identifier();
       if (watcher->second->connection_name() != message->GetSender()) {
-        chromeos::Error::AddToPrintf(
-            error, FROM_HERE, chromeos::errors::dbus::kDomain, kManagerError,
+        brillo::Error::AddToPrintf(
+            error, FROM_HERE, brillo::errors::dbus::kDomain, kManagerError,
             "Service %d is owned by another local process.",
             (*it)->identifier());
         return false;
@@ -118,8 +118,8 @@ bool Manager::RemoveService(chromeos::ErrorPtr* error,
     }
   }
 
-  chromeos::Error::AddTo(
-      error, FROM_HERE, chromeos::errors::dbus::kDomain, kManagerError,
+  brillo::Error::AddTo(
+      error, FROM_HERE, brillo::errors::dbus::kDomain, kManagerError,
       "Service does not exist");
   return false;
 }
diff --git a/manager.h b/manager.h
index 2c4d453..3e62df8 100644
--- a/manager.h
+++ b/manager.h
@@ -22,7 +22,7 @@
 #include <vector>
 
 #include <base/macros.h>
-#include <chromeos/dbus/dbus_service_watcher.h>
+#include <brillo/dbus/dbus_service_watcher.h>
 
 #include "apmanager/device_info.h"
 #include "apmanager/firewall_manager.h"
@@ -36,7 +36,7 @@ class Manager : public org::chromium::apmanager::ManagerAdaptor,
                 public org::chromium::apmanager::ManagerInterface {
  public:
   template<typename T>
-  using DBusMethodResponse = chromeos::dbus_utils::DBusMethodResponse<T>;
+  using DBusMethodResponse = brillo::dbus_utils::DBusMethodResponse<T>;
 
   Manager();
   virtual ~Manager();
@@ -49,15 +49,15 @@ class Manager : public org::chromium::apmanager::ManagerAdaptor,
       std::unique_ptr<DBusMethodResponse<dbus::ObjectPath>> response,
       dbus::Message* message);
   // Handles calls to org.chromium.apmanager.Manager.RemoveService().
-  virtual bool RemoveService(chromeos::ErrorPtr* error,
+  virtual bool RemoveService(brillo::ErrorPtr* error,
                              dbus::Message* message,
                              const dbus::ObjectPath& in_service);
 
   // Register DBus object.
   void RegisterAsync(
-      chromeos::dbus_utils::ExportedObjectManager* object_manager,
+      brillo::dbus_utils::ExportedObjectManager* object_manager,
       const scoped_refptr<dbus::Bus>& bus,
-      chromeos::dbus_utils::AsyncEventSequencer* sequencer);
+      brillo::dbus_utils::AsyncEventSequencer* sequencer);
 
   virtual void Start();
   virtual void Stop();
@@ -100,12 +100,12 @@ class Manager : public org::chromium::apmanager::ManagerAdaptor,
 
   int service_identifier_;
   int device_identifier_;
-  std::unique_ptr<chromeos::dbus_utils::DBusObject> dbus_object_;
+  std::unique_ptr<brillo::dbus_utils::DBusObject> dbus_object_;
   scoped_refptr<dbus::Bus> bus_;
   std::vector<std::unique_ptr<Service>> services_;
   std::vector<scoped_refptr<Device>> devices_;
   // DBus service watchers for the owner of AP services.
-  using DBusServiceWatcher = chromeos::dbus_utils::DBusServiceWatcher;
+  using DBusServiceWatcher = brillo::dbus_utils::DBusServiceWatcher;
   std::map<int, std::unique_ptr<DBusServiceWatcher>> service_watchers_;
   DeviceInfo device_info_;
 
diff --git a/mock_config.h b/mock_config.h
index ff4dbac..3bce700 100644
--- a/mock_config.h
+++ b/mock_config.h
@@ -32,7 +32,7 @@ class MockConfig : public Config {
   ~MockConfig() override;
 
   MOCK_METHOD2(GenerateConfigFile,
-               bool(chromeos::ErrorPtr *error,
+               bool(brillo::ErrorPtr *error,
                     std::string* config_str));
   MOCK_METHOD0(ClaimDevice, bool());
   MOCK_METHOD0(ReleaseDevice, bool());
diff --git a/mock_process_factory.h b/mock_process_factory.h
index 1c7c3c1..a07f5e8 100644
--- a/mock_process_factory.h
+++ b/mock_process_factory.h
@@ -31,7 +31,7 @@ class MockProcessFactory : public ProcessFactory {
   // This is a singleton. Use MockDHCPServerFactory::GetInstance()->Foo().
   static MockProcessFactory* GetInstance();
 
-  MOCK_METHOD0(CreateProcess, chromeos::Process*());
+  MOCK_METHOD0(CreateProcess, brillo::Process*());
 
  protected:
   MockProcessFactory();
diff --git a/mock_service.h b/mock_service.h
index 8140bd7..4265486 100644
--- a/mock_service.h
+++ b/mock_service.h
@@ -29,8 +29,8 @@ class MockService : public Service {
   MockService();
   ~MockService() override;
 
-  MOCK_METHOD1(Start, bool(chromeos::ErrorPtr *error));
-  MOCK_METHOD1(Stop, bool(chromeos::ErrorPtr *error));
+  MOCK_METHOD1(Start, bool(brillo::ErrorPtr *error));
+  MOCK_METHOD1(Stop, bool(brillo::ErrorPtr *error));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockService);
diff --git a/permission_broker_dbus_proxy.cc b/permission_broker_dbus_proxy.cc
index 62adcb0..c39b440 100644
--- a/permission_broker_dbus_proxy.cc
+++ b/permission_broker_dbus_proxy.cc
@@ -17,7 +17,7 @@
 #include "apmanager/permission_broker_dbus_proxy.h"
 
 #include <base/bind.h>
-#include <chromeos/errors/error.h>
+#include <brillo/errors/error.h>
 
 #include "apmanager/event_dispatcher.h"
 
@@ -71,7 +71,7 @@ bool PermissionBrokerDBusProxy::RequestUdpPortAccess(const string& interface,
   dbus::FileDescriptor fd(lifeline_read_fd_);
   fd.CheckValidity();
   bool allowed = false;
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   if (!proxy_->RequestUdpPortAccess(port, interface, fd, &allowed, &error)) {
     LOG(ERROR) << "Failed to request UDP port access: "
                << error->GetCode() << " " << error->GetMessage();
@@ -94,7 +94,7 @@ bool PermissionBrokerDBusProxy::ReleaseUdpPortAccess(const string& interface,
     return false;
   }
 
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   bool success;
   if (!proxy_->ReleaseUdpPort(port, interface, &success, &error)) {
     LOG(ERROR) << "Failed to release UDP port access: "
diff --git a/process_factory.cc b/process_factory.cc
index 3f5e476..4517c6e 100644
--- a/process_factory.cc
+++ b/process_factory.cc
@@ -32,8 +32,8 @@ ProcessFactory* ProcessFactory::GetInstance() {
   return g_process_factory.Pointer();
 }
 
-chromeos::Process* ProcessFactory::CreateProcess() {
-  return new chromeos::ProcessImpl();
+brillo::Process* ProcessFactory::CreateProcess() {
+  return new brillo::ProcessImpl();
 }
 
 }  // namespace apmanager
diff --git a/process_factory.h b/process_factory.h
index 32eefda..8c9a7af 100644
--- a/process_factory.h
+++ b/process_factory.h
@@ -21,7 +21,7 @@
 
 #include <base/lazy_instance.h>
 
-#include <chromeos/process.h>
+#include <brillo/process.h>
 
 namespace apmanager {
 
@@ -32,7 +32,7 @@ class ProcessFactory {
   // This is a singleton. Use ProcessFactory::GetInstance()->Foo().
   static ProcessFactory* GetInstance();
 
-  virtual chromeos::Process* CreateProcess();
+  virtual brillo::Process* CreateProcess();
 
  protected:
   ProcessFactory();
diff --git a/service.cc b/service.cc
index 0761be8..b3a6cd9 100644
--- a/service.cc
+++ b/service.cc
@@ -19,7 +19,7 @@
 #include <signal.h>
 
 #include <base/strings/stringprintf.h>
-#include <chromeos/errors/error.h>
+#include <brillo/errors/error.h>
 
 #if !defined(__ANDROID__)
 #include <chromeos/dbus/service_constants.h>
@@ -29,8 +29,8 @@
 
 #include "apmanager/manager.h"
 
-using chromeos::dbus_utils::AsyncEventSequencer;
-using chromeos::dbus_utils::ExportedObjectManager;
+using brillo::dbus_utils::AsyncEventSequencer;
+using brillo::dbus_utils::ExportedObjectManager;
 using org::chromium::apmanager::ManagerAdaptor;
 using std::string;
 
@@ -91,7 +91,7 @@ void Service::RegisterAsync(ExportedObjectManager* object_manager,
                             AsyncEventSequencer* sequencer) {
   CHECK(!dbus_object_) << "Already registered";
   dbus_object_.reset(
-      new chromeos::dbus_utils::DBusObject(
+      new brillo::dbus_utils::DBusObject(
           object_manager,
           bus,
           dbus_path_));
@@ -103,10 +103,10 @@ void Service::RegisterAsync(ExportedObjectManager* object_manager,
   config_->RegisterAsync(object_manager, bus, sequencer);
 }
 
-bool Service::Start(chromeos::ErrorPtr* error) {
+bool Service::Start(brillo::ErrorPtr* error) {
   if (IsHostapdRunning()) {
-    chromeos::Error::AddTo(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kServiceError,
+    brillo::Error::AddTo(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kServiceError,
         "Service already running");
     return false;
   }
@@ -117,8 +117,8 @@ bool Service::Start(chromeos::ErrorPtr* error) {
   // Generate hostapd configuration content.
   string config_str;
   if (!config_->GenerateConfigFile(error, &config_str)) {
-    chromeos::Error::AddTo(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kServiceError,
+    brillo::Error::AddTo(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kServiceError,
         "Failed to generate config file");
     return false;
   }
@@ -127,24 +127,24 @@ bool Service::Start(chromeos::ErrorPtr* error) {
   string config_file_name = base::StringPrintf(kHostapdConfigPathFormat,
                                                identifier_);
   if (!file_writer_->Write(config_file_name, config_str)) {
-    chromeos::Error::AddTo(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kServiceError,
+    brillo::Error::AddTo(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kServiceError,
         "Failed to write configuration to a file");
     return false;
   }
 
   // Claim the device needed for this ap service.
   if (!config_->ClaimDevice()) {
-    chromeos::Error::AddTo(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kServiceError,
+    brillo::Error::AddTo(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kServiceError,
         "Failed to claim the device for this service");
     return false;
   }
 
   // Start hostapd process.
   if (!StartHostapdProcess(config_file_name)) {
-    chromeos::Error::AddTo(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kServiceError,
+    brillo::Error::AddTo(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kServiceError,
         "Failed to start hostapd");
     // Release the device claimed for this service.
     config_->ReleaseDevice();
@@ -157,8 +157,8 @@ bool Service::Start(chromeos::ErrorPtr* error) {
         dhcp_server_factory_->CreateDHCPServer(config_->GetServerAddressIndex(),
                                                config_->selected_interface()));
     if (!dhcp_server_->Start()) {
-      chromeos::Error::AddTo(
-          error, FROM_HERE, chromeos::errors::dbus::kDomain, kServiceError,
+      brillo::Error::AddTo(
+          error, FROM_HERE, brillo::errors::dbus::kDomain, kServiceError,
           "Failed to start DHCP server");
       ReleaseResources();
       return false;
@@ -182,10 +182,10 @@ bool Service::Start(chromeos::ErrorPtr* error) {
   return true;
 }
 
-bool Service::Stop(chromeos::ErrorPtr* error) {
+bool Service::Stop(brillo::ErrorPtr* error) {
   if (!IsHostapdRunning()) {
-    chromeos::Error::AddTo(
-        error, FROM_HERE, chromeos::errors::dbus::kDomain, kServiceError,
+    brillo::Error::AddTo(
+        error, FROM_HERE, brillo::errors::dbus::kDomain, kServiceError,
         "Service is not currently running");
     return false;
   }
@@ -197,7 +197,7 @@ bool Service::Stop(chromeos::ErrorPtr* error) {
 
 bool Service::IsHostapdRunning() {
   return hostapd_process_ && hostapd_process_->pid() != 0 &&
-         chromeos::Process::ProcessExists(hostapd_process_->pid());
+         brillo::Process::ProcessExists(hostapd_process_->pid());
 }
 
 bool Service::StartHostapdProcess(const string& config_file_path) {
diff --git a/service.h b/service.h
index d87c2b4..b0e7976 100644
--- a/service.h
+++ b/service.h
@@ -20,7 +20,7 @@
 #include <string>
 
 #include <base/macros.h>
-#include <chromeos/process.h>
+#include <brillo/process.h>
 
 #include "apmanager/config.h"
 #include "apmanager/dhcp_server_factory.h"
@@ -40,14 +40,14 @@ class Service : public org::chromium::apmanager::ServiceAdaptor,
   virtual ~Service();
 
   // Implementation of ServiceInterface.
-  virtual bool Start(chromeos::ErrorPtr* error);
-  virtual bool Stop(chromeos::ErrorPtr* error);
+  virtual bool Start(brillo::ErrorPtr* error);
+  virtual bool Stop(brillo::ErrorPtr* error);
 
   // Register Service DBus object.
   void RegisterAsync(
-      chromeos::dbus_utils::ExportedObjectManager* object_manager,
+      brillo::dbus_utils::ExportedObjectManager* object_manager,
       const scoped_refptr<dbus::Bus>& bus,
-      chromeos::dbus_utils::AsyncEventSequencer* sequencer);
+      brillo::dbus_utils::AsyncEventSequencer* sequencer);
 
   const dbus::ObjectPath& dbus_path() const { return dbus_path_; }
 
@@ -87,8 +87,8 @@ class Service : public org::chromium::apmanager::ServiceAdaptor,
   std::string service_path_;
   dbus::ObjectPath dbus_path_;
   std::unique_ptr<Config> config_;
-  std::unique_ptr<chromeos::dbus_utils::DBusObject> dbus_object_;
-  std::unique_ptr<chromeos::Process> hostapd_process_;
+  std::unique_ptr<brillo::dbus_utils::DBusObject> dbus_object_;
+  std::unique_ptr<brillo::Process> hostapd_process_;
   std::unique_ptr<DHCPServer> dhcp_server_;
   DHCPServerFactory* dhcp_server_factory_;
   FileWriter* file_writer_;
diff --git a/service_unittest.cc b/service_unittest.cc
index 509b9a0..986e435 100644
--- a/service_unittest.cc
+++ b/service_unittest.cc
@@ -20,7 +20,7 @@
 
 #include <base/strings/string_util.h>
 #include <base/strings/stringprintf.h>
-#include <chromeos/process_mock.h>
+#include <brillo/process_mock.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -38,7 +38,7 @@
 #include "apmanager/mock_manager.h"
 #include "apmanager/mock_process_factory.h"
 
-using chromeos::ProcessMock;
+using brillo::ProcessMock;
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Return;
@@ -75,7 +75,7 @@ class ServiceTest : public testing::Test {
   }
 
   void StartDummyProcess() {
-    service_.hostapd_process_.reset(new chromeos::ProcessImpl);
+    service_.hostapd_process_.reset(new brillo::ProcessImpl);
     service_.hostapd_process_->AddArg(kBinSleep);
     service_.hostapd_process_->AddArg("12345");
     CHECK(service_.hostapd_process_->Start());
@@ -97,7 +97,7 @@ class ServiceTest : public testing::Test {
 
 MATCHER_P(IsServiceErrorStartingWith, message, "") {
   return arg != nullptr &&
-         arg->GetDomain() == chromeos::errors::dbus::kDomain &&
+         arg->GetDomain() == brillo::errors::dbus::kDomain &&
          arg->GetCode() == kServiceError &&
          base::EndsWith(arg->GetMessage(), message, false);
 }
@@ -105,7 +105,7 @@ MATCHER_P(IsServiceErrorStartingWith, message, "") {
 TEST_F(ServiceTest, StartWhenServiceAlreadyRunning) {
   StartDummyProcess();
 
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_FALSE(service_.Start(&error));
   EXPECT_THAT(error, IsServiceErrorStartingWith("Service already running"));
 }
@@ -114,7 +114,7 @@ TEST_F(ServiceTest, StartWhenConfigFileFailed) {
   MockConfig* config = new MockConfig();
   SetConfig(config);
 
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_CALL(*config, GenerateConfigFile(_, _)).WillOnce(Return(false));
   EXPECT_FALSE(service_.Start(&error));
   EXPECT_THAT(error, IsServiceErrorStartingWith(
@@ -131,7 +131,7 @@ TEST_F(ServiceTest, StartSuccess) {
   ProcessMock* process = new ProcessMock();
 
   std::string config_str(kHostapdConfig);
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_CALL(*config, GenerateConfigFile(_, _)).WillOnce(
       DoAll(SetArgPointee<1>(config_str), Return(true)));
   EXPECT_CALL(*file_writer_, Write(kHostapdConfigFilePath, kHostapdConfig))
@@ -149,7 +149,7 @@ TEST_F(ServiceTest, StartSuccess) {
 }
 
 TEST_F(ServiceTest, StopWhenServiceNotRunning) {
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_FALSE(service_.Stop(&error));
   EXPECT_THAT(error, IsServiceErrorStartingWith(
       "Service is not currently running"));
@@ -160,7 +160,7 @@ TEST_F(ServiceTest, StopSuccess) {
 
   MockConfig* config = new MockConfig();
   SetConfig(config);
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   EXPECT_CALL(*config, ReleaseDevice()).Times(1);
   EXPECT_TRUE(service_.Stop(&error));
 }
diff --git a/shill_dbus_proxy.cc b/shill_dbus_proxy.cc
index 95ad3bf..fed6555 100644
--- a/shill_dbus_proxy.cc
+++ b/shill_dbus_proxy.cc
@@ -17,7 +17,7 @@
 #include "apmanager/shill_dbus_proxy.h"
 
 #include <base/bind.h>
-#include <chromeos/errors/error.h>
+#include <brillo/errors/error.h>
 
 #if !defined(__ANDROID__)
 #include <chromeos/dbus/service_constants.h>
@@ -59,7 +59,7 @@ bool ShillDBusProxy::ClaimInterface(const string& interface_name) {
     LOG(ERROR) << "ClaimInterface failed: service not available";
     return false;
   }
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   if (!manager_proxy_->ClaimInterface(kServiceName, interface_name, &error)) {
     LOG(ERROR) << "Failed to claim interface from shill: "
                << error->GetCode() << " " << error->GetMessage();
@@ -73,7 +73,7 @@ bool ShillDBusProxy::ReleaseInterface(const string& interface_name) {
     LOG(ERROR) << "ReleaseInterface failed: service not available";
     return false;
   }
-  chromeos::ErrorPtr error;
+  brillo::ErrorPtr error;
   if (!manager_proxy_->ReleaseInterface(kServiceName, interface_name, &error)) {
     LOG(ERROR) << "Failed to release interface from shill: "
                << error->GetCode() << " " << error->GetMessage();
diff --git a/shill_manager.cc b/shill_manager.cc
index 5ed9895..34984ab 100644
--- a/shill_manager.cc
+++ b/shill_manager.cc
@@ -17,7 +17,7 @@
 #include "apmanager/shill_manager.h"
 
 #include <base/bind.h>
-#include <chromeos/errors/error.h>
+#include <brillo/errors/error.h>
 
 #include "apmanager/shill_dbus_proxy.h"
 
diff --git a/testrunner.cc b/testrunner.cc
index d05703d..39d33ee 100644
--- a/testrunner.cc
+++ b/testrunner.cc
@@ -16,13 +16,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();
 }