attestation: 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
Change-Id: Id96f4f7c372afd328b56efe09aa02b59b5a6fd3a

15 files changed, 113 insertions, 113 deletions

diff --git a/attestation_testrunner.cc b/attestation_testrunner.cc
index e65761a..2aac479 100644
--- a/attestation_testrunner.cc
+++ b/attestation_testrunner.cc
@@ -17,12 +17,12 @@
 #include <base/at_exit.h>
 #include <base/command_line.h>
 #include <base/logging.h>
-#include <chromeos/syslog_logging.h>
+#include <brillo/syslog_logging.h>
 #include <gtest/gtest.h>
 
 int main(int argc, char **argv) {
   base::CommandLine::Init(argc, argv);
-  chromeos::InitLog(chromeos::kLogToStderr);
+  brillo::InitLog(brillo::kLogToStderr);
   // Enable verbose logging while running unit tests.
   logging::SetMinLogLevel(logging::LOG_VERBOSE);
   base::AtExitManager exit_manager;
diff --git a/client/dbus_proxy.cc b/client/dbus_proxy.cc
index 64dfdd2..bf37d0a 100644
--- a/client/dbus_proxy.cc
+++ b/client/dbus_proxy.cc
@@ -16,8 +16,8 @@
 
 #include "attestation/client/dbus_proxy.h"
 
-#include <chromeos/bind_lambda.h>
-#include <chromeos/dbus/dbus_method_invoker.h>
+#include <brillo/bind_lambda.h>
+#include <brillo/dbus/dbus_method_invoker.h>
 
 #include "attestation/common/dbus_interface.h"
 
@@ -51,12 +51,12 @@ bool DBusProxy::Initialize() {
 void DBusProxy::CreateGoogleAttestedKey(
     const CreateGoogleAttestedKeyRequest& request,
     const CreateGoogleAttestedKeyCallback& callback) {
-  auto on_error = [callback](chromeos::Error* error) {
+  auto on_error = [callback](brillo::Error* error) {
     CreateGoogleAttestedKeyReply reply;
     reply.set_status(STATUS_NOT_AVAILABLE);
     callback.Run(reply);
   };
-  chromeos::dbus_utils::CallMethodWithTimeout(
+  brillo::dbus_utils::CallMethodWithTimeout(
       kDBusTimeoutMS,
       object_proxy_,
       attestation::kAttestationInterface,
@@ -68,12 +68,12 @@ void DBusProxy::CreateGoogleAttestedKey(
 
 void DBusProxy::GetKeyInfo(const GetKeyInfoRequest& request,
                            const GetKeyInfoCallback& callback) {
-  auto on_error = [callback](chromeos::Error* error) {
+  auto on_error = [callback](brillo::Error* error) {
     GetKeyInfoReply reply;
     reply.set_status(STATUS_NOT_AVAILABLE);
     callback.Run(reply);
   };
-  chromeos::dbus_utils::CallMethodWithTimeout(
+  brillo::dbus_utils::CallMethodWithTimeout(
       kDBusTimeoutMS,
       object_proxy_,
       attestation::kAttestationInterface,
@@ -85,12 +85,12 @@ void DBusProxy::GetKeyInfo(const GetKeyInfoRequest& request,
 
 void DBusProxy::GetEndorsementInfo(const GetEndorsementInfoRequest& request,
                                    const GetEndorsementInfoCallback& callback) {
-  auto on_error = [callback](chromeos::Error* error) {
+  auto on_error = [callback](brillo::Error* error) {
     GetEndorsementInfoReply reply;
     reply.set_status(STATUS_NOT_AVAILABLE);
     callback.Run(reply);
   };
-  chromeos::dbus_utils::CallMethodWithTimeout(
+  brillo::dbus_utils::CallMethodWithTimeout(
       kDBusTimeoutMS,
       object_proxy_,
       attestation::kAttestationInterface,
@@ -103,12 +103,12 @@ void DBusProxy::GetEndorsementInfo(const GetEndorsementInfoRequest& request,
 void DBusProxy::GetAttestationKeyInfo(
     const GetAttestationKeyInfoRequest& request,
     const GetAttestationKeyInfoCallback& callback) {
-  auto on_error = [callback](chromeos::Error* error) {
+  auto on_error = [callback](brillo::Error* error) {
     GetAttestationKeyInfoReply reply;
     reply.set_status(STATUS_NOT_AVAILABLE);
     callback.Run(reply);
   };
-  chromeos::dbus_utils::CallMethodWithTimeout(
+  brillo::dbus_utils::CallMethodWithTimeout(
       kDBusTimeoutMS,
       object_proxy_,
       attestation::kAttestationInterface,
@@ -121,12 +121,12 @@ void DBusProxy::GetAttestationKeyInfo(
 void DBusProxy::ActivateAttestationKey(
     const ActivateAttestationKeyRequest& request,
     const ActivateAttestationKeyCallback& callback) {
-  auto on_error = [callback](chromeos::Error* error) {
+  auto on_error = [callback](brillo::Error* error) {
     ActivateAttestationKeyReply reply;
     reply.set_status(STATUS_NOT_AVAILABLE);
     callback.Run(reply);
   };
-  chromeos::dbus_utils::CallMethodWithTimeout(
+  brillo::dbus_utils::CallMethodWithTimeout(
       kDBusTimeoutMS,
       object_proxy_,
       attestation::kAttestationInterface,
@@ -139,12 +139,12 @@ void DBusProxy::ActivateAttestationKey(
 void DBusProxy::CreateCertifiableKey(
     const CreateCertifiableKeyRequest& request,
     const CreateCertifiableKeyCallback& callback) {
-  auto on_error = [callback](chromeos::Error* error) {
+  auto on_error = [callback](brillo::Error* error) {
     CreateCertifiableKeyReply reply;
     reply.set_status(STATUS_NOT_AVAILABLE);
     callback.Run(reply);
   };
-  chromeos::dbus_utils::CallMethodWithTimeout(
+  brillo::dbus_utils::CallMethodWithTimeout(
       kDBusTimeoutMS,
       object_proxy_,
       attestation::kAttestationInterface,
@@ -156,12 +156,12 @@ void DBusProxy::CreateCertifiableKey(
 
 void DBusProxy::Decrypt(const DecryptRequest& request,
                         const DecryptCallback& callback) {
-  auto on_error = [callback](chromeos::Error* error) {
+  auto on_error = [callback](brillo::Error* error) {
     DecryptReply reply;
     reply.set_status(STATUS_NOT_AVAILABLE);
     callback.Run(reply);
   };
-  chromeos::dbus_utils::CallMethodWithTimeout(
+  brillo::dbus_utils::CallMethodWithTimeout(
       kDBusTimeoutMS,
       object_proxy_,
       attestation::kAttestationInterface,
@@ -172,12 +172,12 @@ void DBusProxy::Decrypt(const DecryptRequest& request,
 }
 
 void DBusProxy::Sign(const SignRequest& request, const SignCallback& callback) {
-  auto on_error = [callback](chromeos::Error* error) {
+  auto on_error = [callback](brillo::Error* error) {
     SignReply reply;
     reply.set_status(STATUS_NOT_AVAILABLE);
     callback.Run(reply);
   };
-  chromeos::dbus_utils::CallMethodWithTimeout(
+  brillo::dbus_utils::CallMethodWithTimeout(
       kDBusTimeoutMS,
       object_proxy_,
       attestation::kAttestationInterface,
@@ -190,12 +190,12 @@ void DBusProxy::Sign(const SignRequest& request, const SignCallback& callback) {
 void DBusProxy::RegisterKeyWithChapsToken(
     const RegisterKeyWithChapsTokenRequest& request,
     const RegisterKeyWithChapsTokenCallback& callback) {
-  auto on_error = [callback](chromeos::Error* error) {
+  auto on_error = [callback](brillo::Error* error) {
     RegisterKeyWithChapsTokenReply reply;
     reply.set_status(STATUS_NOT_AVAILABLE);
     callback.Run(reply);
   };
-  chromeos::dbus_utils::CallMethodWithTimeout(
+  brillo::dbus_utils::CallMethodWithTimeout(
       kDBusTimeoutMS,
       object_proxy_,
       attestation::kAttestationInterface,
diff --git a/client/dbus_proxy_test.cc b/client/dbus_proxy_test.cc
index 05856c0..7170a28 100644
--- a/client/dbus_proxy_test.cc
+++ b/client/dbus_proxy_test.cc
@@ -16,7 +16,7 @@
 
 #include <string>
 
-#include <chromeos/bind_lambda.h>
+#include <brillo/bind_lambda.h>
 #include <dbus/mock_object_proxy.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
diff --git a/client/main.cc b/client/main.cc
index 759ea7c..abb3e4e 100644
--- a/client/main.cc
+++ b/client/main.cc
@@ -23,9 +23,9 @@
 #include <base/command_line.h>
 #include <base/files/file_util.h>
 #include <base/message_loop/message_loop.h>
-#include <chromeos/bind_lambda.h>
-#include <chromeos/daemons/daemon.h>
-#include <chromeos/syslog_logging.h>
+#include <brillo/bind_lambda.h>
+#include <brillo/daemons/daemon.h>
+#include <brillo/syslog_logging.h>
 
 #include "attestation/client/dbus_proxy.h"
 #include "attestation/common/attestation_ca.pb.h"
@@ -90,7 +90,7 @@ Commands:
 )";
 
 // The Daemon class works well as a client loop as well.
-using ClientLoopBase = chromeos::Daemon;
+using ClientLoopBase = brillo::Daemon;
 
 class ClientLoop : public ClientLoopBase {
  public:
@@ -497,7 +497,7 @@ class ClientLoop : public ClientLoopBase {
 
 int main(int argc, char* argv[]) {
   base::CommandLine::Init(argc, argv);
-  chromeos::InitLog(chromeos::kLogToSyslog | chromeos::kLogToStderr);
+  brillo::InitLog(brillo::kLogToSyslog | brillo::kLogToStderr);
   attestation::ClientLoop loop;
   return loop.Run();
 }
diff --git a/common/dbus_interface.h b/common/dbus_interface.h
index e62c422..06132b5 100644
--- a/common/dbus_interface.h
+++ b/common/dbus_interface.h
@@ -19,7 +19,7 @@
 
 namespace attestation {
 
-// TODO(namnguyen): Move to chromeos/system_api once we're ready.
+// TODO(namnguyen): Move to brillo/system_api once we're ready.
 constexpr char kAttestationInterface[] = "org.chromium.Attestation";
 constexpr char kAttestationServicePath[] = "/org/chromium/Attestation";
 constexpr char kAttestationServiceName[] = "org.chromium.Attestation";
diff --git a/server/attestation_service.cc b/server/attestation_service.cc
index e8988ae..d7f7974 100644
--- a/server/attestation_service.cc
+++ b/server/attestation_service.cc
@@ -19,10 +19,10 @@
 #include <string>
 
 #include <base/callback.h>
-#include <chromeos/bind_lambda.h>
-#include <chromeos/data_encoding.h>
-#include <chromeos/http/http_utils.h>
-#include <chromeos/mime_utils.h>
+#include <brillo/bind_lambda.h>
+#include <brillo/data_encoding.h>
+#include <brillo/http/http_utils.h>
+#include <brillo/mime_utils.h>
 #include <crypto/sha2.h>
 
 #include "attestation/common/attestation_ca.pb.h"
@@ -680,15 +680,15 @@ bool AttestationService::FinishCertificateRequest(
 bool AttestationService::SendACARequestAndBlock(ACARequestType request_type,
                                                 const std::string& request,
                                                 std::string* reply) {
-  std::shared_ptr<chromeos::http::Transport> transport = http_transport_;
+  std::shared_ptr<brillo::http::Transport> transport = http_transport_;
   if (!transport) {
-    transport = chromeos::http::Transport::CreateDefault();
+    transport = brillo::http::Transport::CreateDefault();
   }
-  std::unique_ptr<chromeos::http::Response> response = PostBinaryAndBlock(
+  std::unique_ptr<brillo::http::Response> response = PostBinaryAndBlock(
       GetACAURL(request_type),
       request.data(),
       request.size(),
-      chromeos::mime::application::kOctet_stream,
+      brillo::mime::application::kOctet_stream,
       {},  // headers
       transport,
       nullptr);  // error
@@ -856,7 +856,7 @@ std::string AttestationService::CreatePEMCertificate(
   const char kEndCertificate[] = "-----END CERTIFICATE-----";
 
   std::string pem = kBeginCertificate;
-  pem += chromeos::data_encoding::Base64EncodeWrapLines(certificate);
+  pem += brillo::data_encoding::Base64EncodeWrapLines(certificate);
   pem += kEndCertificate;
   return pem;
 }
diff --git a/server/attestation_service.h b/server/attestation_service.h
index e74e358..8426272 100644
--- a/server/attestation_service.h
+++ b/server/attestation_service.h
@@ -26,8 +26,8 @@
 #include <base/macros.h>
 #include <base/memory/weak_ptr.h>
 #include <base/threading/thread.h>
-#include <chromeos/bind_lambda.h>
-#include <chromeos/http/http_transport.h>
+#include <brillo/bind_lambda.h>
+#include <brillo/http/http_transport.h>
 
 #include "attestation/common/crypto_utility.h"
 #include "attestation/common/crypto_utility_impl.h"
@@ -101,7 +101,7 @@ class AttestationService : public AttestationInterface {
   }
 
   void set_http_transport(
-      const std::shared_ptr<chromeos::http::Transport>& transport) {
+      const std::shared_ptr<brillo::http::Transport>& transport) {
     http_transport_ = transport;
   }
 
@@ -284,7 +284,7 @@ class AttestationService : public AttestationInterface {
   // worker thread.
   CryptoUtility* crypto_utility_{nullptr};
   Database* database_{nullptr};
-  std::shared_ptr<chromeos::http::Transport> http_transport_;
+  std::shared_ptr<brillo::http::Transport> http_transport_;
   KeyStore* key_store_{nullptr};
   TpmUtility* tpm_utility_{nullptr};
 
diff --git a/server/attestation_service_test.cc b/server/attestation_service_test.cc
index 15856b9..494904b 100644
--- a/server/attestation_service_test.cc
+++ b/server/attestation_service_test.cc
@@ -20,10 +20,10 @@
 #include <base/callback.h>
 #include <base/message_loop/message_loop.h>
 #include <base/run_loop.h>
-#include <chromeos/bind_lambda.h>
-#include <chromeos/data_encoding.h>
-#include <chromeos/http/http_transport_fake.h>
-#include <chromeos/mime_utils.h>
+#include <brillo/bind_lambda.h>
+#include <brillo/data_encoding.h>
+#include <brillo/http/http_transport_fake.h>
+#include <brillo/mime_utils.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -34,8 +34,8 @@
 #include "attestation/server/mock_database.h"
 #include "attestation/server/mock_key_store.h"
 
-using chromeos::http::fake::ServerRequest;
-using chromeos::http::fake::ServerResponse;
+using brillo::http::fake::ServerRequest;
+using brillo::http::fake::ServerResponse;
 using testing::_;
 using testing::DoAll;
 using testing::NiceMock;
@@ -59,7 +59,7 @@ class AttestationServiceTest : public testing::Test {
     service_.reset(new AttestationService);
     service_->set_database(&mock_database_);
     service_->set_crypto_utility(&mock_crypto_utility_);
-    fake_http_transport_ = std::make_shared<chromeos::http::fake::Transport>();
+    fake_http_transport_ = std::make_shared<brillo::http::fake::Transport>();
     service_->set_http_transport(fake_http_transport_);
     service_->set_key_store(&mock_key_store_);
     service_->set_tpm_utility(&mock_tpm_utility_);
@@ -77,7 +77,7 @@ class AttestationServiceTest : public testing::Test {
   void SetupFakeCAEnroll(FakeCAState state) {
     fake_http_transport_->AddHandler(
         service_->attestation_ca_origin() + "/enroll",
-        chromeos::http::request_type::kPost,
+        brillo::http::request_type::kPost,
         base::Bind(&AttestationServiceTest::FakeCAEnroll,
                    base::Unretained(this),
                    state));
@@ -86,7 +86,7 @@ class AttestationServiceTest : public testing::Test {
   void SetupFakeCASign(FakeCAState state) {
     fake_http_transport_->AddHandler(
         service_->attestation_ca_origin() + "/sign",
-        chromeos::http::request_type::kPost,
+        brillo::http::request_type::kPost,
         base::Bind(&AttestationServiceTest::FakeCASign,
                    base::Unretained(this),
                    state));
@@ -96,11 +96,11 @@ class AttestationServiceTest : public testing::Test {
     const std::string kBeginCertificate = "-----BEGIN CERTIFICATE-----\n";
     const std::string kEndCertificate = "-----END CERTIFICATE-----";
     std::string pem = kBeginCertificate;
-    pem += chromeos::data_encoding::Base64EncodeWrapLines("fake_cert");
+    pem += brillo::data_encoding::Base64EncodeWrapLines("fake_cert");
     pem += kEndCertificate + "\n" + kBeginCertificate;
-    pem += chromeos::data_encoding::Base64EncodeWrapLines("fake_ca_cert");
+    pem += brillo::data_encoding::Base64EncodeWrapLines("fake_ca_cert");
     pem += kEndCertificate + "\n" + kBeginCertificate;
-    pem += chromeos::data_encoding::Base64EncodeWrapLines("fake_ca_cert2");
+    pem += brillo::data_encoding::Base64EncodeWrapLines("fake_ca_cert2");
     pem += kEndCertificate;
     return pem;
   }
@@ -128,7 +128,7 @@ class AttestationServiceTest : public testing::Test {
     run_loop_.Quit();
   }
 
-  std::shared_ptr<chromeos::http::fake::Transport> fake_http_transport_;
+  std::shared_ptr<brillo::http::fake::Transport> fake_http_transport_;
   NiceMock<MockCryptoUtility> mock_crypto_utility_;
   NiceMock<MockDatabase> mock_database_;
   NiceMock<MockKeyStore> mock_key_store_;
@@ -142,8 +142,8 @@ class AttestationServiceTest : public testing::Test {
     AttestationEnrollmentRequest request_pb;
     EXPECT_TRUE(request_pb.ParseFromString(request.GetDataAsString()));
     if (state == kHttpFailure) {
-      response->ReplyText(chromeos::http::status_code::NotFound, std::string(),
-                          chromeos::mime::application::kOctet_stream);
+      response->ReplyText(brillo::http::status_code::NotFound, std::string(),
+                          brillo::mime::application::kOctet_stream);
       return;
     }
     AttestationEnrollmentResponse response_pb;
@@ -162,8 +162,8 @@ class AttestationServiceTest : public testing::Test {
     }
     std::string tmp;
     response_pb.SerializeToString(&tmp);
-    response->ReplyText(chromeos::http::status_code::Ok, tmp,
-                        chromeos::mime::application::kOctet_stream);
+    response->ReplyText(brillo::http::status_code::Ok, tmp,
+                        brillo::mime::application::kOctet_stream);
   }
 
   void FakeCASign(FakeCAState state,
@@ -172,8 +172,8 @@ class AttestationServiceTest : public testing::Test {
     AttestationCertificateRequest request_pb;
     EXPECT_TRUE(request_pb.ParseFromString(request.GetDataAsString()));
     if (state == kHttpFailure) {
-      response->ReplyText(chromeos::http::status_code::NotFound, std::string(),
-                          chromeos::mime::application::kOctet_stream);
+      response->ReplyText(brillo::http::status_code::NotFound, std::string(),
+                          brillo::mime::application::kOctet_stream);
       return;
     }
     AttestationCertificateResponse response_pb;
@@ -192,8 +192,8 @@ class AttestationServiceTest : public testing::Test {
     }
     std::string tmp;
     response_pb.SerializeToString(&tmp);
-    response->ReplyText(chromeos::http::status_code::Ok, tmp,
-                        chromeos::mime::application::kOctet_stream);
+    response->ReplyText(brillo::http::status_code::Ok, tmp,
+                        brillo::mime::application::kOctet_stream);
   }
 
   base::MessageLoop message_loop_;
diff --git a/server/database_impl.cc b/server/database_impl.cc
index 299b6f7..48cdfe5 100644
--- a/server/database_impl.cc
+++ b/server/database_impl.cc
@@ -28,7 +28,7 @@
 #include <base/files/important_file_writer.h>
 #include <base/logging.h>
 #include <base/stl_util.h>
-#include <chromeos/secure_blob.h>
+#include <brillo/secure_blob.h>
 
 using base::FilePath;
 
@@ -51,8 +51,8 @@ DatabaseImpl::DatabaseImpl(CryptoUtility* crypto) : io_(this), crypto_(crypto) {
 }
 
 DatabaseImpl::~DatabaseImpl() {
-  chromeos::SecureMemset(string_as_array(&database_key_), 0,
-                         database_key_.size());
+  brillo::SecureMemset(string_as_array(&database_key_), 0,
+                       database_key_.size());
 }
 
 void DatabaseImpl::Initialize() {
diff --git a/server/dbus_service.cc b/server/dbus_service.cc
index ff4372a..9c25dab 100644
--- a/server/dbus_service.cc
+++ b/server/dbus_service.cc
@@ -19,13 +19,13 @@
 #include <memory>
 #include <string>
 
-#include <chromeos/bind_lambda.h>
+#include <brillo/bind_lambda.h>
 #include <dbus/bus.h>
 #include <dbus/object_path.h>
 
 #include "attestation/common/dbus_interface.h"
 
-using chromeos::dbus_utils::DBusMethodResponse;
+using brillo::dbus_utils::DBusMethodResponse;
 
 namespace attestation {
 
@@ -36,7 +36,7 @@ DBusService::DBusService(const scoped_refptr<dbus::Bus>& bus,
 }
 
 void DBusService::Register(const CompletionAction& callback) {
-  chromeos::dbus_utils::DBusInterface* dbus_interface =
+  brillo::dbus_utils::DBusInterface* dbus_interface =
       dbus_object_.AddOrGetInterface(kAttestationInterface);
 
   dbus_interface->AddMethodHandler(kCreateGoogleAttestedKey,
diff --git a/server/dbus_service.h b/server/dbus_service.h
index cb4acc3..dd4281c 100644
--- a/server/dbus_service.h
+++ b/server/dbus_service.h
@@ -19,8 +19,8 @@
 
 #include <memory>
 
-#include <chromeos/dbus/dbus_method_response.h>
-#include <chromeos/dbus/dbus_object.h>
+#include <brillo/dbus/dbus_method_response.h>
+#include <brillo/dbus/dbus_object.h>
 #include <dbus/bus.h>
 
 #include "attestation/common/attestation_interface.h"
@@ -28,7 +28,7 @@
 namespace attestation {
 
 using CompletionAction =
-    chromeos::dbus_utils::AsyncEventSequencer::CompletionAction;
+    brillo::dbus_utils::AsyncEventSequencer::CompletionAction;
 
 // Handles D-Bus calls to the attestation daemon.
 class DBusService {
@@ -52,59 +52,59 @@ class DBusService {
 
   // Handles a CreateGoogleAttestedKey D-Bus call.
   void HandleCreateGoogleAttestedKey(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<
           const CreateGoogleAttestedKeyReply&>> response,
       const CreateGoogleAttestedKeyRequest& request);
 
   // Handles a GetKeyInfo D-Bus call.
   void HandleGetKeyInfo(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<
           const GetKeyInfoReply&>> response,
       const GetKeyInfoRequest& request);
 
   // Handles a GetEndorsementInfo D-Bus call.
   void HandleGetEndorsementInfo(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<
           const GetEndorsementInfoReply&>> response,
       const GetEndorsementInfoRequest& request);
 
   // Handles a GetAttestationKeyInfo D-Bus call.
   void HandleGetAttestationKeyInfo(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<
           const GetAttestationKeyInfoReply&>> response,
       const GetAttestationKeyInfoRequest& request);
 
   // Handles a ActivateAttestationKey D-Bus call.
   void HandleActivateAttestationKey(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<
           const ActivateAttestationKeyReply&>> response,
       const ActivateAttestationKeyRequest& request);
 
   // Handles a CreateCertifiableKey D-Bus call.
   void HandleCreateCertifiableKey(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<
           const CreateCertifiableKeyReply&>> response,
       const CreateCertifiableKeyRequest& request);
 
   // Handles a Decrypt D-Bus call.
   void HandleDecrypt(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<
           const DecryptReply&>> response,
       const DecryptRequest& request);
 
   // Handles a Sign D-Bus call.
   void HandleSign(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<
           const SignReply&>> response,
       const SignRequest& request);
 
   // Handles a RegisterKeyWithChapsToken D-Bus call.
   void HandleRegisterKeyWithChapsToken(
-      std::unique_ptr<chromeos::dbus_utils::DBusMethodResponse<
+      std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<
           const RegisterKeyWithChapsTokenReply&>> response,
       const RegisterKeyWithChapsTokenRequest& request);
 
-  chromeos::dbus_utils::DBusObject dbus_object_;
+  brillo::dbus_utils::DBusObject dbus_object_;
   AttestationInterface* service_;
 
   DISALLOW_COPY_AND_ASSIGN(DBusService);
diff --git a/server/dbus_service_test.cc b/server/dbus_service_test.cc
index 71a3e9c..ebe6acc 100644
--- a/server/dbus_service_test.cc
+++ b/server/dbus_service_test.cc
@@ -16,8 +16,8 @@
 
 #include <string>
 
-#include <chromeos/bind_lambda.h>
-#include <chromeos/dbus/dbus_object_test_helpers.h>
+#include <brillo/bind_lambda.h>
+#include <brillo/dbus/dbus_object_test_helpers.h>
 #include <dbus/mock_bus.h>
 #include <dbus/mock_exported_object.h>
 #include <gmock/gmock.h>
@@ -48,12 +48,12 @@ class DBusServiceTest : public testing::Test {
     ON_CALL(*mock_bus_, GetExportedObject(path))
         .WillByDefault(Return(mock_exported_object_.get()));
     dbus_service_.reset(new DBusService(mock_bus_, &mock_service_));
-    dbus_service_->Register(chromeos::dbus_utils::AsyncEventSequencer::
+    dbus_service_->Register(brillo::dbus_utils::AsyncEventSequencer::
                                 GetDefaultCompletionAction());
   }
 
   std::unique_ptr<dbus::Response> CallMethod(dbus::MethodCall* method_call) {
-    return chromeos::dbus_utils::testing::CallMethod(
+    return brillo::dbus_utils::testing::CallMethod(
         dbus_service_->dbus_object_, method_call);
   }
 
diff --git a/server/main.cc b/server/main.cc
index 8af931d..247485d 100644
--- a/server/main.cc
+++ b/server/main.cc
@@ -20,17 +20,17 @@
 #include <string>
 
 #include <base/command_line.h>
-#include <chromeos/daemons/dbus_daemon.h>
-#include <chromeos/dbus/async_event_sequencer.h>
-#include <chromeos/minijail/minijail.h>
-#include <chromeos/syslog_logging.h>
-#include <chromeos/userdb_utils.h>
+#include <brillo/daemons/dbus_daemon.h>
+#include <brillo/dbus/async_event_sequencer.h>
+#include <brillo/minijail/minijail.h>
+#include <brillo/syslog_logging.h>
+#include <brillo/userdb_utils.h>
 
 #include "attestation/common/dbus_interface.h"
 #include "attestation/server/attestation_service.h"
 #include "attestation/server/dbus_service.h"
 
-#include <chromeos/libminijail.h>
+#include <brillo/libminijail.h>
 
 namespace {
 
@@ -43,12 +43,12 @@ const char kAttestationSeccompPath[] =
 void InitMinijailSandbox() {
   uid_t attestation_uid;
   gid_t attestation_gid;
-  CHECK(chromeos::userdb::GetUserInfo(kAttestationUser,
+  CHECK(brillo::userdb::GetUserInfo(kAttestationUser,
                                       &attestation_uid,
                                       &attestation_gid))
       << "Error getting attestation uid and gid.";
   CHECK_EQ(getuid(), kRootUID) << "AttestationDaemon not initialized as root.";
-  chromeos::Minijail* minijail = chromeos::Minijail::GetInstance();
+  brillo::Minijail* minijail = brillo::Minijail::GetInstance();
   struct minijail* jail = minijail->New();
 
   minijail->DropRoot(jail, kAttestationUser, kAttestationGroup);
@@ -63,12 +63,12 @@ void InitMinijailSandbox() {
 
 }  // namespace
 
-using chromeos::dbus_utils::AsyncEventSequencer;
+using brillo::dbus_utils::AsyncEventSequencer;
 
-class AttestationDaemon : public chromeos::DBusServiceDaemon {
+class AttestationDaemon : public brillo::DBusServiceDaemon {
  public:
   AttestationDaemon()
-      : chromeos::DBusServiceDaemon(attestation::kAttestationServiceName) {
+      : brillo::DBusServiceDaemon(attestation::kAttestationServiceName) {
     attestation_service_.reset(new attestation::AttestationService);
     // Move initialize call down to OnInit
     CHECK(attestation_service_->Initialize());
@@ -76,7 +76,7 @@ class AttestationDaemon : public chromeos::DBusServiceDaemon {
 
  protected:
   int OnInit() override {
-    int result = chromeos::DBusServiceDaemon::OnInit();
+    int result = brillo::DBusServiceDaemon::OnInit();
     if (result != EX_OK) {
       LOG(ERROR) << "Error starting attestation dbus daemon.";
       return result;
@@ -100,7 +100,7 @@ class AttestationDaemon : public chromeos::DBusServiceDaemon {
 
 int main(int argc, char* argv[]) {
   base::CommandLine::Init(argc, argv);
-  chromeos::InitLog(chromeos::kLogToSyslog | chromeos::kLogToStderr);
+  brillo::InitLog(brillo::kLogToSyslog | brillo::kLogToStderr);
   AttestationDaemon daemon;
   LOG(INFO) << "Attestation Daemon Started.";
   InitMinijailSandbox();
diff --git a/server/pkcs11_key_store.cc b/server/pkcs11_key_store.cc
index 219a961..45be47e 100644
--- a/server/pkcs11_key_store.cc
+++ b/server/pkcs11_key_store.cc
@@ -28,7 +28,7 @@
 #include <chaps/isolate.h>
 #include <chaps/pkcs11/cryptoki.h>
 #include <chaps/token_manager_client.h>
-#include <chromeos/cryptohome.h>
+#include <brillo/cryptohome.h>
 #include <crypto/scoped_openssl_types.h>
 #include <openssl/rsa.h>
 #include <openssl/sha.h>
@@ -495,7 +495,7 @@ bool Pkcs11KeyStore::GetUserSlot(const std::string& username,
   const char kChapsSystemToken[] = "/var/lib/chaps";
   base::FilePath token_path = username.empty() ?
       base::FilePath(kChapsSystemToken) :
-      chromeos::cryptohome::home::GetDaemonPath(username, kChapsDaemonName);
+      brillo::cryptohome::home::GetDaemonPath(username, kChapsDaemonName);
   CK_RV rv;
   rv = C_Initialize(nullptr);
   if (rv != CKR_OK && rv != CKR_CRYPTOKI_ALREADY_INITIALIZED) {
diff --git a/server/pkcs11_key_store_test.cc b/server/pkcs11_key_store_test.cc
index 7fbae1e..5cd4e82 100644
--- a/server/pkcs11_key_store_test.cc
+++ b/server/pkcs11_key_store_test.cc
@@ -25,8 +25,8 @@
 #include <chaps/attributes.h>
 #include <chaps/chaps_proxy_mock.h>
 #include <chaps/token_manager_client_mock.h>
-#include <chromeos/cryptohome.h>
-#include <chromeos/map_utils.h>
+#include <brillo/cryptohome.h>
+#include <brillo/map_utils.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -99,10 +99,10 @@ std::string HexDecode(const std::string hex) {
 class ScopedFakeSalt {
  public:
   ScopedFakeSalt() : salt_(128, 0) {
-    chromeos::cryptohome::home::SetSystemSalt(&salt_);
+    brillo::cryptohome::home::SetSystemSalt(&salt_);
   }
   ~ScopedFakeSalt() {
-    chromeos::cryptohome::home::SetSystemSalt(nullptr);
+    brillo::cryptohome::home::SetSystemSalt(nullptr);
   }
 
  private:
@@ -168,14 +168,14 @@ class KeyStoreTest : public testing::Test {
     base::FilePath system_path("/var/lib/chaps");
     ON_CALL(token_manager_, GetTokenPath(_, 0, _))
         .WillByDefault(DoAll(SetArgumentPointee<2>(system_path), Return(true)));
-    base::FilePath user_path(chromeos::cryptohome::home::GetDaemonPath(
+    base::FilePath user_path(brillo::cryptohome::home::GetDaemonPath(
         kDefaultUser, "chaps"));
     ON_CALL(token_manager_, GetTokenPath(_, 1, _))
         .WillByDefault(DoAll(SetArgumentPointee<2>(user_path), Return(true)));
   }
 
   // Stores a new labeled object, only CKA_LABEL and CKA_VALUE are relevant.
-  virtual uint32_t CreateObject(const chromeos::SecureBlob& isolate,
+  virtual uint32_t CreateObject(const brillo::SecureBlob& isolate,
                                 uint64_t session_id,
                                 const std::vector<uint8_t>& attributes,
                                 uint64_t* new_object_handle) {
@@ -188,7 +188,7 @@ class KeyStoreTest : public testing::Test {
   }
 
   // Deletes a labeled object.
-  virtual uint32_t DestroyObject(const chromeos::SecureBlob& isolate,
+  virtual uint32_t DestroyObject(const brillo::SecureBlob& isolate,
                                  uint64_t session_id,
                                  uint64_t object_handle) {
     std::string label = handles_[object_handle];
@@ -199,7 +199,7 @@ class KeyStoreTest : public testing::Test {
   }
 
   // Supports reading CKA_VALUE.
-  virtual uint32_t GetAttributeValue(const chromeos::SecureBlob& isolate,
+  virtual uint32_t GetAttributeValue(const brillo::SecureBlob& isolate,
                                      uint64_t session_id,
                                      uint64_t object_handle,
                                      const std::vector<uint8_t>& attributes_in,
@@ -226,7 +226,7 @@ class KeyStoreTest : public testing::Test {
 
   // Supports writing CKA_VALUE.
   virtual uint32_t SetAttributeValue(
-      const chromeos::SecureBlob& isolate,
+      const brillo::SecureBlob& isolate,
       uint64_t session_id,
       uint64_t object_handle,
       const std::vector<uint8_t>& attributes) {
@@ -236,7 +236,7 @@ class KeyStoreTest : public testing::Test {
 
   // Finds stored objects by CKA_LABEL or CKA_VALUE. If no CKA_LABEL or
   // CKA_VALUE, find all objects.
-  virtual uint32_t FindObjectsInit(const chromeos::SecureBlob& isolate,
+  virtual uint32_t FindObjectsInit(const brillo::SecureBlob& isolate,
                                    uint64_t session_id,
                                    const std::vector<uint8_t>& attributes) {
     std::string label = GetValue(attributes, CKA_LABEL);
@@ -244,7 +244,7 @@ class KeyStoreTest : public testing::Test {
     found_objects_.clear();
     if (label.empty() && value.empty()) {
       // Find all objects.
-      found_objects_ = chromeos::GetMapKeysAsVector(handles_);
+      found_objects_ = brillo::GetMapKeysAsVector(handles_);
     } else if (!label.empty() && labels_.count(label) > 0) {
       // Find only the object with |label|.
       found_objects_.push_back(labels_[label]);
@@ -260,7 +260,7 @@ class KeyStoreTest : public testing::Test {
   }
 
   // Reports a 'found' object based on find_status_.
-  virtual uint32_t FindObjects(const chromeos::SecureBlob& isolate,
+  virtual uint32_t FindObjects(const brillo::SecureBlob& isolate,
                                uint64_t session_id,
                                uint64_t max_object_count,
                                std::vector<uint64_t>* object_list) {