diff --git a/chromeos/any.h b/chromeos/any.h
index bda7e60..fa09a13 100644
--- a/chromeos/any.h
+++ b/chromeos/any.h
@@ -112,11 +112,10 @@
   // convertible to/compatible with it.
   template<typename T>
   const T& Get() const {
-    CHECK(IsTypeCompatible<T>()) << "Requesting value of type '"
-                                 << GetUndecoratedTypeName<T>()
-                                 << "' from variant containing '"
-                                 << UndecorateTypeName(GetType().name())
-                                 << "'";
+    CHECK(IsTypeCompatible<T>())
+        << "Requesting value of type '" << GetUndecoratedTypeName<T>()
+        << "' from variant containing '" << UndecorateTypeName(GetType().name())
+        << "'";
     return data_buffer_.GetData<T>();
   }
 
@@ -193,4 +192,3 @@
 }  // namespace std
 
 #endif  // LIBCHROMEOS_CHROMEOS_ANY_H_
-
diff --git a/chromeos/any_internal_impl.h b/chromeos/any_internal_impl.h
index 13aef03..3944baa 100644
--- a/chromeos/any_internal_impl.h
+++ b/chromeos/any_internal_impl.h
@@ -22,10 +22,12 @@
 // An extension to std::is_convertible to allow conversion from an enum to
 // an integral type which std::is_convertible does not indicate as supported.
 template <typename From, typename To>
-struct IsConvertible : public std::integral_constant<bool,
-    std::is_convertible<From, To>::value ||
-    (std::is_enum<From>::value && std::is_integral<To>::value)> {
-};
+struct IsConvertible
+    : public std::integral_constant<
+          bool,
+          std::is_convertible<From, To>::value ||
+              (std::is_enum<From>::value && std::is_integral<To>::value)> {};
+
 // TryConvert is a helper function that does a safe compile-time conditional
 // type cast between data types that may not be always convertible.
 // From and To are the source and destination types.
@@ -101,7 +103,7 @@
   // lvalue references to type U which is not necessarily default-constructible.
   template<typename U>
   static decltype((std::declval<U&>() == std::declval<U&>()), std::true_type())
-      TriggerFunction(int dummy);
+  TriggerFunction(int dummy);
 
   // Finally, use the return type of the overload of TriggerFunction that
   // matches the argument (int) to be aliased to type |type|. If T is
@@ -117,18 +119,21 @@
 // type is non-comparable. We just use |type| alias from
 // IsEqualityComparableHelper<T> as the base class.
 template<typename T>
-struct IsEqualityComparable : IsEqualityComparableHelper<T>::type {
-};
+struct IsEqualityComparable : IsEqualityComparableHelper<T>::type {};
 
 // EqCompare() overload for non-comparable types. Always returns false.
 template<typename T>
 inline typename std::enable_if<!IsEqualityComparable<T>::value, bool>::type
-    EqCompare(const T& v1, const T& v2) { return false; }
+EqCompare(const T& v1, const T& v2) {
+  return false;
+}
 
 // EqCompare overload for comparable types. Calls operator==(v1, v2) to compare.
 template<typename T>
 inline typename std::enable_if<IsEqualityComparable<T>::value, bool>::type
-    EqCompare(const T& v1, const T& v2) { return (v1 == v2); }
+EqCompare(const T& v1, const T& v2) {
+  return (v1 == v2);
+}
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -170,8 +175,7 @@
     intmax_t int_val = 0;
     bool converted = TryConvert(value_, &int_val);
     CHECK(converted) << "Unable to convert value of type '"
-                     << GetUndecoratedTypeName<T>()
-                     << "' to integer";
+                     << GetUndecoratedTypeName<T>() << "' to integer";
     return int_val;
   }
 
@@ -216,17 +220,11 @@
  public:
   enum StorageType { kExternal, kContained };
   Buffer() : external_ptr_(nullptr), storage_(kExternal) {}
-  ~Buffer() {
-    Clear();
-  }
+  ~Buffer() { Clear(); }
 
-  Buffer(const Buffer& rhs) : Buffer() {
-    rhs.CopyTo(this);
-  }
+  Buffer(const Buffer& rhs) : Buffer() { rhs.CopyTo(this); }
   // NOLINTNEXTLINE(build/c++11)
-  Buffer(Buffer&& rhs) : Buffer() {
-    rhs.MoveTo(this);
-  }
+  Buffer(Buffer&& rhs) : Buffer() { rhs.MoveTo(this); }
   Buffer& operator=(const Buffer& rhs) {
     rhs.CopyTo(this);
     return *this;
@@ -240,12 +238,13 @@
   // Returns the underlying pointer to contained data. Uses either the pointer
   // or the raw data depending on |storage_| type.
   inline Data* GetDataPtr() {
-    return (storage_ == kExternal) ?
-        external_ptr_ : reinterpret_cast<Data*>(contained_buffer_);
+    return (storage_ == kExternal) ? external_ptr_
+                                   : reinterpret_cast<Data*>(contained_buffer_);
   }
   inline const Data* GetDataPtr() const {
-    return (storage_ == kExternal) ?
-        external_ptr_ : reinterpret_cast<const Data*>(contained_buffer_);
+    return (storage_ == kExternal)
+               ? external_ptr_
+               : reinterpret_cast<const Data*>(contained_buffer_);
   }
 
   // Destroys the contained object (and frees memory if needed).
@@ -358,14 +357,17 @@
   StorageType storage_;  // Declare after the union to eliminate member padding.
 };
 
-template<typename T>
-void TypedData<T>::CopyTo(Buffer* buffer) const { buffer->Assign(value_); }
-template<typename T>
-void TypedData<T>::MoveTo(Buffer* buffer) { buffer->Assign(std::move(value_)); }
+template <typename T>
+void TypedData<T>::CopyTo(Buffer* buffer) const {
+  buffer->Assign(value_);
+}
+template <typename T>
+void TypedData<T>::MoveTo(Buffer* buffer) {
+  buffer->Assign(std::move(value_));
+}
 
 }  // namespace internal_details
 
 }  // namespace chromeos
 
 #endif  // LIBCHROMEOS_CHROMEOS_ANY_INTERNAL_IMPL_H_
-
diff --git a/chromeos/any_unittest.cc b/chromeos/any_unittest.cc
index 289a0ef..a1114d9 100644
--- a/chromeos/any_unittest.cc
+++ b/chromeos/any_unittest.cc
@@ -304,4 +304,3 @@
   EXPECT_NE(person1, person3);
   EXPECT_NE(person2, person3);
 }
-
diff --git a/chromeos/asynchronous_signal_handler.cc b/chromeos/asynchronous_signal_handler.cc
index 0e02956..5bb430d 100644
--- a/chromeos/asynchronous_signal_handler.cc
+++ b/chromeos/asynchronous_signal_handler.cc
@@ -45,7 +45,10 @@
       signalfd(descriptor_, &signal_mask_, SFD_CLOEXEC | SFD_NONBLOCK);
   CHECK_NE(kInvalidDescriptor, descriptor_);
   CHECK(base::MessageLoopForIO::current()->WatchFileDescriptor(
-      descriptor_, true, base::MessageLoopForIO::WATCH_READ, fd_watcher_.get(),
+      descriptor_,
+      true,
+      base::MessageLoopForIO::WATCH_READ,
+      fd_watcher_.get(),
       this))
       << "Watching shutdown pipe failed.";
 }
diff --git a/chromeos/asynchronous_signal_handler_unittest.cc b/chromeos/asynchronous_signal_handler_unittest.cc
index ca1c870..9c9055e 100644
--- a/chromeos/asynchronous_signal_handler_unittest.cc
+++ b/chromeos/asynchronous_signal_handler_unittest.cc
@@ -24,9 +24,7 @@
   AsynchronousSignalHandlerTest() {}
   virtual ~AsynchronousSignalHandlerTest() {}
 
-  virtual void SetUp() {
-    handler_.Init();
-  }
+  virtual void SetUp() { handler_.Init(); }
 
   virtual void TearDown() {}
 
@@ -53,8 +51,10 @@
 
 TEST_F(AsynchronousSignalHandlerTest, CheckTerm) {
   handler_.RegisterHandler(
-      SIGTERM, base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
-                          base::Unretained(this), true));
+      SIGTERM,
+      base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
+                 base::Unretained(this),
+                 true));
   EXPECT_EQ(0, infos_.size());
   EXPECT_EQ(0, kill(getpid(), SIGTERM));
 
@@ -67,8 +67,10 @@
 
 TEST_F(AsynchronousSignalHandlerTest, CheckSignalUnregistration) {
   handler_.RegisterHandler(
-      SIGCHLD, base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
-                          base::Unretained(this), true));
+      SIGCHLD,
+      base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
+                 base::Unretained(this),
+                 true));
   EXPECT_EQ(0, infos_.size());
   EXPECT_EQ(0, kill(getpid(), SIGCHLD));
 
@@ -81,7 +83,8 @@
   EXPECT_EQ(0, kill(getpid(), SIGCHLD));
 
   // Run the loop with a timeout, as no message are expected.
-  loop_.PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
+  loop_.PostDelayedTask(FROM_HERE,
+                        base::MessageLoop::QuitClosure(),
                         base::TimeDelta::FromMilliseconds(10));
   Run();
 
@@ -93,8 +96,10 @@
 TEST_F(AsynchronousSignalHandlerTest, CheckMultipleSignal) {
   const uint8_t NB_SIGNALS = 5;
   handler_.RegisterHandler(
-      SIGCHLD, base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
-                          base::Unretained(this), false));
+      SIGCHLD,
+      base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
+                 base::Unretained(this),
+                 false));
   EXPECT_EQ(0, infos_.size());
   for (int i = 0; i < NB_SIGNALS; ++i) {
     EXPECT_EQ(0, kill(getpid(), SIGCHLD));
@@ -111,8 +116,10 @@
 
 TEST_F(AsynchronousSignalHandlerTest, CheckChld) {
   handler_.RegisterHandler(
-      SIGCHLD, base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
-                          base::Unretained(this), false));
+      SIGCHLD,
+      base::Bind(&AsynchronousSignalHandlerTest::RecordInfoAndQuit,
+                 base::Unretained(this),
+                 false));
   pid_t child_pid = fork();
   if (child_pid == 0) {
     _Exit(EXIT_SUCCESS);
diff --git a/chromeos/bind_lambda.h b/chromeos/bind_lambda.h
index ba1d748..27b4d4e 100644
--- a/chromeos/bind_lambda.h
+++ b/chromeos/bind_lambda.h
@@ -50,12 +50,11 @@
 };
 
 template <typename Lambda>
-class RunnableAdapter : public LambdaAdapter<Lambda,
-                                             decltype(&Lambda::operator())> {
+class RunnableAdapter
+    : public LambdaAdapter<Lambda, decltype(&Lambda::operator())> {
  public:
-  explicit RunnableAdapter(Lambda lambda) :
-      LambdaAdapter<Lambda, decltype(&Lambda::operator())>(lambda) {
-  }
+  explicit RunnableAdapter(Lambda lambda)
+      : LambdaAdapter<Lambda, decltype(&Lambda::operator())>(lambda) {}
 };
 
 }  // namespace internal
diff --git a/chromeos/bootstat/bootstat.h b/chromeos/bootstat/bootstat.h
index b1b8b4d..d568b38 100644
--- a/chromeos/bootstat/bootstat.h
+++ b/chromeos/bootstat/bootstat.h
@@ -24,7 +24,7 @@
 // bootstat_log.c regarding implementation assumptions for this
 // value.
 //
-#define BOOTSTAT_MAX_EVENT_LEN  64
+#define BOOTSTAT_MAX_EVENT_LEN 64
 
 // Log an event.  Event names should be composed of characters drawn
 // from this subset of 7-bit ASCII:  Letters (upper- or lower-case),
diff --git a/chromeos/cryptohome.cc b/chromeos/cryptohome.cc
index b6189ae..f7f4f93 100644
--- a/chromeos/cryptohome.cc
+++ b/chromeos/cryptohome.cc
@@ -36,7 +36,7 @@
   FilePath salt_path(g_system_salt_path);
   int64_t file_size;
   if (!base::GetFileSize(salt_path, &file_size)) {
-    PLOG(ERROR) << "Could not get size of system salt: " <<  g_system_salt_path;
+    PLOG(ERROR) << "Could not get size of system salt: " << g_system_salt_path;
     return false;
   }
   if (file_size > static_cast<int64_t>(std::numeric_limits<int>::max())) {
@@ -47,8 +47,8 @@
   buf.resize(file_size);
   unsigned int data_read = base::ReadFile(salt_path, &buf.front(), file_size);
   if (data_read != file_size) {
-    PLOG(ERROR) << "Could not read entire file: " << data_read << " != "
-                << file_size;
+    PLOG(ERROR) << "Could not read entire file: " << data_read
+                << " != " << file_size;
     return false;
   }
 
@@ -64,8 +64,8 @@
 
   unsigned char binmd[SHA_DIGEST_LENGTH];
   std::string lowercase(username);
-  std::transform(lowercase.begin(), lowercase.end(),
-                 lowercase.begin(), ::tolower);
+  std::transform(
+      lowercase.begin(), lowercase.end(), lowercase.begin(), ::tolower);
   SHA_CTX ctx;
   SHA1_Init(&ctx);
   SHA1_Update(&ctx, salt->data(), salt->size());
@@ -86,8 +86,8 @@
 }
 
 FilePath GetHashedUserPath(const std::string& hashed_username) {
-  return FilePath(base::StringPrintf("%s%s", g_user_home_prefix,
-                                     hashed_username.c_str()));
+  return FilePath(
+      base::StringPrintf("%s%s", g_user_home_prefix, hashed_username.c_str()));
 }
 
 FilePath GetUserPath(const std::string& username) {
@@ -99,8 +99,8 @@
 FilePath GetRootPath(const std::string& username) {
   if (!EnsureSystemSaltIsLoaded())
     return FilePath("");
-  return FilePath(base::StringPrintf("%s%s", g_root_home_prefix,
-                                     SanitizeUserName(username).c_str()));
+  return FilePath(base::StringPrintf(
+      "%s%s", g_root_home_prefix, SanitizeUserName(username).c_str()));
 }
 
 FilePath GetDaemonPath(const std::string& username, const std::string& daemon) {
@@ -112,24 +112,20 @@
 bool IsSanitizedUserName(const std::string& sanitized) {
   std::vector<uint8_t> bytes;
   return (sanitized.length() == 2 * SHA_DIGEST_LENGTH) &&
-      base::HexStringToBytes(sanitized, &bytes);
+         base::HexStringToBytes(sanitized, &bytes);
 }
 
 void SetUserHomePrefix(const std::string& prefix) {
   if (prefix.length() < sizeof(g_user_home_prefix)) {
-    snprintf(g_user_home_prefix,
-             sizeof(g_user_home_prefix),
-             "%s",
-             prefix.c_str());
+    snprintf(
+        g_user_home_prefix, sizeof(g_user_home_prefix), "%s", prefix.c_str());
   }
 }
 
 void SetRootHomePrefix(const std::string& prefix) {
   if (prefix.length() < sizeof(g_root_home_prefix)) {
-    snprintf(g_root_home_prefix,
-             sizeof(g_root_home_prefix),
-             "%s",
-             prefix.c_str());
+    snprintf(
+        g_root_home_prefix, sizeof(g_root_home_prefix), "%s", prefix.c_str());
   }
 }
 
diff --git a/chromeos/daemons/dbus_daemon.cc b/chromeos/daemons/dbus_daemon.cc
index c6cb986..f343746 100644
--- a/chromeos/daemons/dbus_daemon.cc
+++ b/chromeos/daemons/dbus_daemon.cc
@@ -38,21 +38,19 @@
 }
 
 DBusServiceDaemon::DBusServiceDaemon(const std::string& service_name)
-        : service_name_(service_name) {
+    : service_name_(service_name) {
 }
 
 DBusServiceDaemon::DBusServiceDaemon(
     const std::string& service_name,
     const dbus::ObjectPath& object_manager_path)
-        : service_name_(service_name),
-          object_manager_path_(object_manager_path) {
+    : service_name_(service_name), object_manager_path_(object_manager_path) {
 }
 
-DBusServiceDaemon::DBusServiceDaemon(
-    const std::string& service_name,
-    base::StringPiece object_manager_path)
-        : DBusServiceDaemon(service_name,
-                            dbus::ObjectPath(object_manager_path.as_string())) {
+DBusServiceDaemon::DBusServiceDaemon(const std::string& service_name,
+                                     base::StringPiece object_manager_path)
+    : DBusServiceDaemon(service_name,
+                        dbus::ObjectPath(object_manager_path.as_string())) {
 }
 
 int DBusServiceDaemon::OnInit() {
@@ -62,8 +60,8 @@
 
   scoped_refptr<AsyncEventSequencer> sequencer(new AsyncEventSequencer());
   if (object_manager_path_.IsValid()) {
-    object_manager_.reset(new ExportedObjectManager(bus_,
-                                                    object_manager_path_));
+    object_manager_.reset(
+        new ExportedObjectManager(bus_, object_manager_path_));
     object_manager_->RegisterAsync(
         sequencer->GetHandler("ObjectManager.RegisterAsync() failed.", true));
   }
diff --git a/chromeos/data_encoding.cc b/chromeos/data_encoding.cc
index ba3fc1c..b3468b9 100644
--- a/chromeos/data_encoding.cc
+++ b/chromeos/data_encoding.cc
@@ -35,10 +35,9 @@
     char c = *data++;
     // According to RFC3986 (http://www.faqs.org/rfcs/rfc3986.html),
     // section 2.3. - Unreserved Characters
-    if ((c >= '0' && c <= '9') ||
-        (c >= 'A' && c <= 'Z') ||
-        (c >= 'a' && c <= 'z') ||
-        c == '-' || c == '.' || c == '_' || c == '~') {
+    if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') ||
+        (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' ||
+        c == '~') {
       result += c;
     } else if (c == ' ' && encodeSpaceAsPlus) {
       // For historical reasons, some URLs have spaces encoded as '+',
@@ -46,7 +45,8 @@
       // 'application/x-www-form-urlencoded'
       result += '+';
     } else {
-      base::StringAppendF(&result, "%%%02X",
+      base::StringAppendF(&result,
+                          "%%%02X",
                           static_cast<unsigned char>(c));  // Encode as %NN
     }
   }
@@ -60,8 +60,8 @@
     int part1 = 0, part2 = 0;
     // HexToDec would return -1 even for character 0 (end of string),
     // so it is safe to access data[0] and data[1] without overrunning the buf.
-    if (c == '%' &&
-        (part1 = HexToDec(data[0])) >= 0 && (part2 = HexToDec(data[1])) >= 0) {
+    if (c == '%' && (part1 = HexToDec(data[0])) >= 0 &&
+        (part2 = HexToDec(data[1])) >= 0) {
       c = static_cast<char>((part1 << 4) | part2);
       data += 2;
     } else if (c == '+') {
diff --git a/chromeos/data_encoding_unittest.cc b/chromeos/data_encoding_unittest.cc
index a09b09e..b7d6bdd 100644
--- a/chromeos/data_encoding_unittest.cc
+++ b/chromeos/data_encoding_unittest.cc
@@ -12,21 +12,18 @@
 TEST(data_encoding, UrlEncoding) {
   std::string test = "\"http://sample/path/0014.html \"";
   std::string encoded = UrlEncode(test.c_str());
-  EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html+%22",
-            encoded);
+  EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html+%22", encoded);
   EXPECT_EQ(test, UrlDecode(encoded.c_str()));
 
   test = "\"http://sample/path/0014.html \"";
   encoded = UrlEncode(test.c_str(), false);
-  EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html%20%22",
-            encoded);
+  EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html%20%22", encoded);
   EXPECT_EQ(test, UrlDecode(encoded.c_str()));
 }
 
 TEST(data_encoding, WebParamsEncoding) {
-  std::string encoded = WebParamsEncode({{"q", "test"},
-                                         {"path", "/usr/bin"},
-                                         {"#", "%"}});
+  std::string encoded =
+      WebParamsEncode({{"q", "test"}, {"path", "/usr/bin"}, {"#", "%"}});
   EXPECT_EQ("q=test&path=%2Fusr%2Fbin&%23=%25", encoded);
 
   auto params = WebParamsDecode(encoded);
diff --git a/chromeos/dbus/abstract_dbus_service.cc b/chromeos/dbus/abstract_dbus_service.cc
index a59922f..e0040e0 100644
--- a/chromeos/dbus/abstract_dbus_service.cc
+++ b/chromeos/dbus/abstract_dbus_service.cc
@@ -9,7 +9,7 @@
 namespace chromeos {
 namespace dbus {
 
-bool AbstractDbusService::Register(const chromeos::dbus::BusConnection &conn) {
+bool AbstractDbusService::Register(const chromeos::dbus::BusConnection& conn) {
   return RegisterExclusiveService(conn,
                                   service_interface(),
                                   service_name(),
diff --git a/chromeos/dbus/abstract_dbus_service.h b/chromeos/dbus/abstract_dbus_service.h
index 2f4674d..c6ae5c8 100644
--- a/chromeos/dbus/abstract_dbus_service.h
+++ b/chromeos/dbus/abstract_dbus_service.h
@@ -25,7 +25,7 @@
   // Registers the GObject as a service with the system DBus
   // TODO(wad) make this testable by making BusConn and Proxy
   //           subclassing friendly.
-  virtual bool Register(const chromeos::dbus::BusConnection &conn);
+  virtual bool Register(const chromeos::dbus::BusConnection& conn);
 
   // Starts the run loop
   virtual bool Run();
@@ -35,13 +35,13 @@
 
   // Used internally during registration to set the
   // proper service information.
-  virtual const char *service_name() const = 0;
-  virtual const char *service_path() const = 0;
-  virtual const char *service_interface() const = 0;
-  virtual GObject *service_object() const = 0;
+  virtual const char* service_name() const = 0;
+  virtual const char* service_path() const = 0;
+  virtual const char* service_interface() const = 0;
+  virtual GObject* service_object() const = 0;
 
  protected:
-  virtual GMainLoop *main_loop() = 0;
+  virtual GMainLoop* main_loop() = 0;
 };
 
 }  // namespace dbus
diff --git a/chromeos/dbus/async_event_sequencer.cc b/chromeos/dbus/async_event_sequencer.cc
index 1991117..741bd67 100644
--- a/chromeos/dbus/async_event_sequencer.cc
+++ b/chromeos/dbus/async_event_sequencer.cc
@@ -8,24 +8,32 @@
 
 namespace dbus_utils {
 
-AsyncEventSequencer::AsyncEventSequencer() { }
-AsyncEventSequencer::~AsyncEventSequencer() { }
+AsyncEventSequencer::AsyncEventSequencer() {
+}
+AsyncEventSequencer::~AsyncEventSequencer() {
+}
 
 AsyncEventSequencer::Handler AsyncEventSequencer::GetHandler(
-    const std::string& descriptive_message, bool failure_is_fatal) {
+    const std::string& descriptive_message,
+    bool failure_is_fatal) {
   CHECK(!started_) << "Cannot create handlers after OnAllTasksCompletedCall()";
   int unique_registration_id = ++registration_counter_;
   outstanding_registrations_.insert(unique_registration_id);
-  return base::Bind(&AsyncEventSequencer::HandleFinish, this,
-                    unique_registration_id, descriptive_message,
+  return base::Bind(&AsyncEventSequencer::HandleFinish,
+                    this,
+                    unique_registration_id,
+                    descriptive_message,
                     failure_is_fatal);
 }
 
 AsyncEventSequencer::ExportHandler AsyncEventSequencer::GetExportHandler(
-        const std::string& interface_name, const std::string& method_name,
-        const std::string& descriptive_message, bool failure_is_fatal) {
+    const std::string& interface_name,
+    const std::string& method_name,
+    const std::string& descriptive_message,
+    bool failure_is_fatal) {
   auto finish_handler = GetHandler(descriptive_message, failure_is_fatal);
-  return base::Bind(&AsyncEventSequencer::HandleDBusMethodExported, this,
+  return base::Bind(&AsyncEventSequencer::HandleDBusMethodExported,
+                    this,
                     finish_handler,
                     interface_name,
                     method_name);
@@ -42,8 +50,11 @@
 
 namespace {
 void IgnoreSuccess(const AsyncEventSequencer::CompletionTask& task,
-                   bool /*success*/) { task.Run(); }
-void DoNothing(bool success) {}
+                   bool /*success*/) {
+  task.Run();
+}
+void DoNothing(bool success) {
+}
 }  // namespace
 
 AsyncEventSequencer::CompletionAction AsyncEventSequencer::WrapCompletionTask(
@@ -52,13 +63,14 @@
 }
 
 AsyncEventSequencer::CompletionAction
-    AsyncEventSequencer::GetDefaultCompletionAction() {
+AsyncEventSequencer::GetDefaultCompletionAction() {
   return base::Bind(&DoNothing);
 }
 
 void AsyncEventSequencer::HandleFinish(int registration_number,
                                        const std::string& error_message,
-                                       bool failure_is_fatal, bool success) {
+                                       bool failure_is_fatal,
+                                       bool success) {
   RetireRegistration(registration_number);
   CheckForFailure(failure_is_fatal, success, error_message);
   PossiblyRunCompletionActions();
@@ -69,7 +81,8 @@
     const std::string& expected_interface_name,
     const std::string& expected_method_name,
     const std::string& actual_interface_name,
-    const std::string& actual_method_name, bool success) {
+    const std::string& actual_method_name,
+    bool success) {
   CHECK_EQ(expected_method_name, actual_method_name)
       << "Exported DBus method '" << actual_method_name << "' "
       << "but expected '" << expected_method_name << "'";
@@ -79,15 +92,15 @@
   finish_handler.Run(success);
 }
 
-
 void AsyncEventSequencer::RetireRegistration(int registration_number) {
-  const size_t handlers_retired = outstanding_registrations_.erase(
-      registration_number);
-  CHECK_EQ(1U, handlers_retired)
-      << "Tried to retire invalid handler " << registration_number << ")";
+  const size_t handlers_retired =
+      outstanding_registrations_.erase(registration_number);
+  CHECK_EQ(1U, handlers_retired) << "Tried to retire invalid handler "
+                                 << registration_number << ")";
 }
 
-void AsyncEventSequencer::CheckForFailure(bool failure_is_fatal, bool success,
+void AsyncEventSequencer::CheckForFailure(bool failure_is_fatal,
+                                          bool success,
                                           const std::string& error_message) {
   if (failure_is_fatal) {
     CHECK(success) << error_message;
diff --git a/chromeos/dbus/async_event_sequencer.h b/chromeos/dbus/async_event_sequencer.h
index 54bcd69..f555c82 100644
--- a/chromeos/dbus/async_event_sequencer.h
+++ b/chromeos/dbus/async_event_sequencer.h
@@ -39,9 +39,9 @@
     : public base::RefCounted<AsyncEventSequencer> {
  public:
   using Handler = base::Callback<void(bool success)>;
-  using ExportHandler = base::Callback<void (const std::string& interface_name,
-                                             const std::string& method_name,
-                                             bool success)>;
+  using ExportHandler = base::Callback<void(const std::string& interface_name,
+                                            const std::string& method_name,
+                                            bool success)>;
   using CompletionAction = base::Callback<void(bool all_succeeded)>;
   using CompletionTask = base::Callback<void(void)>;
 
@@ -56,9 +56,10 @@
   // Like GetHandler except with a signature tailored to
   // ExportedObject's ExportMethod callback requirements.  Will also assert
   // that the passed interface/method names from ExportedObject are correct.
-  ExportHandler GetExportHandler(
-      const std::string& interface_name, const std::string& method_name,
-      const std::string& descriptive_message, bool failure_is_fatal);
+  ExportHandler GetExportHandler(const std::string& interface_name,
+                                 const std::string& method_name,
+                                 const std::string& descriptive_message,
+                                 bool failure_is_fatal);
 
   // Once all handlers obtained via GetHandler have run,
   // we'll run each CompletionAction, then discard our references.
@@ -78,7 +79,8 @@
   // destroy *this only when all our callbacks have been destroyed.
   CHROMEOS_PRIVATE void HandleFinish(int registration_number,
                                      const std::string& error_message,
-                                     bool failure_is_fatal, bool success);
+                                     bool failure_is_fatal,
+                                     bool success);
   // Similar to HandleFinish.
   CHROMEOS_PRIVATE void HandleDBusMethodExported(
       const Handler& finish_handler,
diff --git a/chromeos/dbus/async_event_sequencer_unittest.cc b/chromeos/dbus/async_event_sequencer_unittest.cc
index 49dcfb4..91e39cc 100644
--- a/chromeos/dbus/async_event_sequencer_unittest.cc
+++ b/chromeos/dbus/async_event_sequencer_unittest.cc
@@ -25,9 +25,9 @@
   MOCK_METHOD1(HandleCompletion, void(bool all_succeeded));
 
   void SetUp() {
-      aec_ = new AsyncEventSequencer();
-      cb_ = base::Bind(&AsyncEventSequencerTest::HandleCompletion,
-                       base::Unretained(this));
+    aec_ = new AsyncEventSequencer();
+    cb_ = base::Bind(&AsyncEventSequencerTest::HandleCompletion,
+                     base::Unretained(this));
   }
 
   scoped_refptr<AsyncEventSequencer> aec_;
@@ -60,9 +60,9 @@
 }
 
 TEST_F(AsyncEventSequencerTest, MultiDBusActionsSucceed) {
-  auto handler1 =  aec_->GetExportHandler(
+  auto handler1 = aec_->GetExportHandler(
       kTestInterface, kTestMethod1, "method export failed", false);
-  auto handler2 =  aec_->GetExportHandler(
+  auto handler2 = aec_->GetExportHandler(
       kTestInterface, kTestMethod2, "method export failed", false);
   aec_->OnAllTasksCompletedCall({cb_});
   handler1.Run(kTestInterface, kTestMethod1, true);
@@ -71,9 +71,9 @@
 }
 
 TEST_F(AsyncEventSequencerTest, SomeDBusActionsFail) {
-  auto handler1 =  aec_->GetExportHandler(
+  auto handler1 = aec_->GetExportHandler(
       kTestInterface, kTestMethod1, "method export failed", false);
-  auto handler2 =  aec_->GetExportHandler(
+  auto handler2 = aec_->GetExportHandler(
       kTestInterface, kTestMethod2, "method export failed", false);
   aec_->OnAllTasksCompletedCall({cb_});
   handler1.Run(kTestInterface, kTestMethod1, true);
@@ -82,7 +82,7 @@
 }
 
 TEST_F(AsyncEventSequencerTest, MixedActions) {
-  auto handler1 =  aec_->GetExportHandler(
+  auto handler1 = aec_->GetExportHandler(
       kTestInterface, kTestMethod1, "method export failed", false);
   auto handler2 = aec_->GetHandler("handler failed", false);
   aec_->OnAllTasksCompletedCall({cb_});
diff --git a/chromeos/dbus/data_serialization.cc b/chromeos/dbus/data_serialization.cc
index b389ce0..b2141aa 100644
--- a/chromeos/dbus/data_serialization.cc
+++ b/chromeos/dbus/data_serialization.cc
@@ -172,8 +172,7 @@
 
 // std::map<KEY, VALUE> overload.
 template<typename KEY, typename VALUE>
-bool PopTypedMapFromReader(dbus::MessageReader* reader,
-                           chromeos::Any* value) {
+bool PopTypedMapFromReader(dbus::MessageReader* reader, chromeos::Any* value) {
   return PopTypedValueFromReader<std::map<KEY, VALUE>>(reader, value);
 }
 
@@ -221,7 +220,7 @@
   // When a use case for particular array signature is found, feel free
   // to add handing for it here.
   LOG(ERROR) << "Variant de-serialization of array containing data of "
-              << "type '" << signature << "' is not yet supported";
+             << "type '" << signature << "' is not yet supported";
   return false;
 }
 
@@ -239,8 +238,8 @@
 
   // When a use case for particular struct signature is found, feel free
   // to add handing for it here.
-  LOG(ERROR) << "Variant de-serialization of structs of type '"
-              << signature << "' is not yet supported";
+  LOG(ERROR) << "Variant de-serialization of structs of type '" << signature
+             << "' is not yet supported";
   return false;
 }
 
diff --git a/chromeos/dbus/data_serialization.h b/chromeos/dbus/data_serialization.h
index 05691f7..dc6b875 100644
--- a/chromeos/dbus/data_serialization.h
+++ b/chromeos/dbus/data_serialization.h
@@ -95,14 +95,17 @@
 // supported.
 template<typename T, typename... Types>
 struct IsTypeSupported<T, Types...>
-    : public std::integral_constant<bool, IsTypeSupported<T>::value &&
-                                          IsTypeSupported<Types...>::value> {};
+    : public std::integral_constant<
+          bool,
+          IsTypeSupported<T>::value && IsTypeSupported<Types...>::value> {};
 
 // For a single type T, check if DBusType<T> derives from Unsupported.
 // If it does, then the type is not supported by the D-Bus.
 template<typename T>
-struct IsTypeSupported<T> : public std::integral_constant<
-    bool, !std::is_base_of<Unsupported, DBusType<T>>::value> {};
+struct IsTypeSupported<T>
+    : public std::integral_constant<
+          bool,
+          !std::is_base_of<Unsupported, DBusType<T>>::value> {};
 
 // Empty set is not supported.
 template<>
@@ -154,9 +157,8 @@
 // into the Variant and updates the |*reader_ref| with the transient
 // |variant_reader| MessageReader instance passed in.
 // Returns false if it fails to descend into the Variant.
-inline bool DescendIntoVariantIfPresent(
-    dbus::MessageReader** reader_ref,
-    dbus::MessageReader* variant_reader) {
+inline bool DescendIntoVariantIfPresent(dbus::MessageReader** reader_ref,
+                                        dbus::MessageReader* variant_reader) {
   if ((*reader_ref)->GetDataType() != dbus::Message::VARIANT)
     return true;
   if (!(*reader_ref)->PopVariant(variant_reader))
@@ -189,10 +191,10 @@
 // DBusType<T> for various C++ types that can be serialized over D-Bus.
 
 // bool -----------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, bool value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, bool* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         bool value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        bool* value);
 
 template<>
 struct DBusType<bool> {
@@ -208,16 +210,14 @@
 };
 
 // uint8_t --------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, uint8_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, uint8_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         uint8_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        uint8_t* value);
 
 template<>
 struct DBusType<uint8_t> {
-  inline static std::string GetSignature() {
-    return DBUS_TYPE_BYTE_AS_STRING;
-  }
+  inline static std::string GetSignature() { return DBUS_TYPE_BYTE_AS_STRING; }
   inline static void Write(dbus::MessageWriter* writer, uint8_t value) {
     AppendValueToWriter(writer, value);
   }
@@ -227,16 +227,14 @@
 };
 
 // int16_t --------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, int16_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, int16_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         int16_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        int16_t* value);
 
 template<>
 struct DBusType<int16_t> {
-  inline static std::string GetSignature() {
-    return DBUS_TYPE_INT16_AS_STRING;
-  }
+  inline static std::string GetSignature() { return DBUS_TYPE_INT16_AS_STRING; }
   inline static void Write(dbus::MessageWriter* writer, int16_t value) {
     AppendValueToWriter(writer, value);
   }
@@ -246,10 +244,10 @@
 };
 
 // uint16_t -------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, uint16_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, uint16_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         uint16_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        uint16_t* value);
 
 template<>
 struct DBusType<uint16_t> {
@@ -265,16 +263,14 @@
 };
 
 // int32_t --------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, int32_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, int32_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         int32_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        int32_t* value);
 
 template<>
 struct DBusType<int32_t> {
-  inline static std::string GetSignature() {
-    return DBUS_TYPE_INT32_AS_STRING;
-  }
+  inline static std::string GetSignature() { return DBUS_TYPE_INT32_AS_STRING; }
   inline static void Write(dbus::MessageWriter* writer, int32_t value) {
     AppendValueToWriter(writer, value);
   }
@@ -284,10 +280,10 @@
 };
 
 // uint32_t -------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, uint32_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, uint32_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         uint32_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        uint32_t* value);
 
 template<>
 struct DBusType<uint32_t> {
@@ -303,16 +299,14 @@
 };
 
 // int64_t --------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, int64_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, int64_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         int64_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        int64_t* value);
 
 template<>
 struct DBusType<int64_t> {
-  inline static std::string GetSignature() {
-    return DBUS_TYPE_INT64_AS_STRING;
-  }
+  inline static std::string GetSignature() { return DBUS_TYPE_INT64_AS_STRING; }
   inline static void Write(dbus::MessageWriter* writer, int64_t value) {
     AppendValueToWriter(writer, value);
   }
@@ -322,10 +316,10 @@
 };
 
 // uint64_t -------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, uint64_t value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, uint64_t* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         uint64_t value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        uint64_t* value);
 
 template<>
 struct DBusType<uint64_t> {
@@ -341,10 +335,10 @@
 };
 
 // double ---------------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, double value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, double* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         double value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        double* value);
 
 template<>
 struct DBusType<double> {
@@ -360,10 +354,10 @@
 };
 
 // std::string ----------------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, const std::string& value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, std::string* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         const std::string& value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        std::string* value);
 
 template<>
 struct DBusType<std::string> {
@@ -380,8 +374,8 @@
 };
 
 // const char*
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, const char* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         const char* value);
 
 template<>
 struct DBusType<const char*> {
@@ -405,10 +399,10 @@
 };
 
 // dbus::ObjectPath -----------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, const dbus::ObjectPath& value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, dbus::ObjectPath* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         const dbus::ObjectPath& value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        dbus::ObjectPath* value);
 
 template<>
 struct DBusType<dbus::ObjectPath> {
@@ -426,10 +420,10 @@
 };
 
 // dbus::FileDescriptor -------------------------------------------------------
-CHROMEOS_EXPORT void AppendValueToWriter(
-    dbus::MessageWriter* writer, const dbus::FileDescriptor& value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, dbus::FileDescriptor* value);
+CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
+                                         const dbus::FileDescriptor& value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        dbus::FileDescriptor* value);
 
 template<>
 struct DBusType<dbus::FileDescriptor> {
@@ -449,8 +443,8 @@
 // chromeos::Any --------------------------------------------------------------
 CHROMEOS_EXPORT void AppendValueToWriter(dbus::MessageWriter* writer,
                                          const chromeos::Any& value);
-CHROMEOS_EXPORT bool PopValueFromReader(
-    dbus::MessageReader* reader, chromeos::Any* value);
+CHROMEOS_EXPORT bool PopValueFromReader(dbus::MessageReader* reader,
+                                        chromeos::Any* value);
 
 template<>
 struct DBusType<chromeos::Any> {
@@ -468,9 +462,9 @@
 
 // std::vector = D-Bus ARRAY. -------------------------------------------------
 template<typename T, typename ALLOC>
-typename std::enable_if<IsTypeSupported<T>::value>::type
-AppendValueToWriter(dbus::MessageWriter* writer,
-                    const std::vector<T, ALLOC>& value) {
+typename std::enable_if<IsTypeSupported<T>::value>::type AppendValueToWriter(
+    dbus::MessageWriter* writer,
+    const std::vector<T, ALLOC>& value) {
   dbus::MessageWriter array_writer(nullptr);
   writer->OpenArray(GetDBusSignature<T>(), &array_writer);
   for (const auto& element : value) {
@@ -552,9 +546,7 @@
 
 template<>
 struct TupleTraits<> {
-  static std::string GetSignature() {
-    return std::string{};
-  }
+  static std::string GetSignature() { return std::string{}; }
 };
 
 }  // namespace details
@@ -562,14 +554,15 @@
 template<typename... Types>
 inline std::string GetStructDBusSignature() {
   // Returns "(T...)", where "T..." is the signature strings for types T...
-    return DBUS_STRUCT_BEGIN_CHAR_AS_STRING +
-           details::TupleTraits<Types...>::GetSignature() +
-           DBUS_STRUCT_END_CHAR_AS_STRING;
+  return DBUS_STRUCT_BEGIN_CHAR_AS_STRING +
+         details::TupleTraits<Types...>::GetSignature() +
+         DBUS_STRUCT_END_CHAR_AS_STRING;
 }
 
 template<typename U, typename V>
-typename std::enable_if<IsTypeSupported<U, V>::value>::type
-AppendValueToWriter(dbus::MessageWriter* writer, const std::pair<U, V>& value) {
+typename std::enable_if<IsTypeSupported<U, V>::value>::type AppendValueToWriter(
+    dbus::MessageWriter* writer,
+    const std::pair<U, V>& value) {
   dbus::MessageWriter struct_writer(nullptr);
   writer->OpenStruct(&struct_writer);
   // Use DBusType<T>::Write() instead of AppendValueToWriter() to delay
@@ -623,8 +616,7 @@
 
 template<typename U, typename V>
 struct DBusType<std::pair<U, V>>
-    : public details::DBusPairType<IsTypeSupported<U, V>::value, U, V> {
-};
+    : public details::DBusPairType<IsTypeSupported<U, V>::value, U, V> {};
 
 // std::tuple = D-Bus STRUCT with arbitrary number of members. ----------------
 namespace details {
@@ -664,17 +656,15 @@
 struct TupleIterator<N, N, T...> {
   using Tuple = std::tuple<T...>;
   static void Write(dbus::MessageWriter* writer, const Tuple& value) {}
-  static bool Read(dbus::MessageReader* reader, Tuple* value) {
-    return true;
-  }
+  static bool Read(dbus::MessageReader* reader, Tuple* value) { return true; }
 };
 
 }  // namespace details
 
 template<typename... T>
-typename std::enable_if<IsTypeSupported<T...>::value>::type
-AppendValueToWriter(dbus::MessageWriter* writer,
-                    const std::tuple<T...>& value) {
+typename std::enable_if<IsTypeSupported<T...>::value>::type AppendValueToWriter(
+    dbus::MessageWriter* writer,
+    const std::tuple<T...>& value) {
   dbus::MessageWriter struct_writer(nullptr);
   writer->OpenStruct(&struct_writer);
   details::TupleIterator<0, sizeof...(T), T...>::Write(&struct_writer, value);
@@ -727,9 +717,8 @@
 // std::map = D-Bus ARRAY of DICT_ENTRY. --------------------------------------
 template<typename KEY, typename VALUE, typename PRED, typename ALLOC>
 typename std::enable_if<IsTypeSupported<KEY, VALUE>::value>::type
-AppendValueToWriter(
-    dbus::MessageWriter* writer,
-    const std::map<KEY, VALUE, PRED, ALLOC>& value) {
+AppendValueToWriter(dbus::MessageWriter* writer,
+                    const std::map<KEY, VALUE, PRED, ALLOC>& value) {
   dbus::MessageWriter dict_writer(nullptr);
   writer->OpenArray(details::GetDBusDictEntryType<KEY, VALUE>(), &dict_writer);
   for (const auto& pair : value) {
@@ -778,7 +767,10 @@
 // GetSignature/Write/Read methods for T types that are supported by D-Bus
 // and not having those methods for types that are not supported by D-Bus.
 template<bool inner_types_supported,
-         typename KEY, typename VALUE, typename PRED, typename ALLOC>
+         typename KEY,
+         typename VALUE,
+         typename PRED,
+         typename ALLOC>
 struct DBusMapType {
   // Returns "a{KV}", where "K" and "V" are the signature strings for types
   // KEY/VALUE.
@@ -804,7 +796,10 @@
 template<typename KEY, typename VALUE, typename PRED, typename ALLOC>
 struct DBusType<std::map<KEY, VALUE, PRED, ALLOC>>
     : public details::DBusMapType<IsTypeSupported<KEY, VALUE>::value,
-                                  KEY, VALUE, PRED, ALLOC> {};
+                                  KEY,
+                                  VALUE,
+                                  PRED,
+                                  ALLOC> {};
 
 // google::protobuf::MessageLite = D-Bus ARRAY of BYTE ------------------------
 inline void AppendValueToWriter(dbus::MessageWriter* writer,
diff --git a/chromeos/dbus/data_serialization_unittest.cc b/chromeos/dbus/data_serialization_unittest.cc
index 8326184..547d8a1 100644
--- a/chromeos/dbus/data_serialization_unittest.cc
+++ b/chromeos/dbus/data_serialization_unittest.cc
@@ -44,8 +44,8 @@
   EXPECT_TRUE(IsTypeSupported<std::vector<bool>>::value);
   EXPECT_TRUE(IsTypeSupported<std::vector<uint8_t>>::value);
   EXPECT_TRUE((IsTypeSupported<std::pair<int16_t, double>>::value));
-  EXPECT_TRUE((IsTypeSupported<std::map<uint16_t,
-                                        std::vector<int64_t>>>::value));
+  EXPECT_TRUE(
+      (IsTypeSupported<std::map<uint16_t, std::vector<int64_t>>>::value));
   EXPECT_TRUE((IsTypeSupported<std::tuple<bool, double, int32_t>>::value));
 }
 
@@ -111,7 +111,8 @@
   EXPECT_EQ("a{ss}", (GetDBusSignature<std::map<std::string, std::string>>()));
   EXPECT_EQ("a{sv}", (GetDBusSignature<std::map<std::string, Any>>()));
   EXPECT_EQ("a{id}", (GetDBusSignature<std::map<int, double>>()));
-  EXPECT_EQ("a{ia{ss}}",
+  EXPECT_EQ(
+      "a{ia{ss}}",
       (GetDBusSignature<std::map<int, std::map<std::string, std::string>>>()));
 }
 
@@ -125,8 +126,8 @@
   EXPECT_EQ("(i)", (GetDBusSignature<std::tuple<int>>()));
   EXPECT_EQ("(sv)", (GetDBusSignature<std::tuple<std::string, Any>>()));
   EXPECT_EQ("(id(si))",
-            (GetDBusSignature<std::tuple<int, double,
-                                         std::tuple<std::string, int>>>()));
+            (GetDBusSignature<
+                std::tuple<int, double, std::tuple<std::string, int>>>()));
 }
 
 // Test that a byte can be properly written and read. We only have this
@@ -147,7 +148,7 @@
 
   uint8_t byte_value = 0;
   EXPECT_TRUE(PopValueFromReader(&reader, &byte_value));
-  EXPECT_EQ(123, byte_value);  // Should match with the input.
+  EXPECT_EQ(123, byte_value);          // Should match with the input.
   EXPECT_FALSE(reader.HasMoreData());  // Should not have more data to read.
 
   // Try to get another byte. Should fail.
@@ -437,9 +438,9 @@
   std::unique_ptr<Response> message(Response::CreateEmpty().release());
   MessageWriter writer(message.get());
   std::vector<ObjectPath> object_paths{
-    ObjectPath("/object/path/1"),
-    ObjectPath("/object/path/2"),
-    ObjectPath("/object/path/3"),
+      ObjectPath("/object/path/1"),
+      ObjectPath("/object/path/2"),
+      ObjectPath("/object/path/3"),
   };
   AppendValueToWriter(&writer, object_paths);
 
@@ -517,24 +518,15 @@
   EXPECT_TRUE(PopValueFromReader(&reader, &values_out));
   EXPECT_FALSE(reader.HasMoreData());
   EXPECT_EQ(values.size(), values_out.size());
-  EXPECT_EQ(values["key1"].Get<uint8_t>(),
-            values_out["key1"].Get<uint8_t>());
-  EXPECT_EQ(values["key2"].Get<bool>(),
-            values_out["key2"].Get<bool>());
-  EXPECT_EQ(values["key3"].Get<int16_t>(),
-            values_out["key3"].Get<int16_t>());
-  EXPECT_EQ(values["key4"].Get<uint16_t>(),
-            values_out["key4"].Get<uint16_t>());
-  EXPECT_EQ(values["key5"].Get<int32_t>(),
-            values_out["key5"].Get<int32_t>());
-  EXPECT_EQ(values["key6"].Get<uint32_t>(),
-            values_out["key6"].Get<uint32_t>());
-  EXPECT_EQ(values["key7"].Get<int64_t>(),
-            values_out["key7"].Get<int64_t>());
-  EXPECT_EQ(values["key8"].Get<uint64_t>(),
-            values_out["key8"].Get<uint64_t>());
-  EXPECT_EQ(values["key9"].Get<double>(),
-            values_out["key9"].Get<double>());
+  EXPECT_EQ(values["key1"].Get<uint8_t>(), values_out["key1"].Get<uint8_t>());
+  EXPECT_EQ(values["key2"].Get<bool>(), values_out["key2"].Get<bool>());
+  EXPECT_EQ(values["key3"].Get<int16_t>(), values_out["key3"].Get<int16_t>());
+  EXPECT_EQ(values["key4"].Get<uint16_t>(), values_out["key4"].Get<uint16_t>());
+  EXPECT_EQ(values["key5"].Get<int32_t>(), values_out["key5"].Get<int32_t>());
+  EXPECT_EQ(values["key6"].Get<uint32_t>(), values_out["key6"].Get<uint32_t>());
+  EXPECT_EQ(values["key7"].Get<int64_t>(), values_out["key7"].Get<int64_t>());
+  EXPECT_EQ(values["key8"].Get<uint64_t>(), values_out["key8"].Get<uint64_t>());
+  EXPECT_EQ(values["key9"].Get<double>(), values_out["key9"].Get<double>());
   EXPECT_EQ(values["keyA"].Get<std::string>(),
             values_out["keyA"].Get<std::string>());
   EXPECT_EQ(values["keyB"].Get<ObjectPath>(),
@@ -649,8 +641,7 @@
   int age;
   // Provide == operator so we can easily compare arrays of Person.
   bool operator==(const Person& rhs) const {
-    return first_name == rhs.first_name &&
-           last_name == rhs.last_name &&
+    return first_name == rhs.first_name && last_name == rhs.last_name &&
            age == rhs.age;
   }
 };
@@ -730,7 +721,7 @@
 
   EXPECT_EQ("aa{i(ssi)}", message->GetSignature());
 
-  std::vector<std::map<int, Person>> data_out;;
+  std::vector<std::map<int, Person>> data_out;
 
   MessageReader reader(message.get());
   EXPECT_TRUE(PopValueFromReader(&reader, &data_out));
diff --git a/chromeos/dbus/dbus.h b/chromeos/dbus/dbus.h
index 177a6b8..abde7dd 100644
--- a/chromeos/dbus/dbus.h
+++ b/chromeos/dbus/dbus.h
@@ -37,8 +37,7 @@
  public:
   typedef ::DBusGConnection* value_type;
 
-  BusConnection(const BusConnection& x)
-      : object_(x.object_) {
+  BusConnection(const BusConnection& x) : object_(x.object_) {
     if (object_)
       ::dbus_g_connection_ref(object_);
   }
@@ -58,13 +57,9 @@
     return object_;
   }
 
-  operator bool() const {
-    return object_;
-  }
+  operator bool() const { return object_; }
 
-  bool HasConnection() const {
-    return object_;
-  }
+  bool HasConnection() const { return object_; }
 
  private:
   friend void swap(BusConnection& x, BusConnection& y);
@@ -74,9 +69,7 @@
   friend BusConnection GetPrivateBusConnection(const char* address);
 
   // Constructor takes ownership
-  CHROMEOS_PRIVATE explicit BusConnection(::DBusGConnection* x)
-      : object_(x) {
-  }
+  CHROMEOS_PRIVATE explicit BusConnection(::DBusGConnection* x) : object_(x) {}
 
   value_type object_;
 };
@@ -139,17 +132,14 @@
     return object_;
   }
 
-  operator bool() const {
-    return object_;
-  }
+  operator bool() const { return object_; }
 
  private:
-  CHROMEOS_PRIVATE static value_type GetGProxy(
-    const BusConnection& connection,
-    const char* name,
-    const char* path,
-    const char* interface,
-    bool connect_to_name_owner);
+  CHROMEOS_PRIVATE static value_type GetGProxy(const BusConnection& connection,
+                                               const char* name,
+                                               const char* path,
+                                               const char* interface,
+                                               bool connect_to_name_owner);
 
   CHROMEOS_PRIVATE static value_type GetGPeerProxy(
       const BusConnection& connection,
@@ -183,26 +173,23 @@
                                               const char* service_path,
                                               GObject* object);
 
-template <typename F>  // F is a function signature
+template<typename F>  // F is a function signature
 class MonitorConnection;
 
-template <typename A1>
+template<typename A1>
 class MonitorConnection<void(A1)> {
  public:
-  MonitorConnection(const Proxy& proxy, const char* name,
-                    void (*monitor)(void*, A1), void* object)
-      : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {
-  }
+  MonitorConnection(const Proxy& proxy,
+                    const char* name,
+                    void (*monitor)(void*, A1),
+                    void* object)
+      : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {}
 
   static void Run(::DBusGProxy*, A1 x, MonitorConnection* self) {
     self->monitor_(self->object_, x);
   }
-  const Proxy& proxy() const {
-    return proxy_;
-  }
-  const std::string& name() const {
-    return name_;
-  }
+  const Proxy& proxy() const { return proxy_; }
+  const std::string& name() const { return name_; }
 
  private:
   Proxy proxy_;
@@ -211,23 +198,20 @@
   void* object_;
 };
 
-template <typename A1, typename A2>
+template<typename A1, typename A2>
 class MonitorConnection<void(A1, A2)> {
  public:
-  MonitorConnection(const Proxy& proxy, const char* name,
-                    void (*monitor)(void*, A1, A2), void* object)
-      : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {
-  }
+  MonitorConnection(const Proxy& proxy,
+                    const char* name,
+                    void (*monitor)(void*, A1, A2),
+                    void* object)
+      : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {}
 
   static void Run(::DBusGProxy*, A1 x, A2 y, MonitorConnection* self) {
     self->monitor_(self->object_, x, y);
   }
-  const Proxy& proxy() const {
-    return proxy_;
-  }
-  const std::string& name() const {
-    return name_;
-  }
+  const Proxy& proxy() const { return proxy_; }
+  const std::string& name() const { return name_; }
 
  private:
   Proxy proxy_;
@@ -236,23 +220,20 @@
   void* object_;
 };
 
-template <typename A1, typename A2, typename A3>
+template<typename A1, typename A2, typename A3>
 class MonitorConnection<void(A1, A2, A3)> {
  public:
-  MonitorConnection(const Proxy& proxy, const char* name,
-                    void (*monitor)(void*, A1, A2, A3), void* object)
-      : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {
-  }
+  MonitorConnection(const Proxy& proxy,
+                    const char* name,
+                    void (*monitor)(void*, A1, A2, A3),
+                    void* object)
+      : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {}
 
   static void Run(::DBusGProxy*, A1 x, A2 y, A3 z, MonitorConnection* self) {
     self->monitor_(self->object_, x, y, z);
   }
-  const Proxy& proxy() const {
-    return proxy_;
-  }
-  const std::string& name() const {
-    return name_;
-  }
+  const Proxy& proxy() const { return proxy_; }
+  const std::string& name() const { return name_; }
 
  private:
   Proxy proxy_;
@@ -261,24 +242,25 @@
   void* object_;
 };
 
-template <typename A1, typename A2, typename A3, typename A4>
+template<typename A1, typename A2, typename A3, typename A4>
 class MonitorConnection<void(A1, A2, A3, A4)> {
  public:
-  MonitorConnection(const Proxy& proxy, const char* name,
-                    void (*monitor)(void*, A1, A2, A3, A4), void* object)
-      : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {
-  }
+  MonitorConnection(const Proxy& proxy,
+                    const char* name,
+                    void (*monitor)(void*, A1, A2, A3, A4),
+                    void* object)
+      : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {}
 
-  static void Run(::DBusGProxy*, A1 x, A2 y, A3 z, A4 w,
+  static void Run(::DBusGProxy*,
+                  A1 x,
+                  A2 y,
+                  A3 z,
+                  A4 w,
                   MonitorConnection* self) {
     self->monitor_(self->object_, x, y, z, w);
   }
-  const Proxy& proxy() const {
-    return proxy_;
-  }
-  const std::string& name() const {
-    return name_;
-  }
+  const Proxy& proxy() const { return proxy_; }
+  const std::string& name() const { return name_; }
 
  private:
   Proxy proxy_;
@@ -287,82 +269,84 @@
   void* object_;
 };
 
-template <typename A1>
-MonitorConnection<void(A1)>* Monitor(const Proxy& proxy, const char* name,
+template<typename A1>
+MonitorConnection<void(A1)>* Monitor(const Proxy& proxy,
+                                     const char* name,
                                      void (*monitor)(void*, A1),
                                      void* object) {
-  typedef MonitorConnection<void (A1)> ConnectionType;
+  typedef MonitorConnection<void(A1)> ConnectionType;
 
   ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
 
-  ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
-                            glib::type_to_gtypeid<A1>(), G_TYPE_INVALID);
-  ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
-                                G_CALLBACK(&ConnectionType::Run),
-                                result, nullptr);
+  ::dbus_g_proxy_add_signal(
+      proxy.gproxy(), name, glib::type_to_gtypeid<A1>(), G_TYPE_INVALID);
+  ::dbus_g_proxy_connect_signal(
+      proxy.gproxy(), name, G_CALLBACK(&ConnectionType::Run), result, nullptr);
   return result;
 }
 
-template <typename A1, typename A2>
-MonitorConnection<void(A1, A2)>* Monitor(const Proxy& proxy, const char* name,
+template<typename A1, typename A2>
+MonitorConnection<void(A1, A2)>* Monitor(const Proxy& proxy,
+                                         const char* name,
                                          void (*monitor)(void*, A1, A2),
                                          void* object) {
-  typedef MonitorConnection<void (A1, A2)> ConnectionType;
+  typedef MonitorConnection<void(A1, A2)> ConnectionType;
 
   ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
 
-  ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
+  ::dbus_g_proxy_add_signal(proxy.gproxy(),
+                            name,
                             glib::type_to_gtypeid<A1>(),
                             glib::type_to_gtypeid<A2>(),
                             G_TYPE_INVALID);
-  ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
-                                G_CALLBACK(&ConnectionType::Run),
-                                result, nullptr);
+  ::dbus_g_proxy_connect_signal(
+      proxy.gproxy(), name, G_CALLBACK(&ConnectionType::Run), result, nullptr);
   return result;
 }
 
-template <typename A1, typename A2, typename A3>
+template<typename A1, typename A2, typename A3>
 MonitorConnection<void(A1, A2, A3)>* Monitor(const Proxy& proxy,
-                                          const char* name,
-                                          void (*monitor)(void*, A1, A2, A3),
-                                          void* object) {
-  typedef MonitorConnection<void (A1, A2, A3)> ConnectionType;
+                                             const char* name,
+                                             void (*monitor)(void*, A1, A2, A3),
+                                             void* object) {
+  typedef MonitorConnection<void(A1, A2, A3)> ConnectionType;
 
   ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
 
-  ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
+  ::dbus_g_proxy_add_signal(proxy.gproxy(),
+                            name,
                             glib::type_to_gtypeid<A1>(),
                             glib::type_to_gtypeid<A2>(),
                             glib::type_to_gtypeid<A3>(),
                             G_TYPE_INVALID);
-  ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
-                                G_CALLBACK(&ConnectionType::Run),
-                                result, nullptr);
+  ::dbus_g_proxy_connect_signal(
+      proxy.gproxy(), name, G_CALLBACK(&ConnectionType::Run), result, nullptr);
   return result;
 }
 
-template <typename A1, typename A2, typename A3, typename A4>
-MonitorConnection<void(A1, A2, A3, A4)>* Monitor(const Proxy& proxy,
+template<typename A1, typename A2, typename A3, typename A4>
+MonitorConnection<void(A1, A2, A3, A4)>* Monitor(
+    const Proxy& proxy,
     const char* name,
     void (*monitor)(void*, A1, A2, A3, A4),
     void* object) {
-  typedef MonitorConnection<void (A1, A2, A3, A4)> ConnectionType;
+  typedef MonitorConnection<void(A1, A2, A3, A4)> ConnectionType;
 
   ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
 
-  ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
+  ::dbus_g_proxy_add_signal(proxy.gproxy(),
+                            name,
                             glib::type_to_gtypeid<A1>(),
                             glib::type_to_gtypeid<A2>(),
                             glib::type_to_gtypeid<A3>(),
                             glib::type_to_gtypeid<A4>(),
                             G_TYPE_INVALID);
-  ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
-                                G_CALLBACK(&ConnectionType::Run),
-                                result, nullptr);
+  ::dbus_g_proxy_connect_signal(
+      proxy.gproxy(), name, G_CALLBACK(&ConnectionType::Run), result, nullptr);
   return result;
 }
 
-template <typename F>
+template<typename F>
 void Disconnect(MonitorConnection<F>* connection) {
   typedef MonitorConnection<F> ConnectionType;
 
@@ -407,7 +391,7 @@
 //   std::cout << "Battery charge is " << x << "% of capacity.";
 // \end_example
 
-template <typename T>
+template<typename T>
 inline bool RetrieveProperty(const Proxy& proxy,
                              const char* interface,
                              const char* property,
diff --git a/chromeos/dbus/dbus_method_invoker.h b/chromeos/dbus/dbus_method_invoker.h
index c3d45ab..450f353 100644
--- a/chromeos/dbus/dbus_method_invoker.h
+++ b/chromeos/dbus/dbus_method_invoker.h
@@ -106,10 +106,15 @@
       &method_call, timeout_ms, &dbus_error);
   if (!response) {
     if (dbus_error.is_set()) {
-      Error::AddTo(error, FROM_HERE, errors::dbus::kDomain,
-                   dbus_error.name(), dbus_error.message());
+      Error::AddTo(error,
+                   FROM_HERE,
+                   errors::dbus::kDomain,
+                   dbus_error.name(),
+                   dbus_error.message());
     } else {
-      Error::AddToPrintf(error, FROM_HERE, errors::dbus::kDomain,
+      Error::AddToPrintf(error,
+                         FROM_HERE,
+                         errors::dbus::kDomain,
                          DBUS_ERROR_FAILED,
                          "Failed to call D-Bus method: %s.%s",
                          interface_name.c_str(),
@@ -146,8 +151,8 @@
   auto callback = [val_tuple](const ResultTypes&... params) {
     *val_tuple = std::tie(params...);
   };
-  return DBusParamReader<false, ResultTypes...>::Invoke(callback, reader,
-                                                        error);
+  return DBusParamReader<false, ResultTypes...>::Invoke(
+      callback, reader, error);
 }
 // Overload of ExtractMessageParametersAsTuple to handle reference types in
 // tuples created with std::tie().
@@ -159,8 +164,8 @@
   auto callback = [ref_tuple](const ResultTypes&... params) {
     *ref_tuple = std::tie(params...);
   };
-  return DBusParamReader<false, ResultTypes...>::Invoke(callback, reader,
-                                                        error);
+  return DBusParamReader<false, ResultTypes...>::Invoke(
+      callback, reader, error);
 }
 
 // A helper method to extract a list of values from a message buffer.
@@ -181,8 +186,8 @@
                                      ErrorPtr* error,
                                      ResultTypes*... results) {
   auto ref_tuple = std::tie(*results...);
-  return ExtractMessageParametersAsTuple<ResultTypes...>(reader, error,
-                                                         &ref_tuple);
+  return ExtractMessageParametersAsTuple<ResultTypes...>(
+      reader, error, &ref_tuple);
 }
 
 // Convenient helper method to extract return value(s) of a D-Bus method call.
@@ -267,9 +272,8 @@
 
   dbus::ObjectProxy::ErrorCallback dbus_error_callback =
       base::Bind(&TranslateErrorResponse, error_callback);
-  dbus::ObjectProxy::ResponseCallback dbus_success_callback =
-      base::Bind(&TranslateSuccessResponse<OutArgs...>,
-                 success_callback, error_callback);
+  dbus::ObjectProxy::ResponseCallback dbus_success_callback = base::Bind(
+      &TranslateSuccessResponse<OutArgs...>, success_callback, error_callback);
 
   object->CallMethodWithErrorCallback(
       &method_call, timeout_ms, dbus_success_callback, dbus_error_callback);
@@ -277,13 +281,12 @@
 
 // Same as CallMethodWithTimeout() but uses a default timeout value.
 template<typename... InArgs, typename... OutArgs>
-inline void CallMethod(
-    dbus::ObjectProxy* object,
-    const std::string& interface_name,
-    const std::string& method_name,
-    const base::Callback<void(OutArgs...)>& success_callback,
-    const AsyncErrorCallback& error_callback,
-    const InArgs&... params) {
+inline void CallMethod(dbus::ObjectProxy* object,
+                       const std::string& interface_name,
+                       const std::string& method_name,
+                       const base::Callback<void(OutArgs...)>& success_callback,
+                       const AsyncErrorCallback& error_callback,
+                       const InArgs&... params) {
   return CallMethodWithTimeout(dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                                object,
                                interface_name,
diff --git a/chromeos/dbus/dbus_method_invoker_unittest.cc b/chromeos/dbus/dbus_method_invoker_unittest.cc
index 7b7d373..70539bf 100644
--- a/chromeos/dbus/dbus_method_invoker_unittest.cc
+++ b/chromeos/dbus/dbus_method_invoker_unittest.cc
@@ -32,7 +32,7 @@
 const char kTestMethod1[] = "TestMethod1";
 const char kTestMethod2[] = "TestMethod2";
 
-class DBusMethodInvokerTest: public testing::Test {
+class DBusMethodInvokerTest : public testing::Test {
  public:
   void SetUp() override {
     dbus::Bus::Options options;
@@ -44,8 +44,8 @@
     // Use a mock exported object.
     mock_object_proxy_ = new dbus::MockObjectProxy(
         bus_.get(), kTestServiceName, dbus::ObjectPath(kTestPath));
-    EXPECT_CALL(*bus_, GetObjectProxy(kTestServiceName,
-                                      dbus::ObjectPath(kTestPath)))
+    EXPECT_CALL(*bus_,
+                GetObjectProxy(kTestServiceName, dbus::ObjectPath(kTestPath)))
         .WillRepeatedly(Return(mock_object_proxy_.get()));
     int def_timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT;
     EXPECT_CALL(*mock_object_proxy_,
@@ -53,9 +53,7 @@
         .WillRepeatedly(Invoke(this, &DBusMethodInvokerTest::CreateResponse));
   }
 
-  void TearDown() override {
-    bus_ = nullptr;
-  }
+  void TearDown() override { bus_ = nullptr; }
 
   Response* CreateResponse(dbus::MethodCall* method_call,
                            int timeout_ms,
@@ -110,10 +108,8 @@
 TEST_F(DBusMethodInvokerTest, TestFailure) {
   chromeos::ErrorPtr error;
   std::unique_ptr<dbus::Response> response =
-      chromeos::dbus_utils::CallMethodAndBlock(mock_object_proxy_.get(),
-                                               kTestInterface,
-                                               kTestMethod2,
-                                               &error);
+      chromeos::dbus_utils::CallMethodAndBlock(
+          mock_object_proxy_.get(), kTestInterface, kTestMethod2, &error);
   EXPECT_EQ(nullptr, response.get());
   EXPECT_EQ(chromeos::errors::dbus::kDomain, error->GetDomain());
   EXPECT_EQ("org.MyError", error->GetCode());
@@ -123,7 +119,7 @@
 //////////////////////////////////////////////////////////////////////////////
 // Asynchronous method invocation support
 
-class AsyncDBusMethodInvokerTest: public testing::Test {
+class AsyncDBusMethodInvokerTest : public testing::Test {
  public:
   void SetUp() override {
     dbus::Bus::Options options;
@@ -135,19 +131,16 @@
     // Use a mock exported object.
     mock_object_proxy_ = new dbus::MockObjectProxy(
         bus_.get(), kTestServiceName, dbus::ObjectPath(kTestPath));
-    EXPECT_CALL(*bus_, GetObjectProxy(kTestServiceName,
-                                      dbus::ObjectPath(kTestPath)))
+    EXPECT_CALL(*bus_,
+                GetObjectProxy(kTestServiceName, dbus::ObjectPath(kTestPath)))
         .WillRepeatedly(Return(mock_object_proxy_.get()));
     int def_timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT;
     EXPECT_CALL(*mock_object_proxy_,
                 CallMethodWithErrorCallback(_, def_timeout_ms, _, _))
-        .WillRepeatedly(Invoke(this,
-                               &AsyncDBusMethodInvokerTest::HandleCall));
+        .WillRepeatedly(Invoke(this, &AsyncDBusMethodInvokerTest::HandleCall));
   }
 
-  void TearDown() override {
-    bus_ = nullptr;
-  }
+  void TearDown() override { bus_ = nullptr; }
 
   void HandleCall(dbus::MethodCall* method_call,
                   int timeout_ms,
@@ -179,8 +172,8 @@
   }
 
   struct SuccessCallback {
-    SuccessCallback(const std::string& in_result,
-                    int* in_counter) : result(in_result), counter(in_counter) {}
+    SuccessCallback(const std::string& in_result, int* in_counter)
+        : result(in_result), counter(in_counter) {}
 
     explicit SuccessCallback(int* in_counter) : counter(in_counter) {}
 
diff --git a/chromeos/dbus/dbus_method_response.cc b/chromeos/dbus/dbus_method_response.cc
index 6fac1d6..e376a0a 100644
--- a/chromeos/dbus/dbus_method_response.cc
+++ b/chromeos/dbus/dbus_method_response.cc
@@ -11,8 +11,7 @@
 
 DBusMethodResponseBase::DBusMethodResponseBase(dbus::MethodCall* method_call,
                                                ResponseSender sender)
-    : sender_(sender),
-      method_call_(method_call) {
+    : sender_(sender), method_call_(method_call) {
 }
 
 DBusMethodResponseBase::~DBusMethodResponseBase() {
diff --git a/chromeos/dbus/dbus_object.cc b/chromeos/dbus/dbus_object.cc
index db16c7e..4e8cdc2 100644
--- a/chromeos/dbus/dbus_object.cc
+++ b/chromeos/dbus/dbus_object.cc
@@ -20,14 +20,13 @@
 
 DBusInterface::DBusInterface(DBusObject* dbus_object,
                              const std::string& interface_name)
-    : dbus_object_(dbus_object),
-      interface_name_(interface_name) {}
+    : dbus_object_(dbus_object), interface_name_(interface_name) {
+}
 
 void DBusInterface::AddProperty(const std::string& property_name,
                                 ExportedPropertyBase* prop_base) {
-  dbus_object_->property_set_.RegisterProperty(interface_name_,
-                                               property_name,
-                                               prop_base);
+  dbus_object_->property_set_.RegisterProperty(
+      interface_name_, property_name, prop_base);
 }
 
 void DBusInterface::ExportAsync(
@@ -45,8 +44,8 @@
     std::string export_error = "Failed exporting " + method_name + " method";
     auto export_handler = sequencer->GetExportHandler(
         interface_name_, method_name, export_error, true);
-    auto method_handler = base::Bind(&DBusInterface::HandleMethodCall,
-                                     base::Unretained(this));
+    auto method_handler =
+        base::Bind(&DBusInterface::HandleMethodCall, base::Unretained(this));
     exported_object->ExportMethod(
         interface_name_, method_name, method_handler, export_handler);
   }
@@ -66,22 +65,20 @@
   sequencer->OnAllTasksCompletedCall(actions);
 }
 
-void DBusInterface::HandleMethodCall(
-    dbus::MethodCall* method_call,
-    ResponseSender sender) {
+void DBusInterface::HandleMethodCall(dbus::MethodCall* method_call,
+                                     ResponseSender sender) {
   std::string method_name = method_call->GetMember();
   // Make a local copy of |interface_name_| because calling HandleMethod()
   // can potentially kill this interface object...
   std::string interface_name = interface_name_;
-  VLOG(1) << "Received method call request: "
-          << interface_name << "." << method_name
-          << "(" << method_call->GetSignature() << ")";
+  VLOG(1) << "Received method call request: " << interface_name << "."
+          << method_name << "(" << method_call->GetSignature() << ")";
   auto pair = handlers_.find(method_name);
   if (pair == handlers_.end()) {
-    auto response = dbus::ErrorResponse::FromMethodCall(
-        method_call,
-        DBUS_ERROR_UNKNOWN_METHOD,
-        "Unknown method: " + method_name);
+    auto response =
+        dbus::ErrorResponse::FromMethodCall(method_call,
+                                            DBUS_ERROR_UNKNOWN_METHOD,
+                                            "Unknown method: " + method_name);
     sender.Run(response.Pass());
     return;
   }
@@ -92,8 +89,8 @@
 void DBusInterface::AddHandlerImpl(
     const std::string& method_name,
     std::unique_ptr<DBusInterfaceMethodHandlerInterface> handler) {
-  VLOG(1) << "Declaring method handler: "
-          << interface_name_ << "." << method_name;
+  VLOG(1) << "Declaring method handler: " << interface_name_ << "."
+          << method_name;
   auto res = handlers_.insert(std::make_pair(method_name, std::move(handler)));
   CHECK(res.second) << "Method '" << method_name << "' already exists";
 }
@@ -101,21 +98,18 @@
 void DBusInterface::AddSignalImpl(
     const std::string& signal_name,
     const std::shared_ptr<DBusSignalBase>& signal) {
-  VLOG(1) << "Declaring a signal sink: "
-          << interface_name_ << "." << signal_name;
+  VLOG(1) << "Declaring a signal sink: " << interface_name_ << "."
+          << signal_name;
   CHECK(signals_.insert(std::make_pair(signal_name, signal)).second)
       << "The signal '" << signal_name << "' is already registered";
 }
 
-
 ///////////////////////////////////////////////////////////////////////////////
 
 DBusObject::DBusObject(ExportedObjectManager* object_manager,
                        const scoped_refptr<dbus::Bus>& bus,
                        const dbus::ObjectPath& object_path)
-    : property_set_(bus.get()),
-      bus_(bus),
-      object_path_(object_path) {
+    : property_set_(bus.get()), bus_(bus), object_path_(object_path) {
   if (object_manager)
     object_manager_ = object_manager->AsWeakPtr();
 }
@@ -139,21 +133,21 @@
     // Interface doesn't exist yet. Create one...
     std::unique_ptr<DBusInterface> new_itf(
         new DBusInterface(this, interface_name));
-    iter = interfaces_.insert(
-        std::make_pair(interface_name, std::move(new_itf))).first;
+    iter = interfaces_.insert(std::make_pair(interface_name,
+                                             std::move(new_itf))).first;
   }
   return iter->second.get();
 }
 
 DBusInterface* DBusObject::FindInterface(
-      const std::string& interface_name) const {
+    const std::string& interface_name) const {
   auto itf_iter = interfaces_.find(interface_name);
   return (itf_iter == interfaces_.end()) ? nullptr : itf_iter->second.get();
 }
 
 void DBusObject::RegisterAsync(
     const AsyncEventSequencer::CompletionAction& completion_callback) {
-  VLOG(1) << "Registering D-Bus object '"<< object_path_.value() << "'.";
+  VLOG(1) << "Registering D-Bus object '" << object_path_.value() << "'.";
   CHECK(exported_object_ == nullptr) << "Object already registered.";
   scoped_refptr<AsyncEventSequencer> sequencer(new AsyncEventSequencer());
   exported_object_ = bus_->GetExportedObject(object_path_);
diff --git a/chromeos/dbus/dbus_object.h b/chromeos/dbus/dbus_object.h
index 766761f..5701801 100644
--- a/chromeos/dbus/dbus_object.h
+++ b/chromeos/dbus/dbus_object.h
@@ -123,9 +123,8 @@
   // Register sync D-Bus method handler for |method_name| as a static
   // function.
   template<typename R, typename... Args>
-  inline void AddSimpleMethodHandler(
-      const std::string& method_name,
-      R(*handler)(Args...)) {
+  inline void AddSimpleMethodHandler(const std::string& method_name,
+                                     R(*handler)(Args...)) {
     Handler<SimpleDBusInterfaceMethodHandler<R, Args...>>::Add(
         this, method_name, base::Bind(handler));
   }
@@ -133,20 +132,18 @@
   // Register sync D-Bus method handler for |method_name| as a class member
   // function.
   template<typename Instance, typename Class, typename R, typename... Args>
-  inline void AddSimpleMethodHandler(
-      const std::string& method_name,
-      Instance instance,
-      R(Class::*handler)(Args...)) {
+  inline void AddSimpleMethodHandler(const std::string& method_name,
+                                     Instance instance,
+                                     R(Class::*handler)(Args...)) {
     Handler<SimpleDBusInterfaceMethodHandler<R, Args...>>::Add(
         this, method_name, base::Bind(handler, instance));
   }
 
   // Same as above but for const-method of a class.
   template<typename Instance, typename Class, typename R, typename... Args>
-  inline void AddSimpleMethodHandler(
-      const std::string& method_name,
-      Instance instance,
-      R(Class::*handler)(Args...) const) {
+  inline void AddSimpleMethodHandler(const std::string& method_name,
+                                     Instance instance,
+                                     R(Class::*handler)(Args...) const) {
     Handler<SimpleDBusInterfaceMethodHandler<R, Args...>>::Add(
         this, method_name, base::Bind(handler, instance));
   }
@@ -205,9 +202,8 @@
   // Register an async D-Bus method handler for |method_name| as a static
   // function.
   template<typename Response, typename... Args>
-  inline void AddMethodHandler(
-      const std::string& method_name,
-      void(*handler)(scoped_ptr<Response>, Args...)) {
+  inline void AddMethodHandler(const std::string& method_name,
+                               void (*handler)(scoped_ptr<Response>, Args...)) {
     static_assert(std::is_base_of<DBusMethodResponseBase, Response>::value,
                   "Response must be DBusMethodResponse<T...>");
     Handler<DBusInterfaceMethodHandler<Response, Args...>>::Add(
@@ -216,7 +212,9 @@
 
   // Register an async D-Bus method handler for |method_name| as a class member
   // function.
-  template<typename Response, typename Instance, typename Class,
+  template<typename Response,
+           typename Instance,
+           typename Class,
            typename... Args>
   inline void AddMethodHandler(
       const std::string& method_name,
@@ -229,7 +227,9 @@
   }
 
   // Same as above but for const-method of a class.
-  template<typename Response, typename Instance, typename Class,
+  template<typename Response,
+           typename Instance,
+           typename Class,
            typename... Args>
   inline void AddMethodHandler(
       const std::string& method_name,
@@ -283,9 +283,8 @@
   template<typename DBusSignalType>
   inline std::weak_ptr<DBusSignalType> RegisterSignalOfType(
       const std::string& signal_name) {
-    auto signal = std::make_shared<DBusSignalType>(dbus_object_,
-                                                   interface_name_,
-                                                   signal_name);
+    auto signal = std::make_shared<DBusSignalType>(
+        dbus_object_, interface_name_, signal_name);
     AddSignalImpl(signal_name, signal);
     return signal;
   }
@@ -351,8 +350,8 @@
       const AsyncEventSequencer::CompletionAction& completion_callback);
 
   // Method registration map.
-  std::map<std::string,
-           std::unique_ptr<DBusInterfaceMethodHandlerInterface>> handlers_;
+  std::map<std::string, std::unique_ptr<DBusInterfaceMethodHandlerInterface>>
+      handlers_;
   // Signal registration map.
   std::map<std::string, std::shared_ptr<DBusSignalBase>> signals_;
 
diff --git a/chromeos/dbus/dbus_object_internal_impl.h b/chromeos/dbus/dbus_object_internal_impl.h
index 925ce04..22df883 100644
--- a/chromeos/dbus/dbus_object_internal_impl.h
+++ b/chromeos/dbus/dbus_object_internal_impl.h
@@ -86,9 +86,8 @@
     ErrorPtr param_reader_error;
     dbus::MessageReader reader(method_call);
     // The handler is expected a return value, don't allow output parameters.
-    if (!DBusParamReader<false, Args...>::Invoke(invoke_callback,
-                                                 &reader,
-                                                 &param_reader_error)) {
+    if (!DBusParamReader<false, Args...>::Invoke(
+            invoke_callback, &reader, &param_reader_error)) {
       // Error parsing method arguments.
       method_response.ReplyWithError(param_reader_error.get());
     }
@@ -124,9 +123,8 @@
 
     ErrorPtr param_reader_error;
     dbus::MessageReader reader(method_call);
-    if (!DBusParamReader<true, Args...>::Invoke(invoke_callback,
-                                                &reader,
-                                                &param_reader_error)) {
+    if (!DBusParamReader<true, Args...>::Invoke(
+            invoke_callback, &reader, &param_reader_error)) {
       // Error parsing method arguments.
       method_response.ReplyWithError(param_reader_error.get());
     }
@@ -156,7 +154,7 @@
   // virtual function is invoked.
   explicit SimpleDBusInterfaceMethodHandlerWithError(
       const base::Callback<bool(ErrorPtr*, Args...)>& handler)
-          : handler_(handler) {}
+      : handler_(handler) {}
 
   void HandleMethod(dbus::MethodCall* method_call,
                     ResponseSender sender) override {
@@ -175,9 +173,8 @@
 
     ErrorPtr param_reader_error;
     dbus::MessageReader reader(method_call);
-    if (!DBusParamReader<true, Args...>::Invoke(invoke_callback,
-                                                &reader,
-                                                &param_reader_error)) {
+    if (!DBusParamReader<true, Args...>::Invoke(
+            invoke_callback, &reader, &param_reader_error)) {
       // Error parsing method arguments.
       method_response.ReplyWithError(param_reader_error.get());
     }
@@ -203,7 +200,7 @@
   // virtual function is invoked.
   explicit DBusInterfaceMethodHandler(
       const base::Callback<void(scoped_ptr<Response>, Args...)>& handler)
-          : handler_(handler) {}
+      : handler_(handler) {}
 
   // This method forwards the call to |handler_| after extracting the required
   // arguments from the DBus message buffer specified in |method_call|.
@@ -217,9 +214,8 @@
 
     ErrorPtr param_reader_error;
     dbus::MessageReader reader(method_call);
-    if (!DBusParamReader<false, Args...>::Invoke(invoke_callback,
-                                                 &reader,
-                                                 &param_reader_error)) {
+    if (!DBusParamReader<false, Args...>::Invoke(
+            invoke_callback, &reader, &param_reader_error)) {
       // Error parsing method arguments.
       DBusMethodResponseBase method_response(method_call, sender);
       method_response.ReplyWithError(param_reader_error.get());
@@ -247,8 +243,7 @@
   // virtual function is invoked.
   RawDBusInterfaceMethodHandler(
       const base::Callback<void(dbus::MethodCall*, ResponseSender)>& handler)
-      : handler_(handler) {
-  }
+      : handler_(handler) {}
 
   void HandleMethod(dbus::MethodCall* method_call,
                     ResponseSender sender) override {
diff --git a/chromeos/dbus/dbus_object_unittest.cc b/chromeos/dbus/dbus_object_unittest.cc
index 70c3144..f0b7d55 100644
--- a/chromeos/dbus/dbus_object_unittest.cc
+++ b/chromeos/dbus/dbus_object_unittest.cc
@@ -82,26 +82,27 @@
     EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
     // Use a mock exported object.
     const dbus::ObjectPath kMethodsExportedOnPath(std::string("/export"));
-    mock_exported_object_ = new dbus::MockExportedObject(
-        bus_.get(), kMethodsExportedOnPath);
+    mock_exported_object_ =
+        new dbus::MockExportedObject(bus_.get(), kMethodsExportedOnPath);
     EXPECT_CALL(*bus_, GetExportedObject(kMethodsExportedOnPath))
-        .Times(AnyNumber()).WillRepeatedly(Return(mock_exported_object_.get()));
-    EXPECT_CALL(*mock_exported_object_,
-                ExportMethod(_, _, _, _)).Times(AnyNumber());
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(mock_exported_object_.get()));
+    EXPECT_CALL(*mock_exported_object_, ExportMethod(_, _, _, _))
+        .Times(AnyNumber());
     EXPECT_CALL(*mock_exported_object_, Unregister()).Times(1);
 
     dbus_object_ = std::unique_ptr<DBusObject>(
         new DBusObject(nullptr, bus_, kMethodsExportedOnPath));
 
     DBusInterface* itf1 = dbus_object_->AddOrGetInterface(kTestInterface1);
-    itf1->AddSimpleMethodHandler(kTestMethod_Add,
-                                 base::Unretained(&calc_), &Calc::Add);
-    itf1->AddSimpleMethodHandler(kTestMethod_Negate,
-                                 base::Unretained(&calc_), &Calc::Negate);
-    itf1->AddMethodHandler(kTestMethod_Positive,
-                           base::Unretained(&calc_), &Calc::Positive);
-    itf1->AddSimpleMethodHandler(kTestMethod_AddSubtract,
-                                 base::Unretained(&calc_), &Calc::AddSubtract);
+    itf1->AddSimpleMethodHandler(
+        kTestMethod_Add, base::Unretained(&calc_), &Calc::Add);
+    itf1->AddSimpleMethodHandler(
+        kTestMethod_Negate, base::Unretained(&calc_), &Calc::Negate);
+    itf1->AddMethodHandler(
+        kTestMethod_Positive, base::Unretained(&calc_), &Calc::Positive);
+    itf1->AddSimpleMethodHandler(
+        kTestMethod_AddSubtract, base::Unretained(&calc_), &Calc::AddSubtract);
     DBusInterface* itf2 = dbus_object_->AddOrGetInterface(kTestInterface2);
     itf2->AddSimpleMethodHandler(kTestMethod_StrLen, StrLen);
     itf2->AddSimpleMethodHandlerWithError(kTestMethod_CheckNonEmpty,
diff --git a/chromeos/dbus/dbus_param_reader.h b/chromeos/dbus/dbus_param_reader.h
index 216a222..0ac1c2a 100644
--- a/chromeos/dbus/dbus_param_reader.h
+++ b/chromeos/dbus/dbus_param_reader.h
@@ -72,10 +72,10 @@
   // Overload 1: ParamType is not a pointer.
   template<typename ParamType, typename CallbackType, typename... Args>
   static typename std::enable_if<!std::is_pointer<ParamType>::value, bool>::type
-      InvokeHelper(const CallbackType& handler,
-                   dbus::MessageReader* reader,
-                   ErrorPtr* error,
-                   const Args&... args) {
+  InvokeHelper(const CallbackType& handler,
+               dbus::MessageReader* reader,
+               ErrorPtr* error,
+               const Args&... args) {
     if (!reader->HasMoreData()) {
       Error::AddTo(error, FROM_HERE, errors::dbus::kDomain,
                    DBUS_ERROR_INVALID_ARGS,
diff --git a/chromeos/dbus/dbus_param_reader_unittest.cc b/chromeos/dbus/dbus_param_reader_unittest.cc
index db0a975..d498516 100644
--- a/chromeos/dbus/dbus_param_reader_unittest.cc
+++ b/chromeos/dbus/dbus_param_reader_unittest.cc
@@ -35,8 +35,8 @@
     EXPECT_EQ(123, param1);
     called = true;
   };
-  EXPECT_TRUE((DBusParamReader<false, int>::Invoke(callback, &reader,
-                                                   nullptr)));
+  EXPECT_TRUE(
+      (DBusParamReader<false, int>::Invoke(callback, &reader, nullptr)));
   EXPECT_TRUE(called);
 }
 
@@ -76,8 +76,8 @@
     called = true;
   };
   ErrorPtr error;
-  EXPECT_FALSE((DBusParamReader<false, bool, int>::Invoke(callback, &reader,
-                                                          &error)));
+  EXPECT_FALSE(
+      (DBusParamReader<false, bool, int>::Invoke(callback, &reader, &error)));
   EXPECT_FALSE(called);
   EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
   EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
@@ -96,8 +96,8 @@
     called = true;
   };
   ErrorPtr error;
-  EXPECT_FALSE((DBusParamReader<false, bool, int>::Invoke(callback, &reader,
-                                                          &error)));
+  EXPECT_FALSE(
+      (DBusParamReader<false, bool, int>::Invoke(callback, &reader, &error)));
   EXPECT_FALSE(called);
   EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
   EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
@@ -117,8 +117,8 @@
     called = true;
   };
   ErrorPtr error;
-  EXPECT_FALSE((DBusParamReader<false, bool, double>::Invoke(callback, &reader,
-                                                             &error)));
+  EXPECT_FALSE((
+      DBusParamReader<false, bool, double>::Invoke(callback, &reader, &error)));
   EXPECT_FALSE(called);
   EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
   EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
@@ -133,8 +133,8 @@
     EXPECT_EQ(0, *param1);
     called = true;
   };
-  EXPECT_TRUE((DBusParamReader<true, int*>::Invoke(callback, &reader,
-                                                   nullptr)));
+  EXPECT_TRUE(
+      (DBusParamReader<true, int*>::Invoke(callback, &reader, nullptr)));
   EXPECT_TRUE(called);
 }
 
@@ -149,8 +149,8 @@
     EXPECT_DOUBLE_EQ(0.0, *param2);
     called = true;
   };
-  EXPECT_TRUE((DBusParamReader<true, int, double*>::Invoke(callback, &reader,
-                                                           nullptr)));
+  EXPECT_TRUE((
+      DBusParamReader<true, int, double*>::Invoke(callback, &reader, nullptr)));
   EXPECT_TRUE(called);
 }
 
@@ -165,8 +165,8 @@
     EXPECT_EQ(123, param2);
     called = true;
   };
-  EXPECT_TRUE((DBusParamReader<true, double*, int>::Invoke(callback, &reader,
-                                                           nullptr)));
+  EXPECT_TRUE((
+      DBusParamReader<true, double*, int>::Invoke(callback, &reader, nullptr)));
   EXPECT_TRUE(called);
 }
 
@@ -194,9 +194,13 @@
     EXPECT_FALSE(*p6);
     called = true;
   };
-  EXPECT_TRUE((DBusParamReader<true, bool, std::string*, int, int*,
-                               VariantDictionary, bool*>::Invoke(
-      callback, &reader, nullptr)));
+  EXPECT_TRUE((DBusParamReader<true,
+                               bool,
+                               std::string*,
+                               int,
+                               int*,
+                               VariantDictionary,
+                               bool*>::Invoke(callback, &reader, nullptr)));
   EXPECT_TRUE(called);
 }
 
@@ -216,9 +220,8 @@
     called = true;
   };
   ErrorPtr error;
-  EXPECT_FALSE((DBusParamReader<true, bool, int, int*>::Invoke(callback,
-                                                               &reader,
-                                                               &error)));
+  EXPECT_FALSE((DBusParamReader<true, bool, int, int*>::Invoke(
+      callback, &reader, &error)));
   EXPECT_FALSE(called);
   EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
   EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
@@ -238,9 +241,8 @@
     called = true;
   };
   ErrorPtr error;
-  EXPECT_FALSE((DBusParamReader<true, bool, int, int*>::Invoke(callback,
-                                                               &reader,
-                                                               &error)));
+  EXPECT_FALSE((DBusParamReader<true, bool, int, int*>::Invoke(
+      callback, &reader, &error)));
   EXPECT_FALSE(called);
   EXPECT_EQ(errors::dbus::kDomain, error->GetDomain());
   EXPECT_EQ(DBUS_ERROR_INVALID_ARGS, error->GetCode());
diff --git a/chromeos/dbus/dbus_param_writer_unittest.cc b/chromeos/dbus/dbus_param_writer_unittest.cc
index cdedf5e..37c3f6f 100644
--- a/chromeos/dbus/dbus_param_writer_unittest.cc
+++ b/chromeos/dbus/dbus_param_writer_unittest.cc
@@ -109,10 +109,8 @@
   int32_t int_value_in{8};
   Any variant_value_in{8.5};
   bool bool_value_in{true};
-  DBusParamWriter::AppendDBusOutParams(&writer,
-                                       &int_value_in,
-                                       &variant_value_in,
-                                       &bool_value_in);
+  DBusParamWriter::AppendDBusOutParams(
+      &writer, &int_value_in, &variant_value_in, &bool_value_in);
   EXPECT_EQ("ivb", message->GetSignature());
 
   int32_t int_value = 0;
@@ -170,14 +168,8 @@
   int32_t int_value_in{8};
   Any variant_value_in{7.5};
   bool bool_value_in{true};
-  DBusParamWriter::AppendDBusOutParams(&writer,
-                                       0,
-                                       &int_value_in,
-                                       1,
-                                       &variant_value_in,
-                                       2,
-                                       &bool_value_in,
-                                       3);
+  DBusParamWriter::AppendDBusOutParams(
+      &writer, 0, &int_value_in, 1, &variant_value_in, 2, &bool_value_in, 3);
   EXPECT_EQ("ivb", message->GetSignature());
 
   int32_t int_value = 0;
diff --git a/chromeos/dbus/dbus_property.h b/chromeos/dbus/dbus_property.h
index e761033..48074a0 100644
--- a/chromeos/dbus/dbus_property.h
+++ b/chromeos/dbus/dbus_property.h
@@ -16,7 +16,7 @@
 // This class is pretty much a copy of dbus::Property<T> from dbus/property.h
 // except that it provides the implementations for PopValueFromReader and
 // AppendSetValueToWriter.
-template <class T>
+template<class T>
 class Property : public dbus::PropertyBase {
  public:
   Property() = default;
diff --git a/chromeos/dbus/dbus_signal.cc b/chromeos/dbus/dbus_signal.cc
index abddd61..b4e12d3 100644
--- a/chromeos/dbus/dbus_signal.cc
+++ b/chromeos/dbus/dbus_signal.cc
@@ -12,9 +12,9 @@
 DBusSignalBase::DBusSignalBase(DBusObject* dbus_object,
                                const std::string& interface_name,
                                const std::string& signal_name)
-  : interface_name_(interface_name),
-    signal_name_(signal_name),
-    dbus_object_(dbus_object) {
+    : interface_name_(interface_name),
+      signal_name_(signal_name),
+      dbus_object_(dbus_object) {
 }
 
 bool DBusSignalBase::SendSignal(dbus::Signal* signal) const {
diff --git a/chromeos/dbus/dbus_signal_handler.h b/chromeos/dbus/dbus_signal_handler.h
index 651198d..13a2b82 100644
--- a/chromeos/dbus/dbus_signal_handler.h
+++ b/chromeos/dbus/dbus_signal_handler.h
@@ -51,8 +51,8 @@
   // |signal_callback|.
   auto dbus_signal_callback = [signal_callback_wrapper](dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
-    DBusParamReader<false, Args...>::Invoke(signal_callback_wrapper, &reader,
-                                            nullptr);
+    DBusParamReader<false, Args...>::Invoke(
+        signal_callback_wrapper, &reader, nullptr);
   };
 
   // Register our stub handler with D-Bus ObjectProxy.
diff --git a/chromeos/dbus/dbus_signal_handler_unittest.cc b/chromeos/dbus/dbus_signal_handler_unittest.cc
index a195b39..08172ea 100644
--- a/chromeos/dbus/dbus_signal_handler_unittest.cc
+++ b/chromeos/dbus/dbus_signal_handler_unittest.cc
@@ -27,7 +27,7 @@
 const char kInterface[] = "org.test.Object.TestInterface";
 const char kSignal[] = "TestSignal";
 
-class DBusSignalHandlerTest: public testing::Test {
+class DBusSignalHandlerTest : public testing::Test {
  public:
   void SetUp() override {
     dbus::Bus::Options options;
@@ -39,14 +39,12 @@
     // Use a mock object proxy.
     mock_object_proxy_ = new dbus::MockObjectProxy(
         bus_.get(), kTestServiceName, dbus::ObjectPath(kTestPath));
-    EXPECT_CALL(*bus_, GetObjectProxy(kTestServiceName,
-                                      dbus::ObjectPath(kTestPath)))
+    EXPECT_CALL(*bus_,
+                GetObjectProxy(kTestServiceName, dbus::ObjectPath(kTestPath)))
         .WillRepeatedly(Return(mock_object_proxy_.get()));
   }
 
-  void TearDown() override {
-    bus_ = nullptr;
-  }
+  void TearDown() override { bus_ = nullptr; }
 
  protected:
   template<typename SignalHandlerSink, typename... Args>
@@ -56,8 +54,11 @@
         .WillOnce(SaveArg<2>(&signal_callback));
 
     chromeos::dbus_utils::ConnectToSignal(
-        mock_object_proxy_.get(), kInterface, kSignal,
-        base::Bind(&SignalHandlerSink::Handler, base::Unretained(sink)), {});
+        mock_object_proxy_.get(),
+        kInterface,
+        kSignal,
+        base::Bind(&SignalHandlerSink::Handler, base::Unretained(sink)),
+        {});
 
     dbus::Signal signal(kInterface, kSignal);
     dbus::MessageWriter writer(&signal);
@@ -70,12 +71,11 @@
 };
 
 TEST_F(DBusSignalHandlerTest, ConnectToSignal) {
-  EXPECT_CALL(*mock_object_proxy_,
-              ConnectToSignal(kInterface, kSignal, _, _)).Times(1);
+  EXPECT_CALL(*mock_object_proxy_, ConnectToSignal(kInterface, kSignal, _, _))
+      .Times(1);
 
-  chromeos::dbus_utils::ConnectToSignal(mock_object_proxy_.get(),
-                                        kInterface, kSignal,
-                                        base::Closure{}, {});
+  chromeos::dbus_utils::ConnectToSignal(
+      mock_object_proxy_.get(), kInterface, kSignal, base::Closure{}, {});
 }
 
 TEST_F(DBusSignalHandlerTest, CallSignal_3Args) {
diff --git a/chromeos/dbus/exported_object_manager.cc b/chromeos/dbus/exported_object_manager.cc
index 49ebd3e..f952e57 100644
--- a/chromeos/dbus/exported_object_manager.cc
+++ b/chromeos/dbus/exported_object_manager.cc
@@ -17,10 +17,11 @@
 
 ExportedObjectManager::ExportedObjectManager(scoped_refptr<dbus::Bus> bus,
                                              const dbus::ObjectPath& path)
-    : bus_(bus), dbus_object_(nullptr, bus, path) {}
+    : bus_(bus), dbus_object_(nullptr, bus, path) {
+}
 
 void ExportedObjectManager::RegisterAsync(
-      const AsyncEventSequencer::CompletionAction& completion_callback) {
+    const AsyncEventSequencer::CompletionAction& completion_callback) {
   VLOG(1) << "Registering object manager";
   bus_->AssertOnOriginThread();
   DBusInterface* itf =
@@ -48,14 +49,15 @@
   VariantDictionary property_dict;
   property_writer.Run(&property_dict);
   std::map<std::string, VariantDictionary> interfaces_and_properties{
-    {interface_name, property_dict}
+      {interface_name, property_dict}
   };
   signal_itf_added_.lock()->Send(path, interfaces_and_properties);
   registered_objects_[path][interface_name] = property_writer;
 }
 
 void ExportedObjectManager::ReleaseInterface(
-    const dbus::ObjectPath& path, const std::string& interface_name) {
+    const dbus::ObjectPath& path,
+    const std::string& interface_name) {
   bus_->AssertOnOriginThread();
   auto interfaces_for_path_itr = registered_objects_.find(path);
   CHECK(interfaces_for_path_itr != registered_objects_.end())
@@ -78,7 +80,7 @@
 }
 
 ExportedObjectManager::ObjectMap
-    ExportedObjectManager::HandleGetManagedObjects() {
+ExportedObjectManager::HandleGetManagedObjects() {
   // Implements the GetManagedObjects method:
   //
   // org.freedesktop.DBus.ObjectManager.GetManagedObjects (
diff --git a/chromeos/dbus/exported_object_manager_unittest.cc b/chromeos/dbus/exported_object_manager_unittest.cc
index 3f3d867..9ae3b20 100644
--- a/chromeos/dbus/exported_object_manager_unittest.cc
+++ b/chromeos/dbus/exported_object_manager_unittest.cc
@@ -51,8 +51,7 @@
 }
 
 void VerifyInterfaceClaimSignal(dbus::Signal* signal) {
-  EXPECT_EQ(signal->GetInterface(),
-            std::string(dbus::kObjectManagerInterface));
+  EXPECT_EQ(signal->GetInterface(), std::string(dbus::kObjectManagerInterface));
   EXPECT_EQ(signal->GetMember(),
             std::string(dbus::kObjectManagerInterfacesAdded));
   //   org.freedesktop.DBus.ObjectManager.InterfacesAdded (
@@ -76,8 +75,7 @@
 }
 
 void VerifyInterfaceDropSignal(dbus::Signal* signal) {
-  EXPECT_EQ(signal->GetInterface(),
-            std::string(dbus::kObjectManagerInterface));
+  EXPECT_EQ(signal->GetInterface(), std::string(dbus::kObjectManagerInterface));
   EXPECT_EQ(signal->GetMember(),
             std::string(dbus::kObjectManagerInterfacesRemoved));
   //   org.freedesktop.DBus.ObjectManager.InterfacesRemoved (
@@ -97,7 +95,7 @@
 
 }  // namespace
 
-class ExportedObjectManagerTest: public ::testing::Test {
+class ExportedObjectManagerTest : public ::testing::Test {
  public:
   void SetUp() override {
     dbus::Bus::Options options;
@@ -107,12 +105,11 @@
     EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
     EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
     // Use a mock exported object.
-    mock_exported_object_ = new dbus::MockExportedObject(
-        bus_.get(), kTestPath);
-    EXPECT_CALL(*bus_, GetExportedObject(kTestPath))
-        .Times(1).WillOnce(Return(mock_exported_object_.get()));
-    EXPECT_CALL(*mock_exported_object_,
-                ExportMethod(_, _, _, _)).Times(AnyNumber());
+    mock_exported_object_ = new dbus::MockExportedObject(bus_.get(), kTestPath);
+    EXPECT_CALL(*bus_, GetExportedObject(kTestPath)).Times(1).WillOnce(
+        Return(mock_exported_object_.get()));
+    EXPECT_CALL(*mock_exported_object_, ExportMethod(_, _, _, _))
+        .Times(AnyNumber());
     om_.reset(new ExportedObjectManager(bus_.get(), kTestPath));
     property_writer_ = base::Bind(&WriteTestPropertyDict);
     om_->RegisterAsync(AsyncEventSequencer::GetDefaultCompletionAction());
diff --git a/chromeos/dbus/exported_property_set.cc b/chromeos/dbus/exported_property_set.cc
index de8a4a4..0f7d7cf 100644
--- a/chromeos/dbus/exported_property_set.cc
+++ b/chromeos/dbus/exported_property_set.cc
@@ -19,8 +19,8 @@
 namespace dbus_utils {
 
 ExportedPropertySet::ExportedPropertySet(dbus::Bus* bus)
-    : bus_(bus),
-      weak_ptr_factory_(this) { }
+    : bus_(bus), weak_ptr_factory_(this) {
+}
 
 void ExportedPropertySet::OnPropertiesInterfaceExported(
     DBusInterface* prop_interface) {
@@ -46,10 +46,11 @@
   CHECK(res.second) << "Property '" << property_name << "' already exists";
   // Technically, the property set exists longer than the properties themselves,
   // so we could use Unretained here rather than a weak pointer.
-  ExportedPropertyBase::OnUpdateCallback cb = base::Bind(
-      &ExportedPropertySet::HandlePropertyUpdated,
-      weak_ptr_factory_.GetWeakPtr(),
-      interface_name, property_name);
+  ExportedPropertyBase::OnUpdateCallback cb =
+      base::Bind(&ExportedPropertySet::HandlePropertyUpdated,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 interface_name,
+                 property_name);
   exported_property->SetUpdateCallback(cb);
 }
 
@@ -60,7 +61,7 @@
 }
 
 VariantDictionary ExportedPropertySet::GetInterfaceProperties(
-     const std::string& interface_name) const {
+    const std::string& interface_name) const {
   VariantDictionary properties;
   auto property_map_itr = properties_.find(interface_name);
   if (property_map_itr != properties_.end()) {
@@ -76,11 +77,10 @@
   *dict = GetInterfaceProperties(interface_name);
 }
 
-bool ExportedPropertySet::HandleGet(
-    chromeos::ErrorPtr* error,
-    const std::string& interface_name,
-    const std::string& property_name,
-    chromeos::Any* result) {
+bool ExportedPropertySet::HandleGet(chromeos::ErrorPtr* error,
+                                    const std::string& interface_name,
+                                    const std::string& property_name,
+                                    chromeos::Any* result) {
   bus_->AssertOnOriginThread();
   auto property_map_itr = properties_.find(interface_name);
   if (property_map_itr == properties_.end()) {
@@ -105,11 +105,10 @@
   return true;
 }
 
-bool ExportedPropertySet::HandleSet(
-    chromeos::ErrorPtr* error,
-    const std::string& interface_name,
-    const std::string& property_name,
-    const chromeos::Any& value) {
+bool ExportedPropertySet::HandleSet(chromeos::ErrorPtr* error,
+                                    const std::string& interface_name,
+                                    const std::string& property_name,
+                                    const chromeos::Any& value) {
   bus_->AssertOnOriginThread();
   auto property_map_itr = properties_.find(interface_name);
   if (property_map_itr == properties_.end()) {
diff --git a/chromeos/dbus/exported_property_set.h b/chromeos/dbus/exported_property_set.h
index 530b6ea..5b8dc57 100644
--- a/chromeos/dbus/exported_property_set.h
+++ b/chromeos/dbus/exported_property_set.h
@@ -113,20 +113,18 @@
 
   // D-Bus methods for org.freedesktop.DBus.Properties interface.
   VariantDictionary HandleGetAll(const std::string& interface_name);
-  bool HandleGet(
-      chromeos::ErrorPtr* error,
-      const std::string& interface_name,
-      const std::string& property_name,
-      chromeos::Any* result);
+  bool HandleGet(chromeos::ErrorPtr* error,
+                 const std::string& interface_name,
+                 const std::string& property_name,
+                 chromeos::Any* result);
   // While Properties.Set has a handler to complete the interface,  we don't
   // support writable properties.  This is almost a feature, since bindings for
   // many languages don't support errors coming back from invalid writes.
   // Instead, use setters in exposed interfaces.
-  bool HandleSet(
-      chromeos::ErrorPtr* error,
-      const std::string& interface_name,
-      const std::string& property_name,
-      const chromeos::Any& value);
+  bool HandleSet(chromeos::ErrorPtr* error,
+                 const std::string& interface_name,
+                 const std::string& property_name,
+                 const chromeos::Any& value);
   // Returns a string-to-variant map of all the properties for the given
   // interface and their values.
   VariantDictionary GetInterfaceProperties(
@@ -136,9 +134,8 @@
   // Used to write the dictionary of string->variant to a message.
   // This dictionary represents the property name/value pairs for the
   // given interface.
-  CHROMEOS_PRIVATE void WritePropertiesToDict(
-      const std::string& interface_name,
-      VariantDictionary* dict);
+  CHROMEOS_PRIVATE void WritePropertiesToDict(const std::string& interface_name,
+                                              VariantDictionary* dict);
   CHROMEOS_PRIVATE void HandlePropertyUpdated(
       const std::string& interface_name,
       const std::string& property_name,
@@ -146,8 +143,8 @@
 
   dbus::Bus* bus_;  // weak; owned by outer DBusObject containing this object.
   // This is a map from interface name -> property name -> pointer to property.
-  std::map<std::string,
-           std::map<std::string, ExportedPropertyBase*>> properties_;
+  std::map<std::string, std::map<std::string, ExportedPropertyBase*>>
+      properties_;
 
   // D-Bus callbacks may last longer the property set exporting those methods.
   base::WeakPtrFactory<ExportedPropertySet> weak_ptr_factory_;
@@ -162,7 +159,7 @@
   DISALLOW_COPY_AND_ASSIGN(ExportedPropertySet);
 };
 
-template <typename T>
+template<typename T>
 class ExportedProperty : public ExportedPropertyBase {
  public:
   ExportedProperty() = default;
@@ -173,7 +170,7 @@
 
   // Set the value exposed to remote applications.  This triggers notifications
   // of changes over the Properties interface.
-  void SetValue(const T& new_value)  {
+  void SetValue(const T& new_value) {
     if (value_ != new_value) {
       value_ = new_value;
       this->NotifyPropertyChanged();
diff --git a/chromeos/dbus/exported_property_set_unittest.cc b/chromeos/dbus/exported_property_set_unittest.cc
index 5e3965d..5ecd08b 100644
--- a/chromeos/dbus/exported_property_set_unittest.cc
+++ b/chromeos/dbus/exported_property_set_unittest.cc
@@ -116,8 +116,8 @@
     EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
     EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
     // Use a mock exported object.
-    mock_exported_object_ = new dbus::MockExportedObject(
-        bus_.get(), kMethodsExportedOnPath);
+    mock_exported_object_ =
+        new dbus::MockExportedObject(bus_.get(), kMethodsExportedOnPath);
     EXPECT_CALL(*bus_, GetExportedObject(kMethodsExportedOnPath))
         .Times(1).WillOnce(Return(mock_exported_object_.get()));
 
@@ -137,7 +137,8 @@
   }
 
   std::unique_ptr<dbus::Response> GetPropertyOnInterface(
-      const std::string& interface_name, const std::string& property_name) {
+      const std::string& interface_name,
+      const std::string& property_name) {
     dbus::MethodCall method_call(dbus::kPropertiesInterface,
                                  dbus::kPropertiesGet);
     method_call.SetSerial(123);
@@ -167,7 +168,7 @@
   scoped_ptr<Properties> p_;
 };
 
-template <typename T>
+template<typename T>
 class PropertyValidatorObserver {
  public:
   PropertyValidatorObserver()
@@ -180,7 +181,7 @@
                  bool(chromeos::ErrorPtr* error, const T& value));
 
   const base::Callback<bool(chromeos::ErrorPtr*, const T&)>&
-      validate_property_callback() const {
+  validate_property_callback() const {
     return validate_property_callback_;
   }
 
@@ -222,8 +223,8 @@
 }
 
 TEST_F(ExportedPropertySetTest, GetAllInvalidInterface) {
-  dbus::MethodCall method_call(
-      dbus::kPropertiesInterface, dbus::kPropertiesGetAll);
+  dbus::MethodCall method_call(dbus::kPropertiesInterface,
+                               dbus::kPropertiesGetAll);
   method_call.SetSerial(123);
   dbus::MessageWriter writer(&method_call);
   writer.AppendString("org.chromium.BadInterface");
@@ -248,8 +249,8 @@
 }
 
 TEST_F(ExportedPropertySetTest, GetAllCorrectness) {
-  dbus::MethodCall method_call(
-      dbus::kPropertiesInterface, dbus::kPropertiesGetAll);
+  dbus::MethodCall method_call(dbus::kPropertiesInterface,
+                               dbus::kPropertiesGetAll);
   method_call.SetSerial(123);
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(kTestInterface2);
@@ -459,34 +460,30 @@
 }
 
 TEST_F(ExportedPropertySetTest, SetInvalidInterface) {
-  auto response = SetPropertyOnInterface("BadInterfaceName",
-                                         kStringPropName,
-                                         chromeos::Any(kTestString));
+  auto response = SetPropertyOnInterface(
+      "BadInterfaceName", kStringPropName, chromeos::Any(kTestString));
   ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
   ASSERT_EQ(DBUS_ERROR_UNKNOWN_INTERFACE, response->GetErrorName());
 }
 
 TEST_F(ExportedPropertySetTest, SetBadPropertyName) {
-  auto response = SetPropertyOnInterface(kTestInterface3,
-                                         "IAmNotAProperty",
-                                         chromeos::Any(kTestString));
+  auto response = SetPropertyOnInterface(
+      kTestInterface3, "IAmNotAProperty", chromeos::Any(kTestString));
   ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
   ASSERT_EQ(DBUS_ERROR_UNKNOWN_PROPERTY, response->GetErrorName());
 }
 
 TEST_F(ExportedPropertySetTest, SetFailsWithReadOnlyProperty) {
-  auto response = SetPropertyOnInterface(kTestInterface3,
-                                         kStringPropName,
-                                         chromeos::Any(kTestString));
+  auto response = SetPropertyOnInterface(
+      kTestInterface3, kStringPropName, chromeos::Any(kTestString));
   ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
   ASSERT_EQ(DBUS_ERROR_PROPERTY_READ_ONLY, response->GetErrorName());
 }
 
 TEST_F(ExportedPropertySetTest, SetFailsWithMismatchedValueType) {
   p_->string_prop_.SetAccessMode(ExportedPropertyBase::Access::kReadWrite);
-  auto response = SetPropertyOnInterface(kTestInterface3,
-                                         kStringPropName,
-                                         chromeos::Any(true));
+  auto response = SetPropertyOnInterface(
+      kTestInterface3, kStringPropName, chromeos::Any(true));
   ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
   ASSERT_EQ(DBUS_ERROR_INVALID_ARGS, response->GetErrorName());
 }
@@ -499,7 +496,7 @@
                          errors::dbus::kDomain,
                          DBUS_ERROR_INVALID_ARGS,
                          "Invalid value");
-    return false;
+  return false;
 }
 
 }  // namespace
@@ -514,9 +511,8 @@
       FROM_HERE, errors::dbus::kDomain, DBUS_ERROR_INVALID_ARGS, "");
   EXPECT_CALL(property_validator, ValidateProperty(_, kTestString))
       .WillOnce(Invoke(SetInvalidProperty));
-  auto response = SetPropertyOnInterface(kTestInterface3,
-                                         kStringPropName,
-                                         chromeos::Any(kTestString));
+  auto response = SetPropertyOnInterface(
+      kTestInterface3, kStringPropName, chromeos::Any(kTestString));
   ASSERT_EQ(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
   ASSERT_EQ(DBUS_ERROR_INVALID_ARGS, response->GetErrorName());
 }
@@ -529,9 +525,8 @@
 
   EXPECT_CALL(property_validator, ValidateProperty(_, kTestString))
       .WillOnce(Return(true));
-  auto response = SetPropertyOnInterface(kTestInterface3,
-                                         kStringPropName,
-                                         chromeos::Any(kTestString));
+  auto response = SetPropertyOnInterface(
+      kTestInterface3, kStringPropName, chromeos::Any(kTestString));
   ASSERT_NE(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
   ASSERT_EQ(kTestString, p_->string_prop_.value());
 }
@@ -546,18 +541,16 @@
 
   // No need to validate the value if it is the same as the current one.
   EXPECT_CALL(property_validator, ValidateProperty(_, _)).Times(0);
-  auto response = SetPropertyOnInterface(kTestInterface3,
-                                         kStringPropName,
-                                         chromeos::Any(kTestString));
+  auto response = SetPropertyOnInterface(
+      kTestInterface3, kStringPropName, chromeos::Any(kTestString));
   ASSERT_NE(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
   ASSERT_EQ(kTestString, p_->string_prop_.value());
 }
 
 TEST_F(ExportedPropertySetTest, SetWorksWithoutValidator) {
   p_->string_prop_.SetAccessMode(ExportedPropertyBase::Access::kReadWrite);
-  auto response = SetPropertyOnInterface(kTestInterface3,
-                                         kStringPropName,
-                                         chromeos::Any(kTestString));
+  auto response = SetPropertyOnInterface(
+      kTestInterface3, kStringPropName, chromeos::Any(kTestString));
   ASSERT_NE(dbus::Message::MESSAGE_ERROR, response->GetMessageType());
   ASSERT_EQ(kTestString, p_->string_prop_.value());
 }
diff --git a/chromeos/dbus/mock_dbus_object.h b/chromeos/dbus/mock_dbus_object.h
index 2f4d57e..7d0d663 100644
--- a/chromeos/dbus/mock_dbus_object.h
+++ b/chromeos/dbus/mock_dbus_object.h
@@ -19,7 +19,7 @@
   MockDBusObject(ExportedObjectManager* object_manager,
                  const scoped_refptr<dbus::Bus>& bus,
                  const dbus::ObjectPath& object_path)
-    : DBusObject(object_manager, bus, object_path) {}
+      : DBusObject(object_manager, bus, object_path) {}
   virtual ~MockDBusObject() = default;
 
   MOCK_METHOD1(RegisterAsync,
diff --git a/chromeos/dbus/utils.cc b/chromeos/dbus/utils.cc
index db3b151..aa23acf 100644
--- a/chromeos/dbus/utils.cc
+++ b/chromeos/dbus/utils.cc
@@ -19,8 +19,8 @@
     dbus::MethodCall* method_call,
     const std::string& error_name,
     const std::string& error_message) {
-  auto resp = dbus::ErrorResponse::FromMethodCall(method_call, error_name,
-                                                  error_message);
+  auto resp = dbus::ErrorResponse::FromMethodCall(
+      method_call, error_name, error_message);
   return std::unique_ptr<dbus::Response>(resp.release());
 }
 
@@ -44,8 +44,8 @@
     // Format error string as "domain/code:message".
     if (!error_message.empty())
       error_message += ';';
-    error_message += error->GetDomain() + '/' + error->GetCode() + ':' +
-               error->GetMessage();
+    error_message +=
+        error->GetDomain() + '/' + error->GetCode() + ':' + error->GetMessage();
     error = error->GetInnerError();
   }
   return CreateDBusErrorResponse(method_call, error_name, error_message);
@@ -60,8 +60,7 @@
     // Each part should be in format of "domain/code:message"
     size_t slash_pos = part.find('/');
     size_t colon_pos = part.find(':');
-    if (slash_pos != std::string::npos &&
-        colon_pos != std::string::npos &&
+    if (slash_pos != std::string::npos && colon_pos != std::string::npos &&
         slash_pos < colon_pos) {
       // If we have both '/' and ':' and in proper order, then we have a
       // correctly encoded error object.
@@ -70,8 +69,7 @@
       std::string message = part.substr(colon_pos + 1);
       errors.emplace_back(domain, code, message);
     } else if (slash_pos == std::string::npos &&
-               colon_pos == std::string::npos &&
-               errors.empty()) {
+               colon_pos == std::string::npos && errors.empty()) {
       // If we don't have both '/' and ':' and this is the first error object,
       // then we had a D-Bus error at the top of the error chain.
       errors.emplace_back(errors::dbus::kDomain, dbus_error_name, part);
@@ -80,17 +78,16 @@
       // not generated by GetDBusError(). To be safe, stop parsing it
       // and return the error as received from D-Bus.
       errors.clear();  // Remove any errors accumulated so far.
-      errors.emplace_back(errors::dbus::kDomain,
-                          dbus_error_name,
-                          dbus_error_message);
+      errors.emplace_back(
+          errors::dbus::kDomain, dbus_error_name, dbus_error_message);
       break;
     }
   }
 
   // Go backwards and add the parsed errors to the error chain.
   for (auto it = errors.crbegin(); it != errors.crend(); ++it) {
-    Error::AddTo(error, FROM_HERE,
-                 std::get<0>(*it), std::get<1>(*it), std::get<2>(*it));
+    Error::AddTo(
+        error, FROM_HERE, std::get<0>(*it), std::get<1>(*it), std::get<2>(*it));
   }
 }
 
diff --git a/chromeos/errors/error.cc b/chromeos/errors/error.cc
index 1e7d3a6..86323a0 100644
--- a/chromeos/errors/error.cc
+++ b/chromeos/errors/error.cc
@@ -19,13 +19,10 @@
   // the current error location with the location passed in to the Error object.
   // This way the log will contain the actual location of the error, and not
   // as if it always comes from chromeos/errors/error.cc(22).
-  logging::LogMessage(location.file_name(),
-                      location.line_number(),
-                      logging::LOG_ERROR).stream()
+  logging::LogMessage(
+      location.file_name(), location.line_number(), logging::LOG_ERROR).stream()
       << location.function_name() << "(...): "
-      << "Domain=" << domain
-      << ", Code=" << code
-      << ", Message=" << message;
+      << "Domain=" << domain << ", Code=" << code << ", Message=" << message;
 }
 }  // anonymous namespace
 
@@ -42,8 +39,8 @@
                        const std::string& message,
                        ErrorPtr inner_error) {
   LogError(location, domain, code, message);
-  return ErrorPtr(new Error(location, domain, code, message,
-                            std::move(inner_error)));
+  return ErrorPtr(
+      new Error(location, domain, code, message, std::move(inner_error)));
 }
 
 void Error::AddTo(ErrorPtr* error,
@@ -64,7 +61,8 @@
                         const tracked_objects::Location& location,
                         const std::string& domain,
                         const std::string& code,
-                        const char* format, ...) {
+                        const char* format,
+                        ...) {
   va_list ap;
   va_start(ap, format);
   std::string message = base::StringPrintV(format, ap);
@@ -91,9 +89,12 @@
              const std::string& domain,
              const std::string& code,
              const std::string& message,
-             ErrorPtr inner_error) :
-    domain_(domain), code_(code), message_(message), location_(location),
-    inner_error_(std::move(inner_error)) {
+             ErrorPtr inner_error)
+    : domain_(domain),
+      code_(code),
+      message_(message),
+      location_(location),
+      inner_error_(std::move(inner_error)) {
 }
 
 const Error* Error::FindErrorOfDomain(const Error* error_chain_start,
diff --git a/chromeos/errors/error.h b/chromeos/errors/error.h
index 5f7b0b1..f3e5a8d 100644
--- a/chromeos/errors/error.h
+++ b/chromeos/errors/error.h
@@ -46,7 +46,8 @@
                           const tracked_objects::Location& location,
                           const std::string& domain,
                           const std::string& code,
-                          const char* format, ...) PRINTF_FORMAT(5, 6);
+                          const char* format,
+                          ...) PRINTF_FORMAT(5, 6);
 
   // Returns the error domain, code and message
   const std::string& GetDomain() const { return domain_; }
diff --git a/chromeos/errors/error_unittest.cc b/chromeos/errors/error_unittest.cc
index 3216d58..e256ead 100644
--- a/chromeos/errors/error_unittest.cc
+++ b/chromeos/errors/error_unittest.cc
@@ -11,8 +11,10 @@
 namespace {
 
 chromeos::ErrorPtr GenerateNetworkError() {
-  tracked_objects::Location loc("GenerateNetworkError", "error_unittest.cc",
-                                15, ::tracked_objects::GetProgramCounter());
+  tracked_objects::Location loc("GenerateNetworkError",
+                                "error_unittest.cc",
+                                15,
+                                ::tracked_objects::GetProgramCounter());
   return Error::Create(loc, "network", "not_found", "Resource not found");
 }
 
diff --git a/chromeos/file_utils.cc b/chromeos/file_utils.cc
index 637fa50..9d3bd53 100644
--- a/chromeos/file_utils.cc
+++ b/chromeos/file_utils.cc
@@ -67,8 +67,7 @@
   if (scoped_fd != -1) {
     struct stat file_stat;
     if (fstat(scoped_fd.get(), &file_stat) != -1 &&
-        S_ISREG(file_stat.st_mode) &&
-        file_stat.st_uid == uid &&
+        S_ISREG(file_stat.st_mode) && file_stat.st_uid == uid &&
         file_stat.st_gid == gid) {
       return kRegularFile;
     }
diff --git a/chromeos/file_utils_unittest.cc b/chromeos/file_utils_unittest.cc
index 9ad03b3..96a5801 100644
--- a/chromeos/file_utils_unittest.cc
+++ b/chromeos/file_utils_unittest.cc
@@ -52,8 +52,8 @@
 namespace {
 
 enum {
-  kPermissions600 = base::FILE_PERMISSION_READ_BY_USER |
-                    base::FILE_PERMISSION_WRITE_BY_USER,
+  kPermissions600 =
+      base::FILE_PERMISSION_READ_BY_USER | base::FILE_PERMISSION_WRITE_BY_USER,
   kPermissions700 = base::FILE_PERMISSION_USER_MASK,
   kPermissions777 = base::FILE_PERMISSION_MASK
 };
diff --git a/chromeos/flag_helper.cc b/chromeos/flag_helper.cc
index d66e3b7..bdc0880 100644
--- a/chromeos/flag_helper.cc
+++ b/chromeos/flag_helper.cc
@@ -30,7 +30,7 @@
 
 class HelpFlag : public chromeos::Flag {
  public:
-  HelpFlag() : Flag("help", "false", "Show this help message", true) { }
+  HelpFlag() : Flag("help", "false", "Show this help message", true) {}
 
   bool SetValue(const std::string& value) override { return true; };
   const char* GetType() const override { return "bool"; }
@@ -227,9 +227,8 @@
         error_code = EX_DATAERR;
       }
     } else {
-      base::StringAppendF(&error_msg,
-                          "ERROR: unknown command line flag '%s'\n",
-                          key.c_str());
+      base::StringAppendF(
+          &error_msg, "ERROR: unknown command line flag '%s'\n", key.c_str());
       error_code = EX_USAGE;
     }
   }
diff --git a/chromeos/flag_helper.h b/chromeos/flag_helper.h
index 1232b5a..73cd301 100644
--- a/chromeos/flag_helper.h
+++ b/chromeos/flag_helper.h
@@ -183,44 +183,34 @@
 // set bool flags to false.  Creating the FLAGS_noxxxx variables here
 // will also ensure a compiler error will be thrown if another flag
 // is created with a conflicting name.
-#define DEFINE_type(type, classtype, name, value, help)                        \
-  type FLAGS_##name = value;                                                   \
-  chromeos::FlagHelper::GetInstance()->AddFlag(                                \
-      std::unique_ptr<chromeos::Flag>(                                         \
+#define DEFINE_type(type, classtype, name, value, help) \
+  type FLAGS_##name = value;                            \
+  chromeos::FlagHelper::GetInstance()->AddFlag(         \
+      std::unique_ptr<chromeos::Flag>(                  \
           new chromeos::classtype(#name, &FLAGS_##name, #value, help, true)));
 
 #define DEFINE_int32(name, value, help) \
-    DEFINE_type(int, Int32Flag, name, value, help)
+  DEFINE_type(int, Int32Flag, name, value, help)
 #define DEFINE_int64(name, value, help) \
-    DEFINE_type(int64_t, Int64Flag, name, value, help)
+  DEFINE_type(int64_t, Int64Flag, name, value, help)
 #define DEFINE_uint64(name, value, help) \
-    DEFINE_type(uint64_t, UInt64Flag, name, value, help)
+  DEFINE_type(uint64_t, UInt64Flag, name, value, help)
 #define DEFINE_double(name, value, help) \
-    DEFINE_type(double, DoubleFlag, name, value, help)
+  DEFINE_type(double, DoubleFlag, name, value, help)
 #define DEFINE_string(name, value, help) \
-    DEFINE_type(std::string, StringFlag, name, value, help)
+  DEFINE_type(std::string, StringFlag, name, value, help)
 
 // Due to the FLAGS_no##name variables, can't re-use the same DEFINE_type macro
 // for defining bool flags
-#define DEFINE_bool(name, value, help)                                         \
-  bool FLAGS_##name = value;                                                   \
-  bool FLAGS_no##name = !value;                                                \
-  chromeos::FlagHelper::GetInstance()->AddFlag(                                \
-      std::unique_ptr<chromeos::Flag>(                                         \
-          new chromeos::BoolFlag(#name,                                        \
-                                 &FLAGS_##name,                                \
-                                 &FLAGS_no##name,                              \
-                                 #value,                                       \
-                                 help,                                         \
-                                 true)));                                      \
-  chromeos::FlagHelper::GetInstance()->AddFlag(                                \
-      std::unique_ptr<chromeos::Flag>(                                         \
-          new chromeos::BoolFlag("no" #name,                                   \
-                                 &FLAGS_no##name,                              \
-                                 &FLAGS_##name,                                \
-                                 #value,                                       \
-                                 help,                                         \
-                                 false)));
+#define DEFINE_bool(name, value, help)                                  \
+  bool FLAGS_##name = value;                                            \
+  bool FLAGS_no##name = !value;                                         \
+  chromeos::FlagHelper::GetInstance()->AddFlag(                         \
+      std::unique_ptr<chromeos::Flag>(new chromeos::BoolFlag(           \
+          #name, &FLAGS_##name, &FLAGS_no##name, #value, help, true))); \
+  chromeos::FlagHelper::GetInstance()->AddFlag(                         \
+      std::unique_ptr<chromeos::Flag>(new chromeos::BoolFlag(           \
+          "no" #name, &FLAGS_no##name, &FLAGS_##name, #value, help, false)));
 
 // The FlagHelper class is a singleton class used for registering command
 // line flags and pointers to their associated scoped variables, so that
diff --git a/chromeos/flag_helper_unittest.cc b/chromeos/flag_helper_unittest.cc
index b086df0..1c8261a 100644
--- a/chromeos/flag_helper_unittest.cc
+++ b/chromeos/flag_helper_unittest.cc
@@ -16,10 +16,8 @@
 
 class FlagHelperTest : public ::testing::Test {
  public:
-  FlagHelperTest() { }
-  ~FlagHelperTest() override {
-    chromeos::FlagHelper::ResetForTesting();
-  }
+  FlagHelperTest() {}
+  ~FlagHelperTest() override { chromeos::FlagHelper::ResetForTesting(); }
 };
 
 // Test that the DEFINE_xxxx macros can create the respective variables
@@ -86,12 +84,24 @@
   DEFINE_string(string_1, "default", "Test string flag");
   DEFINE_string(string_2, "default", "Test string flag");
 
-  const char* argv[] = {"test_program", "--bool1", "--nobool2", "--bool3=true",
-      "--bool4=false", "--int32_1=-2147483648", "--int32_2=0",
-      "--int32_3=2147483647", "--int64_1=-9223372036854775808", "--int64_2=0",
-      "--int64_3=9223372036854775807", "--uint64_1=0",
-      "--uint64_2=18446744073709551615", "--double_1=-100.5",
-      "--double_2=0", "--double_3=100.5", "--string_1=", "--string_2=value"};
+  const char* argv[] = {"test_program",
+                        "--bool1",
+                        "--nobool2",
+                        "--bool3=true",
+                        "--bool4=false",
+                        "--int32_1=-2147483648",
+                        "--int32_2=0",
+                        "--int32_3=2147483647",
+                        "--int64_1=-9223372036854775808",
+                        "--int64_2=0",
+                        "--int64_3=9223372036854775807",
+                        "--uint64_1=0",
+                        "--uint64_2=18446744073709551615",
+                        "--double_1=-100.5",
+                        "--double_2=0",
+                        "--double_3=100.5",
+                        "--string_1=",
+                        "--string_2=value"};
   CommandLine command_line(arraysize(argv), argv);
 
   chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -136,12 +146,22 @@
   DEFINE_string(string_1, "default", "Test string flag");
   DEFINE_string(string_2, "default", "Test string flag");
 
-  const char* argv[] = {"test_program", "-bool1", "-nobool2",
-      "-int32_1=-2147483648", "-int32_2=0", "-int32_3=2147483647",
-      "-int64_1=-9223372036854775808", "-int64_2=0",
-      "-int64_3=9223372036854775807", "-uint64_1=0",
-      "-uint64_2=18446744073709551615", "-double_1=-100.5",
-      "-double_2=0", "-double_3=100.5", "-string_1=", "-string_2=value"};
+  const char* argv[] = {"test_program",
+                        "-bool1",
+                        "-nobool2",
+                        "-int32_1=-2147483648",
+                        "-int32_2=0",
+                        "-int32_3=2147483647",
+                        "-int64_1=-9223372036854775808",
+                        "-int64_2=0",
+                        "-int64_3=9223372036854775807",
+                        "-uint64_1=0",
+                        "-uint64_2=18446744073709551615",
+                        "-double_1=-100.5",
+                        "-double_2=0",
+                        "-double_3=100.5",
+                        "-string_1=",
+                        "-string_2=value"};
   CommandLine command_line(arraysize(argv), argv);
 
   chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -213,24 +233,17 @@
   FILE* orig = stdout;
   stdout = stderr;
 
-  ASSERT_EXIT(chromeos::FlagHelper::Init(arraysize(argv),
-                                         argv,
-                                         "TestHelpMessage"),
-              ::testing::ExitedWithCode(EX_OK),
-              "TestHelpMessage\n\n"
-              "  --bool_1  \\(Test bool flag\\)  type: bool  default: true\n"
-              "  --double_1  \\(Test double flag\\)  type: double  "
-                  "default: 0\n"
-              "  --help  \\(Show this help message\\)  type: bool  "
-                  "default: false\n"
-              "  --int64_1  \\(Test int64 flag\\)  type: int64  "
-                  "default: 0\n"
-              "  --int_1  \\(Test int flag\\)  type: int  default: 0\n"
-              "  --string_1  \\(Test string flag\\)  type: string  "
-                  "default: \"\"\n"
-              "  --uint64_1  \\(Test uint64 flag\\)  type: uint64  "
-                  "default: 0\n"
-);
+  ASSERT_EXIT(
+      chromeos::FlagHelper::Init(arraysize(argv), argv, "TestHelpMessage"),
+      ::testing::ExitedWithCode(EX_OK),
+      "TestHelpMessage\n\n"
+      "  --bool_1  \\(Test bool flag\\)  type: bool  default: true\n"
+      "  --double_1  \\(Test double flag\\)  type: double  default: 0\n"
+      "  --help  \\(Show this help message\\)  type: bool  default: false\n"
+      "  --int64_1  \\(Test int64 flag\\)  type: int64  default: 0\n"
+      "  --int_1  \\(Test int flag\\)  type: int  default: 0\n"
+      "  --string_1  \\(Test string flag\\)  type: string  default: \"\"\n"
+      "  --uint64_1  \\(Test uint64 flag\\)  type: uint64  default: 0\n");
 
   stdout = orig;
 }
@@ -238,7 +251,7 @@
 // Test that passing in unknown command line flags causes the program
 // to exit with EX_USAGE error code and corresponding error message.
 TEST_F(FlagHelperTest, UnknownFlag) {
-  const char* argv[] = {"test_program", "--flag=value" };
+  const char* argv[] = {"test_program", "--flag=value"};
   CommandLine command_line(arraysize(argv), argv);
 
   chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -259,7 +272,7 @@
 TEST_F(FlagHelperTest, BoolParseError) {
   DEFINE_bool(bool_1, 0, "Test bool flag");
 
-  const char* argv[] = {"test_program", "--bool_1=value" };
+  const char* argv[] = {"test_program", "--bool_1=value"};
   CommandLine command_line(arraysize(argv), argv);
 
   chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -268,11 +281,10 @@
   FILE* orig = stdout;
   stdout = stderr;
 
-  ASSERT_EXIT(chromeos::FlagHelper::Init(arraysize(argv),
-                                         argv,
-                                         "TestBoolParseError"),
-              ::testing::ExitedWithCode(EX_DATAERR),
-              "ERROR: illegal value 'value' specified for bool flag 'bool_1'");
+  ASSERT_EXIT(
+      chromeos::FlagHelper::Init(arraysize(argv), argv, "TestBoolParseError"),
+      ::testing::ExitedWithCode(EX_DATAERR),
+      "ERROR: illegal value 'value' specified for bool flag 'bool_1'");
 
   stdout = orig;
 }
@@ -282,7 +294,7 @@
 TEST_F(FlagHelperTest, Int32ParseError) {
   DEFINE_int32(int_1, 0, "Test int flag");
 
-  const char* argv[] = {"test_program", "--int_1=value" };
+  const char* argv[] = {"test_program", "--int_1=value"};
   CommandLine command_line(arraysize(argv), argv);
 
   chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -314,12 +326,11 @@
   FILE* orig = stdout;
   stdout = stderr;
 
-  ASSERT_EXIT(chromeos::FlagHelper::Init(arraysize(argv),
-                                         argv,
-                                         "TestInt64ParseError"),
-              ::testing::ExitedWithCode(EX_DATAERR),
-              "ERROR: illegal value 'value' specified for int64 flag "
-              "'int64_1'");
+  ASSERT_EXIT(
+      chromeos::FlagHelper::Init(arraysize(argv), argv, "TestInt64ParseError"),
+      ::testing::ExitedWithCode(EX_DATAERR),
+      "ERROR: illegal value 'value' specified for int64 flag "
+      "'int64_1'");
 
   stdout = orig;
 }
@@ -329,7 +340,7 @@
 TEST_F(FlagHelperTest, UInt64ParseError) {
   DEFINE_uint64(uint64_1, 0, "Test uint64 flag");
 
-  const char* argv[] = {"test_program", "--uint64_1=value" };
+  const char* argv[] = {"test_program", "--uint64_1=value"};
   CommandLine command_line(arraysize(argv), argv);
 
   chromeos::FlagHelper::GetInstance()->set_command_line_for_testing(
@@ -338,12 +349,11 @@
   FILE* orig = stdout;
   stdout = stderr;
 
-  ASSERT_EXIT(chromeos::FlagHelper::Init(arraysize(argv),
-                                         argv,
-                                         "TestUInt64ParseError"),
-              ::testing::ExitedWithCode(EX_DATAERR),
-              "ERROR: illegal value 'value' specified for uint64 flag "
-              "'uint64_1'");
+  ASSERT_EXIT(
+      chromeos::FlagHelper::Init(arraysize(argv), argv, "TestUInt64ParseError"),
+      ::testing::ExitedWithCode(EX_DATAERR),
+      "ERROR: illegal value 'value' specified for uint64 flag "
+      "'uint64_1'");
 
   stdout = orig;
 }
diff --git a/chromeos/http/curl_api.h b/chromeos/http/curl_api.h
index eb47a96..0f78f22 100644
--- a/chromeos/http/curl_api.h
+++ b/chromeos/http/curl_api.h
@@ -47,8 +47,8 @@
   inline CURLcode EasySetOptCallback(CURL* curl,
                                      CURLoption option,
                                      R(*callback)(Args...)) {
-    return EasySetOptCallback(curl, option,
-                              reinterpret_cast<intptr_t>(callback));
+    return EasySetOptCallback(
+        curl, option, reinterpret_cast<intptr_t>(callback));
   }
 
   // Wrapper around curl_easy_perform().
@@ -100,9 +100,7 @@
   CURLcode EasyPerform(CURL* curl) override;
 
   // Wrappers around curl_easy_getinfo().
-  CURLcode EasyGetInfoInt(CURL* curl,
-                          CURLINFO info,
-                          int* value) const override;
+  CURLcode EasyGetInfoInt(CURL* curl, CURLINFO info, int* value) const override;
   CURLcode EasyGetInfoDbl(CURL* curl,
                           CURLINFO info,
                           double* value) const override;
diff --git a/chromeos/http/http_connection.h b/chromeos/http/http_connection.h
index fa1e7f1..750e987 100644
--- a/chromeos/http/http_connection.h
+++ b/chromeos/http/http_connection.h
@@ -52,9 +52,8 @@
   virtual bool FinishRequest(chromeos::ErrorPtr* error) = 0;
   // Send the request asynchronously and invoke the callback with the response
   // received.
-  virtual void FinishRequestAsync(
-      const SuccessCallback& success_callback,
-      const ErrorCallback& error_callback) = 0;
+  virtual void FinishRequestAsync(const SuccessCallback& success_callback,
+                                  const ErrorCallback& error_callback) = 0;
 
   // Returns the HTTP status code (e.g. 200 for success).
   virtual int GetResponseStatusCode() const = 0;
diff --git a/chromeos/http/http_connection_curl.cc b/chromeos/http/http_connection_curl.cc
index 62c9c97..766e792 100644
--- a/chromeos/http/http_connection_curl.cc
+++ b/chromeos/http/http_connection_curl.cc
@@ -13,34 +13,37 @@
 namespace http {
 namespace curl {
 
-static int curl_trace(CURL *handle, curl_infotype type,
-                      char *data, size_t size, void *userp) {
+static int curl_trace(CURL* handle,
+                      curl_infotype type,
+                      char* data,
+                      size_t size,
+                      void* userp) {
   std::string msg(data, size);
 
   switch (type) {
-  case CURLINFO_TEXT:
-    VLOG(3) << "== Info: " << msg;
-    break;
-  case CURLINFO_HEADER_OUT:
-    VLOG(3) << "=> Send headers:\n" << msg;
-    break;
-  case CURLINFO_DATA_OUT:
-    VLOG(3) << "=> Send data:\n" << msg;
-    break;
-  case CURLINFO_SSL_DATA_OUT:
-    VLOG(3) << "=> Send SSL data" << msg;
-    break;
-  case CURLINFO_HEADER_IN:
-    VLOG(3) << "<= Recv header: " << msg;
-    break;
-  case CURLINFO_DATA_IN:
-    VLOG(3) << "<= Recv data:\n" << msg;
-    break;
-  case CURLINFO_SSL_DATA_IN:
-    VLOG(3) << "<= Recv SSL data" << msg;
-    break;
-  default:
-    break;
+    case CURLINFO_TEXT:
+      VLOG(3) << "== Info: " << msg;
+      break;
+    case CURLINFO_HEADER_OUT:
+      VLOG(3) << "=> Send headers:\n" << msg;
+      break;
+    case CURLINFO_DATA_OUT:
+      VLOG(3) << "=> Send data:\n" << msg;
+      break;
+    case CURLINFO_SSL_DATA_OUT:
+      VLOG(3) << "=> Send SSL data" << msg;
+      break;
+    case CURLINFO_HEADER_IN:
+      VLOG(3) << "<= Recv header: " << msg;
+      break;
+    case CURLINFO_DATA_IN:
+      VLOG(3) << "<= Recv data:\n" << msg;
+      break;
+    case CURLINFO_SSL_DATA_IN:
+      VLOG(3) << "<= Recv SSL data" << msg;
+      break;
+    default:
+      break;
   }
   return 0;
 }
@@ -78,8 +81,8 @@
 
 void Connection::PrepareRequest() {
   if (VLOG_IS_ON(3)) {
-    curl_interface_->EasySetOptCallback(curl_handle_, CURLOPT_DEBUGFUNCTION,
-                                        &curl_trace);
+    curl_interface_->EasySetOptCallback(
+        curl_handle_, CURLOPT_DEBUGFUNCTION, &curl_trace);
     curl_interface_->EasySetOptInt(curl_handle_, CURLOPT_VERBOSE, 1);
   }
 
@@ -87,15 +90,15 @@
   uint64_t data_size =
       request_data_reader_ ? request_data_reader_->GetDataSize() : 0;
   if (method_ == request_type::kPut) {
-    curl_interface_->EasySetOptOffT(curl_handle_, CURLOPT_INFILESIZE_LARGE,
-                                    data_size);
+    curl_interface_->EasySetOptOffT(
+        curl_handle_, CURLOPT_INFILESIZE_LARGE, data_size);
   } else {
-    curl_interface_->EasySetOptOffT(curl_handle_, CURLOPT_POSTFIELDSIZE_LARGE,
-                                    data_size);
+    curl_interface_->EasySetOptOffT(
+        curl_handle_, CURLOPT_POSTFIELDSIZE_LARGE, data_size);
   }
   if (request_data_reader_) {
-    curl_interface_->EasySetOptCallback(curl_handle_, CURLOPT_READFUNCTION,
-                                        &Connection::read_callback);
+    curl_interface_->EasySetOptCallback(
+        curl_handle_, CURLOPT_READFUNCTION, &Connection::read_callback);
     curl_interface_->EasySetOptPtr(curl_handle_, CURLOPT_READDATA, this);
   }
 
@@ -107,22 +110,22 @@
       VLOG(2) << "Request header: " << header;
       header_list_ = curl_slist_append(header_list_, header.c_str());
     }
-    curl_interface_->EasySetOptPtr(curl_handle_, CURLOPT_HTTPHEADER,
-                                   header_list_);
+    curl_interface_->EasySetOptPtr(
+        curl_handle_, CURLOPT_HTTPHEADER, header_list_);
   }
 
   headers_.clear();
 
   // Set up HTTP response data.
   if (method_ != request_type::kHead) {
-    curl_interface_->EasySetOptCallback(curl_handle_, CURLOPT_WRITEFUNCTION,
-                                        &Connection::write_callback);
+    curl_interface_->EasySetOptCallback(
+        curl_handle_, CURLOPT_WRITEFUNCTION, &Connection::write_callback);
     curl_interface_->EasySetOptPtr(curl_handle_, CURLOPT_WRITEDATA, this);
   }
 
   // HTTP response headers
-  curl_interface_->EasySetOptCallback(curl_handle_, CURLOPT_HEADERFUNCTION,
-                                      &Connection::header_callback);
+  curl_interface_->EasySetOptCallback(
+      curl_handle_, CURLOPT_HEADERFUNCTION, &Connection::header_callback);
   curl_interface_->EasySetOptPtr(curl_handle_, CURLOPT_HEADERDATA, this);
 }
 
@@ -133,25 +136,24 @@
     Transport::AddCurlError(error, FROM_HERE, ret, curl_interface_.get());
   } else {
     LOG(INFO) << "Response: " << GetResponseStatusCode() << " ("
-      << GetResponseStatusText() << ")";
+              << GetResponseStatusText() << ")";
     VLOG(2) << "Response data (" << response_data_.size() << "): "
-        << std::string(reinterpret_cast<const char*>(response_data_.data()),
-                       response_data_.size());
+            << std::string(reinterpret_cast<const char*>(response_data_.data()),
+                           response_data_.size());
   }
   return (ret == CURLE_OK);
 }
 
-void Connection::FinishRequestAsync(
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
+void Connection::FinishRequestAsync(const SuccessCallback& success_callback,
+                                    const ErrorCallback& error_callback) {
   PrepareRequest();
   transport_->StartAsyncTransfer(this, success_callback, error_callback);
 }
 
 int Connection::GetResponseStatusCode() const {
   int status_code = 0;
-  curl_interface_->EasyGetInfoInt(curl_handle_, CURLINFO_RESPONSE_CODE,
-                                  &status_code);
+  curl_interface_->EasyGetInfoInt(
+      curl_handle_, CURLINFO_RESPONSE_CODE, &status_code);
   return status_code;
 }
 
@@ -187,16 +189,20 @@
   return true;
 }
 
-size_t Connection::write_callback(char* ptr, size_t size,
-                                  size_t num, void* data) {
+size_t Connection::write_callback(char* ptr,
+                                  size_t size,
+                                  size_t num,
+                                  void* data) {
   Connection* me = reinterpret_cast<Connection*>(data);
   size_t data_len = size * num;
   me->response_data_.insert(me->response_data_.end(), ptr, ptr + data_len);
   return data_len;
 }
 
-size_t Connection::read_callback(char* ptr, size_t size,
-                                 size_t num, void* data) {
+size_t Connection::read_callback(char* ptr,
+                                 size_t size,
+                                 size_t num,
+                                 void* data) {
   Connection* me = reinterpret_cast<Connection*>(data);
   size_t data_len = size * num;
 
@@ -207,8 +213,10 @@
   return success ? read_size : CURL_READFUNC_ABORT;
 }
 
-size_t Connection::header_callback(char* ptr, size_t size,
-                                   size_t num, void* data) {
+size_t Connection::header_callback(char* ptr,
+                                   size_t size,
+                                   size_t num,
+                                   void* data) {
   using chromeos::string_utils::SplitAtFirst;
   Connection* me = reinterpret_cast<Connection*>(data);
   size_t hdr_len = size * num;
diff --git a/chromeos/http/http_connection_curl.h b/chromeos/http/http_connection_curl.h
index d926237..8ac11d9 100644
--- a/chromeos/http/http_connection_curl.h
+++ b/chromeos/http/http_connection_curl.h
@@ -43,19 +43,27 @@
   std::string GetProtocolVersion() const override;
   std::string GetResponseHeader(const std::string& header_name) const override;
   uint64_t GetResponseDataSize() const override;
-  bool ReadResponseData(void* data, size_t buffer_size,
-                        size_t* size_read, chromeos::ErrorPtr* error) override;
+  bool ReadResponseData(void* data,
+                        size_t buffer_size,
+                        size_t* size_read,
+                        chromeos::ErrorPtr* error) override;
 
  protected:
   // Write data callback. Used by CURL when receiving response data.
-  CHROMEOS_PRIVATE static size_t write_callback(char* ptr, size_t size,
-                                                size_t num, void* data);
+  CHROMEOS_PRIVATE static size_t write_callback(char* ptr,
+                                                size_t size,
+                                                size_t num,
+                                                void* data);
   // Read data callback. Used by CURL when sending request body data.
-  CHROMEOS_PRIVATE static size_t read_callback(char* ptr, size_t size,
-                                               size_t num, void* data);
+  CHROMEOS_PRIVATE static size_t read_callback(char* ptr,
+                                               size_t size,
+                                               size_t num,
+                                               void* data);
   // Write header data callback. Used by CURL when receiving response headers.
-  CHROMEOS_PRIVATE static size_t header_callback(char* ptr, size_t size,
-                                                 size_t num, void* data);
+  CHROMEOS_PRIVATE static size_t header_callback(char* ptr,
+                                                 size_t size,
+                                                 size_t num,
+                                                 void* data);
 
   // Helper method to set up the |curl_handle_| with all the parameters
   // pertaining to the current connection.
diff --git a/chromeos/http/http_connection_curl_unittest.cc b/chromeos/http/http_connection_curl_unittest.cc
index 0a46450..0cbda1a 100644
--- a/chromeos/http/http_connection_curl_unittest.cc
+++ b/chromeos/http/http_connection_curl_unittest.cc
@@ -83,8 +83,8 @@
     std::vector<std::string> header_lines;
     header_lines.push_back(status_line + "\r\n");
     for (const auto& pair : response_headers) {
-      header_lines.push_back(
-          string_utils::Join(": ", pair.first, pair.second) + "\r\n");
+      header_lines.push_back(string_utils::Join(": ", pair.first, pair.second) +
+                             "\r\n");
     }
 
     for (const std::string& line : header_lines) {
@@ -103,8 +103,8 @@
     size_t pos = 0;
     size_t size_remaining = str.size();
     while (size_remaining) {
-      size_t size_written = callback(const_cast<char*>(str.data() + pos),
-                                     size_remaining, 1, connection);
+      size_t size_written = callback(
+          const_cast<char*>(str.data() + pos), size_remaining, 1, connection);
       if (size_written == CURL_WRITEFUNC_PAUSE)
         return CURLE_WRITE_ERROR;  // Shouldn't happen.
       CHECK(size_written <= size_remaining) << "Unexpected size returned";
@@ -150,8 +150,8 @@
   void SetUp() override {
     curl_api_ = std::make_shared<MockCurlInterface>();
     transport_ = std::make_shared<MockTransport>();
-    connection_ = std::make_shared<Connection>(handle_, request_type::kPost,
-                                               curl_api_, transport_);
+    connection_ = std::make_shared<Connection>(
+        handle_, request_type::kPost, curl_api_, transport_);
     performer_.connection = connection_.get();
   }
 
@@ -184,8 +184,9 @@
         .WillOnce(Return(CURLE_OK));
   }
 
-  EXPECT_CALL(*curl_api_, EasySetOptOffT(handle_, CURLOPT_POSTFIELDSIZE_LARGE,
-                                         request_data.size()))
+  EXPECT_CALL(
+      *curl_api_,
+      EasySetOptOffT(handle_, CURLOPT_POSTFIELDSIZE_LARGE, request_data.size()))
       .WillOnce(Return(CURLE_OK));
 
   EXPECT_CALL(*curl_api_, EasySetOptCallback(handle_, CURLOPT_READFUNCTION, _))
@@ -218,10 +219,10 @@
   std::string request_data{"Foo Bar Baz"};
   std::unique_ptr<MemoryDataReader> reader{new MemoryDataReader{request_data}};
   HeaderList headers{
-    {request_header::kAccept, "*/*"},
-    {request_header::kContentType, mime::text::kPlain},
-    {request_header::kContentLength, std::to_string(request_data.size())},
-    {"X-Foo", "bar"},
+      {request_header::kAccept, "*/*"},
+      {request_header::kContentType, mime::text::kPlain},
+      {request_header::kContentLength, std::to_string(request_data.size())},
+      {"X-Foo", "bar"},
   };
   EXPECT_TRUE(connection_->SetRequestData(std::move(reader), nullptr));
   EXPECT_TRUE(connection_->SendHeaders(headers, nullptr));
@@ -235,14 +236,15 @@
         .WillOnce(Return(CURLE_OK));
   }
 
-  EXPECT_CALL(*curl_api_, EasySetOptOffT(handle_, CURLOPT_POSTFIELDSIZE_LARGE,
-                                         request_data.size()))
+  EXPECT_CALL(
+      *curl_api_,
+      EasySetOptOffT(handle_, CURLOPT_POSTFIELDSIZE_LARGE, request_data.size()))
       .WillOnce(Return(CURLE_OK));
 
   EXPECT_CALL(*curl_api_, EasySetOptCallback(handle_, CURLOPT_READFUNCTION, _))
-      .WillOnce(DoAll(
-          SaveCallback<2>(&performer_, &CurlPerformer::read_callback),
-          Return(CURLE_OK)));
+      .WillOnce(
+          DoAll(SaveCallback<2>(&performer_, &CurlPerformer::read_callback),
+                Return(CURLE_OK)));
   EXPECT_CALL(*curl_api_, EasySetOptPtr(handle_, CURLOPT_READDATA, _))
       .WillOnce(Return(CURLE_OK));
 
@@ -251,17 +253,17 @@
       .WillOnce(Return(CURLE_OK));
 
   EXPECT_CALL(*curl_api_, EasySetOptCallback(handle_, CURLOPT_WRITEFUNCTION, _))
-      .WillOnce(DoAll(
-          SaveCallback<2>(&performer_, &CurlPerformer::write_callback),
-          Return(CURLE_OK)));
+      .WillOnce(
+          DoAll(SaveCallback<2>(&performer_, &CurlPerformer::write_callback),
+                Return(CURLE_OK)));
   EXPECT_CALL(*curl_api_, EasySetOptPtr(handle_, CURLOPT_WRITEDATA, _))
       .WillOnce(Return(CURLE_OK));
 
   EXPECT_CALL(*curl_api_,
               EasySetOptCallback(handle_, CURLOPT_HEADERFUNCTION, _))
-      .WillOnce(DoAll(
-          SaveCallback<2>(&performer_, &CurlPerformer::header_callback),
-          Return(CURLE_OK)));
+      .WillOnce(
+          DoAll(SaveCallback<2>(&performer_, &CurlPerformer::header_callback),
+                Return(CURLE_OK)));
   EXPECT_CALL(*curl_api_, EasySetOptPtr(handle_, CURLOPT_HEADERDATA, _))
       .WillOnce(Return(CURLE_OK));
 
@@ -274,9 +276,9 @@
   // Set up the CurlPerformer with the response data expected to be received.
   std::string response_data{"<html><body>OK</body></html>"};
   HeaderList response_headers{
-    {response_header::kContentLength, std::to_string(response_data.size())},
-    {response_header::kContentType, mime::text::kHtml},
-    {"X-Foo", "baz"},
+      {response_header::kContentLength, std::to_string(response_data.size())},
+      {response_header::kContentType, mime::text::kHtml},
+      {"X-Foo", "baz"},
   };
   performer_.status_line = "HTTP/1.1 200 OK";
   performer_.response_body = response_data;
@@ -302,8 +304,8 @@
   EXPECT_EQ(response_data.size(), connection_->GetResponseDataSize());
   char buffer[100];
   size_t size_read = 0;
-  EXPECT_TRUE(connection_->ReadResponseData(buffer, sizeof(buffer), &size_read,
-                                            nullptr));
+  EXPECT_TRUE(connection_->ReadResponseData(
+      buffer, sizeof(buffer), &size_read, nullptr));
   EXPECT_EQ(response_data, (std::string{buffer, size_read}));
 }
 
diff --git a/chromeos/http/http_connection_fake.cc b/chromeos/http/http_connection_fake.cc
index d10d242..4ab3d83 100644
--- a/chromeos/http/http_connection_fake.cc
+++ b/chromeos/http/http_connection_fake.cc
@@ -14,9 +14,10 @@
 namespace http {
 namespace fake {
 
-Connection::Connection(const std::string& url, const std::string& method,
-                       const std::shared_ptr<http::Transport>& transport) :
-    http::Connection(transport), request_(url, method) {
+Connection::Connection(const std::string& url,
+                       const std::string& method,
+                       const std::shared_ptr<http::Transport>& transport)
+    : http::Connection(transport), request_(url, method) {
   VLOG(1) << "fake::Connection created: " << method;
 }
 
@@ -39,8 +40,8 @@
 
 bool Connection::FinishRequest(chromeos::ErrorPtr* error) {
   using chromeos::string_utils::ToString;
-  request_.AddHeaders({{request_header::kContentLength,
-                      ToString(request_.GetData().size())}});
+  request_.AddHeaders(
+      {{request_header::kContentLength, ToString(request_.GetData().size())}});
   fake::Transport* transport = static_cast<fake::Transport*>(transport_.get());
   CHECK(transport) << "Expecting a fake transport";
   auto handler = transport->GetHandler(request_.GetURL(), request_.GetMethod());
@@ -56,14 +57,13 @@
   return true;
 }
 
-void Connection::FinishRequestAsync(
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
-  transport_->RunCallbackAsync(
-      FROM_HERE, base::Bind(&Connection::FinishRequestAsyncHelper,
-                            base::Unretained(this),
-                            success_callback,
-                            error_callback));
+void Connection::FinishRequestAsync(const SuccessCallback& success_callback,
+                                    const ErrorCallback& error_callback) {
+  transport_->RunCallbackAsync(FROM_HERE,
+                               base::Bind(&Connection::FinishRequestAsyncHelper,
+                                          base::Unretained(this),
+                                          success_callback,
+                                          error_callback));
 }
 
 void Connection::FinishRequestAsyncHelper(
@@ -97,8 +97,9 @@
 
 uint64_t Connection::GetResponseDataSize() const {
   // HEAD requests must not return body.
-  return (request_.GetMethod() != request_type::kHead) ?
-      response_.GetData().size() : 0;
+  return (request_.GetMethod() != request_type::kHead)
+             ? response_.GetData().size()
+             : 0;
 }
 
 bool Connection::ReadResponseData(void* data,
diff --git a/chromeos/http/http_connection_fake.h b/chromeos/http/http_connection_fake.h
index b81d473..0598859 100644
--- a/chromeos/http/http_connection_fake.h
+++ b/chromeos/http/http_connection_fake.h
@@ -20,7 +20,8 @@
 // This is a fake implementation of http::Connection for unit testing.
 class Connection : public http::Connection {
  public:
-  Connection(const std::string& url, const std::string& method,
+  Connection(const std::string& url,
+             const std::string& method,
              const std::shared_ptr<http::Transport>& transport);
   virtual ~Connection();
 
@@ -39,8 +40,10 @@
   std::string GetProtocolVersion() const override;
   std::string GetResponseHeader(const std::string& header_name) const override;
   uint64_t GetResponseDataSize() const override;
-  bool ReadResponseData(void* data, size_t buffer_size,
-                        size_t* size_read, chromeos::ErrorPtr* error) override;
+  bool ReadResponseData(void* data,
+                        size_t buffer_size,
+                        size_t* size_read,
+                        chromeos::ErrorPtr* error) override;
 
  private:
   // A helper method for FinishRequestAsync() implementation.
diff --git a/chromeos/http/http_form_data.cc b/chromeos/http/http_form_data.cc
index b1e0d16..540d279 100644
--- a/chromeos/http/http_form_data.cc
+++ b/chromeos/http/http_form_data.cc
@@ -33,7 +33,8 @@
     : name_{name},
       content_disposition_{content_disposition},
       content_type_{content_type},
-      transfer_encoding_{transfer_encoding} {}
+      transfer_encoding_{transfer_encoding} {
+}
 
 std::string FormField::GetContentDisposition() const {
   std::string disposition = content_disposition_;
@@ -48,7 +49,7 @@
 
 std::string FormField::GetContentHeader() const {
   HeaderList headers{
-    {form_header::kContentDisposition, GetContentDisposition()}
+      {form_header::kContentDisposition, GetContentDisposition()}
   };
 
   if (!content_type_.empty())
@@ -61,8 +62,8 @@
 
   std::string result;
   for (const auto& pair : headers) {
-    base::StringAppendF(&result, "%s: %s\r\n",
-                        pair.first.c_str(), pair.second.c_str());
+    base::StringAppendF(
+        &result, "%s: %s\r\n", pair.first.c_str(), pair.second.c_str());
   }
   result += "\r\n";
   return result;
@@ -72,9 +73,12 @@
                              const std::string& data,
                              const std::string& content_type,
                              const std::string& transfer_encoding)
-    : FormField{name, content_disposition::kFormData, content_type,
+    : FormField{name,
+                content_disposition::kFormData,
+                content_type,
                 transfer_encoding},
-      data_{data} {}
+      data_{data} {
+}
 
 uint64_t TextFormField::GetDataSize() const {
   return data_.GetDataSize();
@@ -93,10 +97,10 @@
                              const std::string& content_disposition,
                              const std::string& content_type,
                              const std::string& transfer_encoding)
-      : FormField{name, content_disposition, content_type, transfer_encoding},
-        file_{file.Pass()},
-        file_name_{file_name} {}
-
+    : FormField{name, content_disposition, content_type, transfer_encoding},
+      file_{file.Pass()},
+      file_name_{file_name} {
+}
 
 uint64_t FileFormField::GetDataSize() const {
   // Unfortunately base::File::GetLength() is not a const method of the class,
@@ -139,7 +143,8 @@
 MultiPartFormField::MultiPartFormField(const std::string& name,
                                        const std::string& content_type,
                                        const std::string& boundary)
-    : FormField{name, content_disposition::kFormData,
+    : FormField{name,
+                content_disposition::kFormData,
                 content_type.empty() ? mime::multipart::kMixed : content_type,
                 {}},
       boundary_{boundary} {
@@ -162,8 +167,8 @@
 }
 
 std::string MultiPartFormField::GetContentType() const {
-  return base::StringPrintf("%s; boundary=\"%s\"",
-                            content_type_.c_str(), boundary_.c_str());
+  return base::StringPrintf(
+      "%s; boundary=\"%s\"", content_type_.c_str(), boundary_.c_str());
 }
 
 bool MultiPartFormField::ReadData(void* buffer,
@@ -187,8 +192,8 @@
       std::string boundary;
       if (read_part_index_ > 0)
         boundary = "\r\n";
-      boundary += GetBoundaryStart() +
-        parts_[read_part_index_]->GetContentHeader();
+      boundary +=
+          GetBoundaryStart() + parts_[read_part_index_]->GetContentHeader();
       boundary_reader_.SetData(boundary);
     } else if (read_stage_ == ReadStage::kBoundarySetup &&
                read_part_index_ >= parts_.size()) {
@@ -207,8 +212,8 @@
       read_stage_ = ReadStage::kPart;
     } else if (read_stage_ == ReadStage::kPart) {
       // Reading the actual part data.
-      if (!parts_[read_part_index_]->ReadData(buffer, size_to_read,
-                                              size_read, error)) {
+      if (!parts_[read_part_index_]->ReadData(
+              buffer, size_to_read, size_read, error)) {
         return false;
       }
       if (*size_read > 0)
@@ -240,10 +245,12 @@
     return false;
   }
   std::string file_name = file_path.BaseName().value();
-  std::unique_ptr<FormField> file_field{
-      new FileFormField{name, file.Pass(), file_name, content_disposition,
-                        content_type, "binary" }
-  };
+  std::unique_ptr<FormField> file_field{new FileFormField{name,
+                                                          file.Pass(),
+                                                          file_name,
+                                                          content_disposition,
+                                                          content_type,
+                                                          "binary"}};
   AddCustomField(std::move(file_field));
   return true;
 }
@@ -256,17 +263,18 @@
   return base::StringPrintf("--%s--", boundary_.c_str());
 }
 
-FormData::FormData() : FormData{std::string{}} {}
+FormData::FormData() : FormData{std::string{}} {
+}
 
 FormData::FormData(const std::string& boundary)
-    : form_data_{"", mime::multipart::kFormData, boundary} {}
+    : form_data_{"", mime::multipart::kFormData, boundary} {
+}
 
 void FormData::AddCustomField(std::unique_ptr<FormField> field) {
   form_data_.AddCustomField(std::move(field));
 }
 
-void FormData::AddTextField(const std::string& name,
-                            const std::string& data) {
+void FormData::AddTextField(const std::string& name, const std::string& data) {
   form_data_.AddTextField(name, data);
 }
 
@@ -274,9 +282,8 @@
                             const base::FilePath& file_path,
                             const std::string& content_type,
                             chromeos::ErrorPtr* error) {
-  return form_data_.AddFileField(name, file_path,
-                                 content_disposition::kFormData,
-                                 content_type, error);
+  return form_data_.AddFileField(
+      name, file_path, content_disposition::kFormData, content_type, error);
 }
 
 std::string FormData::GetContentType() const {
diff --git a/chromeos/http/http_form_data.h b/chromeos/http/http_form_data.h
index ac7253c..919f02c 100644
--- a/chromeos/http/http_form_data.h
+++ b/chromeos/http/http_form_data.h
@@ -179,8 +179,7 @@
   void AddCustomField(std::unique_ptr<FormField> field);
 
   // Adds a simple text form field.
-  void AddTextField(const std::string& name,
-                    const std::string& data);
+  void AddTextField(const std::string& name, const std::string& data);
 
   // Adds a file upload form field using a file path.
   bool AddFileField(const std::string& name,
@@ -232,8 +231,7 @@
   void AddCustomField(std::unique_ptr<FormField> field);
 
   // Adds a simple text form field.
-  void AddTextField(const std::string& name,
-                    const std::string& data);
+  void AddTextField(const std::string& name, const std::string& data);
 
   // Adds a file upload form field using a file path.
   bool AddFileField(const std::string& name,
diff --git a/chromeos/http/http_form_data_unittest.cc b/chromeos/http/http_form_data_unittest.cc
index 27768ef..15b02bd 100644
--- a/chromeos/http/http_form_data_unittest.cc
+++ b/chromeos/http/http_form_data_unittest.cc
@@ -36,14 +36,17 @@
   std::string file_content{"text line1\ntext line2\n"};
   base::FilePath file_name = dir.path().Append("sample.txt");
   ASSERT_EQ(file_content.size(),
-            static_cast<size_t>(base::WriteFile(file_name, file_content.data(),
-                                                file_content.size())));
+            static_cast<size_t>(base::WriteFile(
+                file_name, file_content.data(), file_content.size())));
 
   base::File file{file_name, base::File::FLAG_READ | base::File::FLAG_OPEN};
   ASSERT_TRUE(file.IsValid());
-  FileFormField form_field{"test_file", file.Pass(), "sample.txt",
+  FileFormField form_field{"test_file",
+                           file.Pass(),
+                           "sample.txt",
                            content_disposition::kFormData,
-                           mime::text::kPlain, ""};
+                           mime::text::kPlain,
+                           ""};
   const char expected_header[] =
       "Content-Disposition: form-data; name=\"test_file\";"
       " filename=\"sample.txt\"\r\n"
@@ -64,20 +67,23 @@
   std::string file1{"text line1\ntext line2\n"};
   base::FilePath filename1 = dir.path().Append("sample.txt");
   ASSERT_EQ(file1.size(),
-            static_cast<size_t>(base::WriteFile(filename1, file1.data(),
-                                                file1.size())));
+            static_cast<size_t>(
+                base::WriteFile(filename1, file1.data(), file1.size())));
   std::string file2{"\x01\x02\x03\x04\x05"};
   base::FilePath filename2 = dir.path().Append("test.bin");
   ASSERT_EQ(file2.size(),
-            static_cast<size_t>(base::WriteFile(filename2, file2.data(),
-                                                file2.size())));
+            static_cast<size_t>(
+                base::WriteFile(filename2, file2.data(), file2.size())));
 
   MultiPartFormField form_field{"foo", mime::multipart::kFormData, "Delimiter"};
   form_field.AddTextField("name", "John Doe");
-  EXPECT_TRUE(form_field.AddFileField("file1", filename1,
+  EXPECT_TRUE(form_field.AddFileField("file1",
+                                      filename1,
                                       content_disposition::kFormData,
-                                      mime::text::kPlain, nullptr));
-  EXPECT_TRUE(form_field.AddFileField("file2", filename2,
+                                      mime::text::kPlain,
+                                      nullptr));
+  EXPECT_TRUE(form_field.AddFileField("file2",
+                                      filename2,
                                       content_disposition::kFormData,
                                       mime::application::kOctet_stream,
                                       nullptr));
@@ -146,22 +152,22 @@
   std::string file1{"text line1\ntext line2\n"};
   base::FilePath filename1 = dir.path().Append("sample.txt");
   ASSERT_EQ(file1.size(),
-            static_cast<size_t>(base::WriteFile(filename1, file1.data(),
-                                                file1.size())));
+            static_cast<size_t>(
+                base::WriteFile(filename1, file1.data(), file1.size())));
   std::string file2{"\x01\x02\x03\x04\x05"};
   base::FilePath filename2 = dir.path().Append("test.bin");
   ASSERT_EQ(file2.size(),
-            static_cast<size_t>(base::WriteFile(filename2, file2.data(),
-                                                file2.size())));
+            static_cast<size_t>(
+                base::WriteFile(filename2, file2.data(), file2.size())));
 
   FormData form_data{"boundary1"};
   form_data.AddTextField("name", "John Doe");
   std::unique_ptr<MultiPartFormField> files{
       new MultiPartFormField{"files", "", "boundary2"}};
-  EXPECT_TRUE(files->AddFileField("", filename1,
-                                  content_disposition::kFile,
-                                  mime::text::kPlain, nullptr));
-  EXPECT_TRUE(files->AddFileField("", filename2,
+  EXPECT_TRUE(files->AddFileField(
+      "", filename1, content_disposition::kFile, mime::text::kPlain, nullptr));
+  EXPECT_TRUE(files->AddFileField("",
+                                  filename2,
                                   content_disposition::kFile,
                                   mime::application::kOctet_stream,
                                   nullptr));
diff --git a/chromeos/http/http_request.cc b/chromeos/http/http_request.cc
index 40e1a14..bcc442e 100644
--- a/chromeos/http/http_request.cc
+++ b/chromeos/http/http_request.cc
@@ -103,9 +103,10 @@
 // ***********************************************************
 // ********************** Request Class **********************
 // ***********************************************************
-Request::Request(const std::string& url, const std::string& method,
-                 std::shared_ptr<Transport> transport) :
-    transport_(transport), request_url_(url), method_(method) {
+Request::Request(const std::string& url,
+                 const std::string& method,
+                 std::shared_ptr<Transport> transport)
+    : transport_(transport), request_url_(url), method_(method) {
   VLOG(1) << "http::Request created";
   if (!transport_)
     transport_ = http::Transport::CreateDefault();
@@ -180,7 +181,7 @@
   if (!SendRequestIfNeeded(error))
     return false;
   std::unique_ptr<DataReaderInterface> data_reader{
-    new MemoryDataReader{data, size}
+      new MemoryDataReader{data, size}
   };
   return connection_->SetRequestData(std::move(data_reader), error);
 }
@@ -246,23 +247,25 @@
         }
       }
       if (!ranges.empty())
-        headers.emplace_back(request_header::kRange,
-                             "bytes=" +
-                                 chromeos::string_utils::Join(',', ranges));
+        headers.emplace_back(
+            request_header::kRange,
+            "bytes=" + chromeos::string_utils::Join(',', ranges));
 
       headers.emplace_back(request_header::kAccept, GetAccept());
       if (method_ != request_type::kGet && method_ != request_type::kHead) {
         if (!content_type_.empty())
           headers.emplace_back(request_header::kContentType, content_type_);
       }
-      connection_ = transport_->CreateConnection(request_url_, method_, headers,
-                                                 user_agent_, referer_, error);
+      connection_ = transport_->CreateConnection(
+          request_url_, method_, headers, user_agent_, referer_, error);
     }
 
     if (connection_)
       return true;
   } else {
-    chromeos::Error::AddTo(error, FROM_HERE, http::kErrorDomain,
+    chromeos::Error::AddTo(error,
+                           FROM_HERE,
+                           http::kErrorDomain,
                            "response_already_received",
                            "HTTP response already received");
   }
@@ -282,8 +285,9 @@
     response_data_.reserve(size);
     uint8_t buffer[1024];
     size_t read = 0;
-    while (connection_->ReadResponseData(buffer, sizeof(buffer),
-                                         &read, nullptr) && read > 0) {
+    while (
+        connection_->ReadResponseData(buffer, sizeof(buffer), &read, nullptr) &&
+        read > 0) {
       response_data_.insert(response_data_.end(), buffer, buffer + read);
     }
   }
diff --git a/chromeos/http/http_request_unittest.cc b/chromeos/http/http_request_unittest.cc
index 84e3c91..0f5cbd8 100644
--- a/chromeos/http/http_request_unittest.cc
+++ b/chromeos/http/http_request_unittest.cc
@@ -109,8 +109,8 @@
   request.SetAccept("text/*, text/html, text/html;level=1, */*");
   request.AddHeader(request_header::kAcceptEncoding, "compress, gzip");
   request.AddHeaders({
-    {request_header::kAcceptLanguage, "da, en-gb;q=0.8, en;q=0.7"},
-    {request_header::kConnection, "close"},
+      {request_header::kAcceptLanguage, "da, en-gb;q=0.8, en;q=0.7"},
+      {request_header::kConnection, "close"},
   });
   request.AddRange(-10);
   request.AddRange(100, 200);
@@ -136,13 +136,11 @@
   EXPECT_CALL(*connection_, MockSetRequestData(ContainsStringData(req_body), _))
       .WillOnce(Return(true));
 
-  EXPECT_TRUE(request.AddRequestBody(req_body.data(), req_body.size(),
-                                     nullptr));
+  EXPECT_TRUE(
+      request.AddRequestBody(req_body.data(), req_body.size(), nullptr));
 
-  EXPECT_CALL(*connection_, FinishRequest(_))
-      .WillOnce(Return(true));
-  EXPECT_CALL(*connection_, GetResponseDataSize())
-      .WillOnce(Return(0));
+  EXPECT_CALL(*connection_, FinishRequest(_)).WillOnce(Return(true));
+  EXPECT_CALL(*connection_, GetResponseDataSize()).WillOnce(Return(0));
   EXPECT_CALL(*connection_, ReadResponseData(_, _, _, _))
       .WillOnce(DoAll(SetArgPointee<2>(0), Return(true)));
   auto resp = request.GetResponseAndBlock(nullptr);
@@ -187,8 +185,9 @@
     success_callback.Run(resp.Pass());
   };
 
-  EXPECT_CALL(*transport_, CreateConnection("http://foo.bar",
-                                            request_type::kGet, _, "", "", _))
+  EXPECT_CALL(
+      *transport_,
+      CreateConnection("http://foo.bar", request_type::kGet, _, "", "", _))
       .WillOnce(Return(connection_));
 
   EXPECT_CALL(*connection_, FinishRequestAsync(_, _))
diff --git a/chromeos/http/http_transport.h b/chromeos/http/http_transport.h
index 080db33..dad54a3 100644
--- a/chromeos/http/http_transport.h
+++ b/chromeos/http/http_transport.h
@@ -63,10 +63,9 @@
 
   // Initiates an asynchronous transfer on the given |connection|.
   // The actual implementation of an async I/O is transport-specific.
-  virtual void StartAsyncTransfer(
-      Connection* connection,
-      const SuccessCallback& success_callback,
-      const ErrorCallback& error_callback) = 0;
+  virtual void StartAsyncTransfer(Connection* connection,
+                                  const SuccessCallback& success_callback,
+                                  const ErrorCallback& error_callback) = 0;
 
   // Creates a default http::Transport (currently, using http::curl::Transport).
   static std::shared_ptr<Transport> CreateDefault();
diff --git a/chromeos/http/http_transport_curl.cc b/chromeos/http/http_transport_curl.cc
index 43f0429..e4d4713 100644
--- a/chromeos/http/http_transport_curl.cc
+++ b/chromeos/http/http_transport_curl.cc
@@ -23,8 +23,7 @@
 
 Transport::Transport(const std::shared_ptr<CurlInterface>& curl_interface,
                      scoped_refptr<base::TaskRunner> task_runner)
-    : curl_interface_{curl_interface},
-      task_runner_{task_runner} {
+    : curl_interface_{curl_interface}, task_runner_{task_runner} {
   VLOG(1) << "curl::Transport created";
 }
 
@@ -51,8 +50,11 @@
   CURL* curl_handle = curl_interface_->EasyInit();
   if (!curl_handle) {
     LOG(ERROR) << "Failed to initialize CURL";
-    chromeos::Error::AddTo(error, FROM_HERE, http::kErrorDomain,
-                           "curl_init_failed", "Failed to initialize CURL");
+    chromeos::Error::AddTo(error,
+                           FROM_HERE,
+                           http::kErrorDomain,
+                           "curl_init_failed",
+                           "Failed to initialize CURL");
     return connection;
   }
 
@@ -60,12 +62,12 @@
   CURLcode code = curl_interface_->EasySetOptStr(curl_handle, CURLOPT_URL, url);
 
   if (code == CURLE_OK && !user_agent.empty()) {
-    code = curl_interface_->EasySetOptStr(curl_handle, CURLOPT_USERAGENT,
-                                          user_agent);
+    code = curl_interface_->EasySetOptStr(
+        curl_handle, CURLOPT_USERAGENT, user_agent);
   }
   if (code == CURLE_OK && !referer.empty()) {
-    code = curl_interface_->EasySetOptStr(curl_handle, CURLOPT_REFERER,
-                                          referer);
+    code =
+        curl_interface_->EasySetOptStr(curl_handle, CURLOPT_REFERER, referer);
   }
   if (code == CURLE_OK && !proxy_.empty()) {
     code = curl_interface_->EasySetOptStr(curl_handle, CURLOPT_PROXY, proxy_);
@@ -73,7 +75,7 @@
 
   // Setup HTTP request method and optional request body.
   if (code == CURLE_OK) {
-    if (method ==  request_type::kGet) {
+    if (method == request_type::kGet) {
       code = curl_interface_->EasySetOptInt(curl_handle, CURLOPT_HTTPGET, 1);
     } else if (method == request_type::kHead) {
       code = curl_interface_->EasySetOptInt(curl_handle, CURLOPT_NOBODY, 1);
@@ -83,11 +85,11 @@
       // POST and custom request methods
       code = curl_interface_->EasySetOptInt(curl_handle, CURLOPT_POST, 1);
       if (code == CURLE_OK)
-        code = curl_interface_->EasySetOptPtr(curl_handle, CURLOPT_POSTFIELDS,
-                                              nullptr);
+        code = curl_interface_->EasySetOptPtr(
+            curl_handle, CURLOPT_POSTFIELDS, nullptr);
       if (code == CURLE_OK && method != request_type::kPost)
-        code = curl_interface_->EasySetOptStr(curl_handle,
-                                              CURLOPT_CUSTOMREQUEST, method);
+        code = curl_interface_->EasySetOptStr(
+            curl_handle, CURLOPT_CUSTOMREQUEST, method);
     }
   }
 
@@ -134,7 +136,9 @@
                              const tracked_objects::Location& location,
                              CURLcode code,
                              CurlInterface* curl_interface) {
-  chromeos::Error::AddTo(error, location, "curl_error",
+  chromeos::Error::AddTo(error,
+                         location,
+                         "curl_error",
                          chromeos::string_utils::ToString(code),
                          curl_interface->EasyStrError(code));
 }
diff --git a/chromeos/http/http_transport_curl_unittest.cc b/chromeos/http/http_transport_curl_unittest.cc
index b330182..c427bc5 100644
--- a/chromeos/http/http_transport_curl_unittest.cc
+++ b/chromeos/http/http_transport_curl_unittest.cc
@@ -49,9 +49,12 @@
       .WillOnce(Return(CURLE_OK));
   EXPECT_CALL(*curl_api_, EasySetOptInt(handle_, CURLOPT_HTTPGET, 1))
       .WillOnce(Return(CURLE_OK));
-  auto connection = transport_->CreateConnection(
-      "http://foo.bar/get", request_type::kGet, {}, "User Agent",
-      "http://foo.bar/baz", nullptr);
+  auto connection = transport_->CreateConnection("http://foo.bar/get",
+                                                 request_type::kGet,
+                                                 {},
+                                                 "User Agent",
+                                                 "http://foo.bar/baz",
+                                                 nullptr);
   EXPECT_NE(nullptr, connection.get());
 
   EXPECT_CALL(*curl_api_, EasyCleanup(handle_)).Times(1);
@@ -118,8 +121,9 @@
       .WillOnce(Return(CURLE_OK));
   EXPECT_CALL(*curl_api_, EasySetOptPtr(handle_, CURLOPT_POSTFIELDS, nullptr))
       .WillOnce(Return(CURLE_OK));
-  EXPECT_CALL(*curl_api_, EasySetOptStr(handle_, CURLOPT_CUSTOMREQUEST,
-                                        request_type::kPatch))
+  EXPECT_CALL(
+      *curl_api_,
+      EasySetOptStr(handle_, CURLOPT_CUSTOMREQUEST, request_type::kPatch))
       .WillOnce(Return(CURLE_OK));
   auto connection = transport_->CreateConnection(
       "http://www.foo.bar/patch", request_type::kPatch, {}, "", "", nullptr);
diff --git a/chromeos/http/http_transport_fake.cc b/chromeos/http/http_transport_fake.cc
index aa8e429..4ef4080 100644
--- a/chromeos/http/http_transport_fake.cc
+++ b/chromeos/http/http_transport_fake.cc
@@ -46,12 +46,12 @@
   }
   HeaderList headers_copy = headers;
   if (!user_agent.empty()) {
-    headers_copy.push_back(std::make_pair(http::request_header::kUserAgent,
-                                          user_agent));
+    headers_copy.push_back(
+        std::make_pair(http::request_header::kUserAgent, user_agent));
   }
   if (!referer.empty()) {
-    headers_copy.push_back(std::make_pair(http::request_header::kReferer,
-                                          referer));
+    headers_copy.push_back(
+        std::make_pair(http::request_header::kReferer, referer));
   }
   connection =
       std::make_shared<http::fake::Connection>(url, method, shared_from_this());
@@ -79,7 +79,8 @@
   return method + ":" + url;
 }
 
-void Transport::AddHandler(const std::string& url, const std::string& method,
+void Transport::AddHandler(const std::string& url,
+                           const std::string& method,
                            const HandlerCallback& handler) {
   handlers_.insert(std::make_pair(GetHandlerMapKey(url, method), handler));
 }
@@ -97,7 +98,8 @@
 }
 
 Transport::HandlerCallback Transport::GetHandler(
-    const std::string& url, const std::string& method) const {
+    const std::string& url,
+    const std::string& method) const {
   // First try the exact combination of URL/Method
   auto p = handlers_.find(GetHandlerMapKey(url, method));
   if (p != handlers_.end())
@@ -137,7 +139,7 @@
 }
 
 std::unique_ptr<base::DictionaryValue>
-    ServerRequestResponseBase::GetDataAsJson() const {
+ServerRequestResponseBase::GetDataAsJson() const {
   if (chromeos::mime::RemoveParameters(
           GetHeader(request_header::kContentType)) ==
       chromeos::mime::application::kJson) {
@@ -169,8 +171,8 @@
   return p != headers_.end() ? p->second : std::string();
 }
 
-ServerRequest::ServerRequest(const std::string& url,
-                             const std::string& method) : method_(method) {
+ServerRequest::ServerRequest(const std::string& url, const std::string& method)
+    : method_(method) {
   auto params = chromeos::url::GetQueryStringParameters(url);
   url_ = chromeos::url::RemoveQueryString(url, true);
   form_fields_.insert(params.begin(), params.end());
@@ -199,11 +201,9 @@
   status_code_ = status_code;
   SetData(std::unique_ptr<DataReaderInterface>{
       new MemoryDataReader{data, data_size}});
-  AddHeaders({
-    {response_header::kContentLength,
-        chromeos::string_utils::ToString(data_size)},
-    {response_header::kContentType, mime_type}
-  });
+  AddHeaders({{response_header::kContentLength,
+               chromeos::string_utils::ToString(data_size)},
+              {response_header::kContentType, mime_type}});
 }
 
 void ServerResponse::ReplyText(int status_code,
@@ -214,13 +214,12 @@
 
 void ServerResponse::ReplyJson(int status_code, const base::Value* json) {
   std::string text;
-  base::JSONWriter::WriteWithOptions(json,
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &text);
-  std::string mime_type = chromeos::mime::AppendParameter(
-      chromeos::mime::application::kJson,
-      chromeos::mime::parameters::kCharset,
-      "utf-8");
+  base::JSONWriter::WriteWithOptions(
+      json, base::JSONWriter::OPTIONS_PRETTY_PRINT, &text);
+  std::string mime_type =
+      chromeos::mime::AppendParameter(chromeos::mime::application::kJson,
+                                      chromeos::mime::parameters::kCharset,
+                                      "utf-8");
   ReplyText(status_code, text, mime_type);
 }
 
@@ -235,52 +234,52 @@
 
 std::string ServerResponse::GetStatusText() const {
   static std::vector<std::pair<int, const char*>> status_text_map = {
-    {100, "Continue"},
-    {101, "Switching Protocols"},
-    {102, "Processing"},
-    {200, "OK"},
-    {201, "Created"},
-    {202, "Accepted"},
-    {203, "Non-Authoritative Information"},
-    {204, "No Content"},
-    {205, "Reset Content"},
-    {206, "Partial Content"},
-    {207, "Multi-Status"},
-    {208, "Already Reported"},
-    {226, "IM Used"},
-    {300, "Multiple Choices"},
-    {301, "Moved Permanently"},
-    {302, "Found"},
-    {303, "See Other"},
-    {304, "Not Modified"},
-    {305, "Use Proxy"},
-    {306, "Switch Proxy"},
-    {307, "Temporary Redirect"},
-    {308, "Permanent Redirect"},
-    {400, "Bad Request"},
-    {401, "Unauthorized"},
-    {402, "Payment Required"},
-    {403, "Forbidden"},
-    {404, "Not Found"},
-    {405, "Method Not Allowed"},
-    {406, "Not Acceptable"},
-    {407, "Proxy Authentication Required"},
-    {408, "Request Timeout"},
-    {409, "Conflict"},
-    {410, "Gone"},
-    {411, "Length Required"},
-    {412, "Precondition Failed"},
-    {413, "Request Entity Too Large"},
-    {414, "Request - URI Too Long"},
-    {415, "Unsupported Media Type"},
-    {429, "Too Many Requests"},
-    {431, "Request Header Fields Too Large"},
-    {500, "Internal Server Error"},
-    {501, "Not Implemented"},
-    {502, "Bad Gateway"},
-    {503, "Service Unavailable"},
-    {504, "Gateway Timeout"},
-    {505, "HTTP Version Not Supported"},
+      {100, "Continue"},
+      {101, "Switching Protocols"},
+      {102, "Processing"},
+      {200, "OK"},
+      {201, "Created"},
+      {202, "Accepted"},
+      {203, "Non-Authoritative Information"},
+      {204, "No Content"},
+      {205, "Reset Content"},
+      {206, "Partial Content"},
+      {207, "Multi-Status"},
+      {208, "Already Reported"},
+      {226, "IM Used"},
+      {300, "Multiple Choices"},
+      {301, "Moved Permanently"},
+      {302, "Found"},
+      {303, "See Other"},
+      {304, "Not Modified"},
+      {305, "Use Proxy"},
+      {306, "Switch Proxy"},
+      {307, "Temporary Redirect"},
+      {308, "Permanent Redirect"},
+      {400, "Bad Request"},
+      {401, "Unauthorized"},
+      {402, "Payment Required"},
+      {403, "Forbidden"},
+      {404, "Not Found"},
+      {405, "Method Not Allowed"},
+      {406, "Not Acceptable"},
+      {407, "Proxy Authentication Required"},
+      {408, "Request Timeout"},
+      {409, "Conflict"},
+      {410, "Gone"},
+      {411, "Length Required"},
+      {412, "Precondition Failed"},
+      {413, "Request Entity Too Large"},
+      {414, "Request - URI Too Long"},
+      {415, "Unsupported Media Type"},
+      {429, "Too Many Requests"},
+      {431, "Request Header Fields Too Large"},
+      {500, "Internal Server Error"},
+      {501, "Not Implemented"},
+      {502, "Bad Gateway"},
+      {503, "Service Unavailable"},
+      {504, "Gateway Timeout"},
+      {505, "HTTP Version Not Supported"},
   };
 
   for (const auto& pair : status_text_map) {
diff --git a/chromeos/http/http_transport_fake.h b/chromeos/http/http_transport_fake.h
index ee6022a..20fed83 100644
--- a/chromeos/http/http_transport_fake.h
+++ b/chromeos/http/http_transport_fake.h
@@ -175,10 +175,13 @@
   ServerResponse() = default;
 
   // Generic reply method.
-  void Reply(int status_code, const void* data, size_t data_size,
+  void Reply(int status_code,
+             const void* data,
+             size_t data_size,
              const std::string& mime_type);
   // Reply with text body.
-  void ReplyText(int status_code, const std::string& text,
+  void ReplyText(int status_code,
+                 const std::string& text,
                  const std::string& mime_type);
   // Reply with JSON object. The content type will be "application/json".
   void ReplyJson(int status_code, const base::Value* json);
@@ -190,7 +193,8 @@
   // data elements. Only trivial data types (scalars, POD structures, etc)
   // can be used.
   template<typename T>
-  void Reply(int status_code, const std::vector<T>& data,
+  void Reply(int status_code,
+             const std::vector<T>& data,
              const std::string& mime_type) {
     // Make sure T doesn't have virtual functions, custom constructors, etc.
     static_assert(std::is_trivial<T>::value, "Only simple data is supported");
diff --git a/chromeos/http/http_utils.cc b/chromeos/http/http_utils.cc
index 0cecbf8..6d93b5d 100644
--- a/chromeos/http/http_utils.cc
+++ b/chromeos/http/http_utils.cc
@@ -32,8 +32,8 @@
                                       const HeaderList& headers,
                                       std::shared_ptr<Transport> transport,
                                       chromeos::ErrorPtr* error) {
-  return SendRequestWithNoDataAndBlock(request_type::kGet, url, headers,
-                                       transport, error);
+  return SendRequestWithNoDataAndBlock(
+      request_type::kGet, url, headers, transport, error);
 }
 
 void Get(const std::string& url,
@@ -41,8 +41,12 @@
          std::shared_ptr<Transport> transport,
          const SuccessCallback& success_callback,
          const ErrorCallback& error_callback) {
-  SendRequestWithNoData(request_type::kGet, url, headers, transport,
-                        success_callback, error_callback);
+  SendRequestWithNoData(request_type::kGet,
+                        url,
+                        headers,
+                        transport,
+                        success_callback,
+                        error_callback);
 }
 
 std::string GetAsStringAndBlock(const std::string& url,
@@ -59,7 +63,9 @@
     std::shared_ptr<Transport> transport,
     const base::Callback<void(const std::string&)>& success_callback,
     const ErrorCallback& error_callback) {
-  Get(url, headers, transport,
+  Get(url,
+      headers,
+      transport,
       base::Bind(SuccessCallbackStringWrapper, success_callback),
       error_callback);
 }
@@ -67,16 +73,20 @@
 std::unique_ptr<Response> HeadAndBlock(const std::string& url,
                                        std::shared_ptr<Transport> transport,
                                        chromeos::ErrorPtr* error) {
-  return SendRequestWithNoDataAndBlock(request_type::kHead, url, {}, transport,
-                                       error);
+  return SendRequestWithNoDataAndBlock(
+      request_type::kHead, url, {}, transport, error);
 }
 
 void Head(const std::string& url,
           std::shared_ptr<Transport> transport,
           const SuccessCallback& success_callback,
           const ErrorCallback& error_callback) {
-  SendRequestWithNoData(request_type::kHead, url, {}, transport,
-                        success_callback, error_callback);
+  SendRequestWithNoData(request_type::kHead,
+                        url,
+                        {},
+                        transport,
+                        success_callback,
+                        error_callback);
 }
 
 std::unique_ptr<Response> PostTextAndBlock(const std::string& url,
@@ -85,8 +95,8 @@
                                            const HeaderList& headers,
                                            std::shared_ptr<Transport> transport,
                                            chromeos::ErrorPtr* error) {
-  return PostBinaryAndBlock(url, data.data(), data.size(), mime_type, headers,
-                            transport, error);
+  return PostBinaryAndBlock(
+      url, data.data(), data.size(), mime_type, headers, transport, error);
 }
 
 void PostText(const std::string& url,
@@ -96,8 +106,14 @@
               std::shared_ptr<Transport> transport,
               const SuccessCallback& success_callback,
               const ErrorCallback& error_callback) {
-  PostBinary(url, data.data(), data.size(), mime_type, headers, transport,
-             success_callback, error_callback);
+  PostBinary(url,
+             data.data(),
+             data.size(),
+             mime_type,
+             headers,
+             transport,
+             success_callback,
+             error_callback);
 }
 
 std::unique_ptr<Response> SendRequestAndBlock(
@@ -127,19 +143,18 @@
     const HeaderList& headers,
     std::shared_ptr<Transport> transport,
     chromeos::ErrorPtr* error) {
-  return SendRequestAndBlock(method, url, nullptr, 0, {}, headers, transport,
-                             error);
+  return SendRequestAndBlock(
+      method, url, nullptr, 0, {}, headers, transport, error);
 }
 
-void SendRequest(
-    const std::string& method,
-    const std::string& url,
-    std::unique_ptr<DataReaderInterface> data_reader,
-    const std::string& mime_type,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
+void SendRequest(const std::string& method,
+                 const std::string& url,
+                 std::unique_ptr<DataReaderInterface> data_reader,
+                 const std::string& mime_type,
+                 const HeaderList& headers,
+                 std::shared_ptr<Transport> transport,
+                 const SuccessCallback& success_callback,
+                 const ErrorCallback& error_callback) {
   Request request(url, method, transport);
   request.AddHeaders(headers);
   if (data_reader && data_reader->GetDataSize() > 0) {
@@ -148,40 +163,48 @@
     request.SetContentType(mime_type);
     chromeos::ErrorPtr error;
     if (!request.AddRequestBody(std::move(data_reader), &error)) {
-      transport->RunCallbackAsync(FROM_HERE,
-                                  base::Bind(error_callback,
-                                             base::Owned(error.release())));
+      transport->RunCallbackAsync(
+          FROM_HERE, base::Bind(error_callback, base::Owned(error.release())));
       return;
     }
   }
   request.GetResponse(success_callback, error_callback);
 }
 
-void SendRequest(
-    const std::string& method,
-    const std::string& url,
-    const void* data,
-    size_t data_size,
-    const std::string& mime_type,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
+void SendRequest(const std::string& method,
+                 const std::string& url,
+                 const void* data,
+                 size_t data_size,
+                 const std::string& mime_type,
+                 const HeaderList& headers,
+                 std::shared_ptr<Transport> transport,
+                 const SuccessCallback& success_callback,
+                 const ErrorCallback& error_callback) {
   std::unique_ptr<DataReaderInterface> data_reader{
-    new MemoryDataReader(data, data_size)
-  };
-  SendRequest(method, url, std::move(data_reader), mime_type, headers,
-              transport, success_callback, error_callback);
+      new MemoryDataReader(data, data_size)};
+  SendRequest(method,
+              url,
+              std::move(data_reader),
+              mime_type,
+              headers,
+              transport,
+              success_callback,
+              error_callback);
 }
 
-void SendRequestWithNoData(
-    const std::string& method,
-    const std::string& url,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
-  SendRequest(method, url, {}, {}, headers, transport, success_callback,
+void SendRequestWithNoData(const std::string& method,
+                           const std::string& url,
+                           const HeaderList& headers,
+                           std::shared_ptr<Transport> transport,
+                           const SuccessCallback& success_callback,
+                           const ErrorCallback& error_callback) {
+  SendRequest(method,
+              url,
+              {},
+              {},
+              headers,
+              transport,
+              success_callback,
               error_callback);
 }
 
@@ -193,33 +216,50 @@
     const HeaderList& headers,
     std::shared_ptr<Transport> transport,
     chromeos::ErrorPtr* error) {
-  return SendRequestAndBlock(request_type::kPost, url, data, data_size,
-                             mime_type, headers, transport, error);
+  return SendRequestAndBlock(request_type::kPost,
+                             url,
+                             data,
+                             data_size,
+                             mime_type,
+                             headers,
+                             transport,
+                             error);
 }
 
-void PostBinary(
-    const std::string& url,
-    std::unique_ptr<DataReaderInterface> data_reader,
-    const std::string& mime_type,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
-  SendRequest(request_type::kPost, url, std::move(data_reader), mime_type,
-              headers, transport, success_callback, error_callback);
+void PostBinary(const std::string& url,
+                std::unique_ptr<DataReaderInterface> data_reader,
+                const std::string& mime_type,
+                const HeaderList& headers,
+                std::shared_ptr<Transport> transport,
+                const SuccessCallback& success_callback,
+                const ErrorCallback& error_callback) {
+  SendRequest(request_type::kPost,
+              url,
+              std::move(data_reader),
+              mime_type,
+              headers,
+              transport,
+              success_callback,
+              error_callback);
 }
 
-void PostBinary(
-    const std::string& url,
-    const void* data,
-    size_t data_size,
-    const std::string& mime_type,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
-  SendRequest(request_type::kPost, url, data, data_size, mime_type,
-              headers, transport, success_callback, error_callback);
+void PostBinary(const std::string& url,
+                const void* data,
+                size_t data_size,
+                const std::string& mime_type,
+                const HeaderList& headers,
+                std::shared_ptr<Transport> transport,
+                const SuccessCallback& success_callback,
+                const ErrorCallback& error_callback) {
+  SendRequest(request_type::kPost,
+              url,
+              data,
+              data_size,
+              mime_type,
+              headers,
+              transport,
+              success_callback,
+              error_callback);
 }
 
 std::unique_ptr<Response> PostFormDataAndBlock(
@@ -229,9 +269,13 @@
     std::shared_ptr<Transport> transport,
     chromeos::ErrorPtr* error) {
   std::string encoded_data = chromeos::data_encoding::WebParamsEncode(data);
-  return PostBinaryAndBlock(url, encoded_data.c_str(), encoded_data.size(),
+  return PostBinaryAndBlock(url,
+                            encoded_data.c_str(),
+                            encoded_data.size(),
                             chromeos::mime::application::kWwwFormUrlEncoded,
-                            headers, transport, error);
+                            headers,
+                            transport,
+                            error);
 }
 
 std::unique_ptr<Response> PostFormDataAndBlock(
@@ -247,69 +291,75 @@
   return request.GetResponseAndBlock(error);
 }
 
-void PostFormData(
-    const std::string& url,
-    const FormFieldList& data,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
+void PostFormData(const std::string& url,
+                  const FormFieldList& data,
+                  const HeaderList& headers,
+                  std::shared_ptr<Transport> transport,
+                  const SuccessCallback& success_callback,
+                  const ErrorCallback& error_callback) {
   std::string encoded_data = chromeos::data_encoding::WebParamsEncode(data);
-  return PostBinary(url, encoded_data.c_str(), encoded_data.size(),
+  return PostBinary(url,
+                    encoded_data.c_str(),
+                    encoded_data.size(),
                     chromeos::mime::application::kWwwFormUrlEncoded,
-                    headers, transport, success_callback, error_callback);
+                    headers,
+                    transport,
+                    success_callback,
+                    error_callback);
 }
 
-void PostFormData(
-    const std::string& url,
-    std::unique_ptr<FormData> form_data,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
+void PostFormData(const std::string& url,
+                  std::unique_ptr<FormData> form_data,
+                  const HeaderList& headers,
+                  std::shared_ptr<Transport> transport,
+                  const SuccessCallback& success_callback,
+                  const ErrorCallback& error_callback) {
   Request request(url, request_type::kPost, transport);
   request.AddHeaders(headers);
   chromeos::ErrorPtr error;
   if (!request.AddRequestBodyAsFormData(std::move(form_data), &error)) {
-    transport->RunCallbackAsync(FROM_HERE,
-                                base::Bind(error_callback,
-                                            base::Owned(error.release())));
+    transport->RunCallbackAsync(
+        FROM_HERE, base::Bind(error_callback, base::Owned(error.release())));
     return;
   }
   request.GetResponse(success_callback, error_callback);
 }
 
-std::unique_ptr<Response> PostJsonAndBlock(
-    const std::string& url,
-    const base::Value* json,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    chromeos::ErrorPtr* error) {
+std::unique_ptr<Response> PostJsonAndBlock(const std::string& url,
+                                           const base::Value* json,
+                                           const HeaderList& headers,
+                                           std::shared_ptr<Transport> transport,
+                                           chromeos::ErrorPtr* error) {
   std::string data;
   if (json)
     base::JSONWriter::Write(json, &data);
   std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
                                           chromeos::mime::parameters::kCharset,
                                           "utf-8");
-  return PostBinaryAndBlock(url, data.c_str(), data.size(),
-                            mime_type, headers, transport, error);
+  return PostBinaryAndBlock(
+      url, data.c_str(), data.size(), mime_type, headers, transport, error);
 }
 
-void PostJson(
-    const std::string& url,
-    std::unique_ptr<base::Value> json,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
+void PostJson(const std::string& url,
+              std::unique_ptr<base::Value> json,
+              const HeaderList& headers,
+              std::shared_ptr<Transport> transport,
+              const SuccessCallback& success_callback,
+              const ErrorCallback& error_callback) {
   std::string data;
   if (json)
     base::JSONWriter::Write(json.get(), &data);
   std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
                                           chromeos::mime::parameters::kCharset,
                                           "utf-8");
-  PostBinary(url, data.c_str(), data.size(), mime_type, headers, transport,
-             success_callback, error_callback);
+  PostBinary(url,
+             data.c_str(),
+             data.size(),
+             mime_type,
+             headers,
+             transport,
+             success_callback,
+             error_callback);
 }
 
 std::unique_ptr<Response> PatchJsonAndBlock(
@@ -324,30 +374,43 @@
   std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
                                           chromeos::mime::parameters::kCharset,
                                           "utf-8");
-  return SendRequestAndBlock(request_type::kPatch, url, data.c_str(),
-                             data.size(), mime_type, headers, transport, error);
+  return SendRequestAndBlock(request_type::kPatch,
+                             url,
+                             data.c_str(),
+                             data.size(),
+                             mime_type,
+                             headers,
+                             transport,
+                             error);
 }
 
-void PatchJson(
-    const std::string& url,
-    std::unique_ptr<base::Value> json,
-    const HeaderList& headers,
-    std::shared_ptr<Transport> transport,
-    const SuccessCallback& success_callback,
-    const ErrorCallback& error_callback) {
+void PatchJson(const std::string& url,
+               std::unique_ptr<base::Value> json,
+               const HeaderList& headers,
+               std::shared_ptr<Transport> transport,
+               const SuccessCallback& success_callback,
+               const ErrorCallback& error_callback) {
   std::string data;
   if (json)
     base::JSONWriter::Write(json.get(), &data);
   std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
                                           chromeos::mime::parameters::kCharset,
                                           "utf-8");
-  SendRequest(request_type::kPatch, url, data.c_str(), data.size(),
-              mime_type, headers, transport,
-              success_callback, error_callback);
+  SendRequest(request_type::kPatch,
+              url,
+              data.c_str(),
+              data.size(),
+              mime_type,
+              headers,
+              transport,
+              success_callback,
+              error_callback);
 }
 
 std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
-    const Response* response, int* status_code, chromeos::ErrorPtr* error) {
+    const Response* response,
+    int* status_code,
+    chromeos::ErrorPtr* error) {
   if (!response)
     return std::unique_ptr<base::DictionaryValue>();
 
@@ -359,7 +422,9 @@
   auto content_type = RemoveParameters(response->GetContentType());
   if (content_type != chromeos::mime::application::kJson &&
       content_type != chromeos::mime::text::kPlain) {
-    chromeos::Error::AddTo(error, FROM_HERE, chromeos::errors::json::kDomain,
+    chromeos::Error::AddTo(error,
+                           FROM_HERE,
+                           chromeos::errors::json::kDomain,
                            "non_json_content_type",
                            "Unexpected response content type: " + content_type);
     return std::unique_ptr<base::DictionaryValue>();
@@ -370,14 +435,19 @@
   base::Value* value = base::JSONReader::ReadAndReturnError(
       json, base::JSON_PARSE_RFC, nullptr, &error_message);
   if (!value) {
-    chromeos::Error::AddTo(error, FROM_HERE, chromeos::errors::json::kDomain,
-                           chromeos::errors::json::kParseError, error_message);
+    chromeos::Error::AddTo(error,
+                           FROM_HERE,
+                           chromeos::errors::json::kDomain,
+                           chromeos::errors::json::kParseError,
+                           error_message);
     return std::unique_ptr<base::DictionaryValue>();
   }
   base::DictionaryValue* dict_value = nullptr;
   if (!value->GetAsDictionary(&dict_value)) {
     delete value;
-    chromeos::Error::AddTo(error, FROM_HERE, chromeos::errors::json::kDomain,
+    chromeos::Error::AddTo(error,
+                           FROM_HERE,
+                           chromeos::errors::json::kDomain,
                            chromeos::errors::json::kObjectExpected,
                            "Response is not a valid JSON object");
     return std::unique_ptr<base::DictionaryValue>();
diff --git a/chromeos/http/http_utils_unittest.cc b/chromeos/http/http_utils_unittest.cc
index 590bd02..1b6abbb 100644
--- a/chromeos/http/http_utils_unittest.cc
+++ b/chromeos/http/http_utils_unittest.cc
@@ -25,28 +25,35 @@
 // Returns the request data back with the same content type.
 static void EchoDataHandler(const fake::ServerRequest& request,
                             fake::ServerResponse* response) {
-  response->Reply(status_code::Ok, request.GetData(),
+  response->Reply(status_code::Ok,
+                  request.GetData(),
                   request.GetHeader(request_header::kContentType));
 }
 
 // Returns the request method as a plain text response.
 static void EchoMethodHandler(const fake::ServerRequest& request,
                               fake::ServerResponse* response) {
-  response->ReplyText(status_code::Ok, request.GetMethod(),
-                      chromeos::mime::text::kPlain);
+  response->ReplyText(
+      status_code::Ok, request.GetMethod(), chromeos::mime::text::kPlain);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 TEST(HttpUtils, SendRequest_BinaryData) {
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kEchoUrl, request_type::kPost,
-                        base::Bind(EchoDataHandler));
+  transport->AddHandler(
+      kEchoUrl, request_type::kPost, base::Bind(EchoDataHandler));
 
   // Test binary data round-tripping.
   std::vector<uint8_t> custom_data{0xFF, 0x00, 0x80, 0x40, 0xC0, 0x7F};
-  auto response = http::SendRequestAndBlock(
-      request_type::kPost, kEchoUrl, custom_data.data(), custom_data.size(),
-      chromeos::mime::application::kOctet_stream, {}, transport, nullptr);
+  auto response =
+      http::SendRequestAndBlock(request_type::kPost,
+                                kEchoUrl,
+                                custom_data.data(),
+                                custom_data.size(),
+                                chromeos::mime::application::kOctet_stream,
+                                {},
+                                transport,
+                                nullptr);
   EXPECT_TRUE(response->IsSuccessful());
   EXPECT_EQ(chromeos::mime::application::kOctet_stream,
             response->GetContentType());
@@ -56,8 +63,8 @@
 
 TEST(HttpUtils, SendRequestAsync_BinaryData) {
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kEchoUrl, request_type::kPost,
-                        base::Bind(EchoDataHandler));
+  transport->AddHandler(
+      kEchoUrl, request_type::kPost, base::Bind(EchoDataHandler));
 
   // Test binary data round-tripping.
   std::vector<uint8_t> custom_data{0xFF, 0x00, 0x80, 0x40, 0xC0, 0x7F};
@@ -71,10 +78,15 @@
   auto error_callback = [](const Error* error) {
     FAIL() << "This callback shouldn't have been called";
   };
-  http::SendRequest(
-      request_type::kPost, kEchoUrl, custom_data.data(), custom_data.size(),
-      chromeos::mime::application::kOctet_stream, {}, transport,
-      base::Bind(success_callback), base::Bind(error_callback));
+  http::SendRequest(request_type::kPost,
+                    kEchoUrl,
+                    custom_data.data(),
+                    custom_data.size(),
+                    chromeos::mime::application::kOctet_stream,
+                    {},
+                    transport,
+                    base::Bind(success_callback),
+                    base::Bind(error_callback));
 }
 
 TEST(HttpUtils, SendRequest_Post) {
@@ -85,10 +97,15 @@
   std::vector<uint8_t> custom_data{0xFF, 0x00, 0x80, 0x40, 0xC0, 0x7F};
 
   // Check the correct HTTP method used.
-  auto response = http::SendRequestAndBlock(
-      request_type::kPost, kMethodEchoUrl, custom_data.data(),
-      custom_data.size(), chromeos::mime::application::kOctet_stream, {},
-      transport, nullptr);
+  auto response =
+      http::SendRequestAndBlock(request_type::kPost,
+                                kMethodEchoUrl,
+                                custom_data.data(),
+                                custom_data.size(),
+                                chromeos::mime::application::kOctet_stream,
+                                {},
+                                transport,
+                                nullptr);
   EXPECT_TRUE(response->IsSuccessful());
   EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
   EXPECT_EQ(request_type::kPost, response->GetDataAsString());
@@ -98,9 +115,14 @@
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
   transport->AddHandler(kMethodEchoUrl, "*", base::Bind(EchoMethodHandler));
 
-  auto response = http::SendRequestAndBlock(
-      request_type::kGet, kMethodEchoUrl, nullptr, 0, std::string{}, {},
-      transport, nullptr);
+  auto response = http::SendRequestAndBlock(request_type::kGet,
+                                            kMethodEchoUrl,
+                                            nullptr,
+                                            0,
+                                            std::string{},
+                                            {},
+                                            transport,
+                                            nullptr);
   EXPECT_TRUE(response->IsSuccessful());
   EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
   EXPECT_EQ(request_type::kGet, response->GetDataAsString());
@@ -110,9 +132,14 @@
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
   transport->AddHandler(kMethodEchoUrl, "*", base::Bind(EchoMethodHandler));
 
-  auto response = http::SendRequestAndBlock(
-      request_type::kPut, kMethodEchoUrl, nullptr, 0, std::string{}, {},
-      transport, nullptr);
+  auto response = http::SendRequestAndBlock(request_type::kPut,
+                                            kMethodEchoUrl,
+                                            nullptr,
+                                            0,
+                                            std::string{},
+                                            {},
+                                            transport,
+                                            nullptr);
   EXPECT_TRUE(response->IsSuccessful());
   EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
   EXPECT_EQ(request_type::kPut, response->GetDataAsString());
@@ -137,17 +164,20 @@
   auto error_callback = [](const Error* error) {
     FAIL() << "This callback shouldn't have been called";
   };
-  http::SendRequestWithNoData(
-      request_type::kGet, "http://blah.com", {}, transport,
-      base::Bind(success_callback), base::Bind(error_callback));
+  http::SendRequestWithNoData(request_type::kGet,
+                              "http://blah.com",
+                              {},
+                              transport,
+                              base::Bind(success_callback),
+                              base::Bind(error_callback));
 }
 
 TEST(HttpUtils, SendRequest_Headers) {
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
 
   static const char json_echo_url[] = "http://localhost/echo/json";
-  auto JsonEchoHandler = [](const fake::ServerRequest& request,
-                            fake::ServerResponse* response) {
+  auto JsonEchoHandler =
+      [](const fake::ServerRequest& request, fake::ServerResponse* response) {
     base::DictionaryValue json;
     json.SetString("method", request.GetMethod());
     json.SetString("data", request.GetDataAsString());
@@ -156,8 +186,7 @@
     }
     response->ReplyJson(status_code::Ok, &json);
   };
-  transport->AddHandler(json_echo_url, "*",
-                        base::Bind(JsonEchoHandler));
+  transport->AddHandler(json_echo_url, "*", base::Bind(JsonEchoHandler));
   auto response = http::SendRequestAndBlock(
       request_type::kPost, json_echo_url, "abcd", 4,
       chromeos::mime::application::kOctet_stream, {
@@ -187,12 +216,13 @@
   // Sends back the "?test=..." portion of URL.
   // So if we do GET "http://localhost?test=blah", this handler responds
   // with "blah" as text/plain.
-  auto GetHandler = [](const fake::ServerRequest& request,
-                       fake::ServerResponse* response) {
+  auto GetHandler =
+      [](const fake::ServerRequest& request, fake::ServerResponse* response) {
     EXPECT_EQ(request_type::kGet, request.GetMethod());
     EXPECT_EQ("0", request.GetHeader(request_header::kContentLength));
     EXPECT_EQ("", request.GetHeader(request_header::kContentType));
-    response->ReplyText(status_code::Ok, request.GetFormField("test"),
+    response->ReplyText(status_code::Ok,
+                        request.GetFormField("test"),
                         chromeos::mime::text::kPlain);
   };
 
@@ -215,13 +245,12 @@
 }
 
 TEST(HttpUtils, Head) {
-  auto HeadHandler = [](const fake::ServerRequest& request,
-                        fake::ServerResponse* response) {
+  auto HeadHandler =
+      [](const fake::ServerRequest& request, fake::ServerResponse* response) {
     EXPECT_EQ(request_type::kHead, request.GetMethod());
     EXPECT_EQ("0", request.GetHeader(request_header::kContentLength));
     EXPECT_EQ("", request.GetHeader(request_header::kContentType));
-    response->ReplyText(status_code::Ok, "blah",
-                        chromeos::mime::text::kPlain);
+    response->ReplyText(status_code::Ok, "blah", chromeos::mime::text::kPlain);
   };
 
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
@@ -235,8 +264,8 @@
 }
 
 TEST(HttpUtils, PostBinary) {
-  auto Handler = [](const fake::ServerRequest& request,
-                    fake::ServerResponse* response) {
+  auto Handler =
+      [](const fake::ServerRequest& request, fake::ServerResponse* response) {
     EXPECT_EQ(request_type::kPost, request.GetMethod());
     EXPECT_EQ("256", request.GetHeader(request_header::kContentLength));
     EXPECT_EQ(chromeos::mime::application::kOctet_stream,
@@ -257,9 +286,13 @@
   std::vector<uint8_t> data(256);
   std::iota(data.begin(), data.end(), 0);
 
-  auto response = http::PostBinaryAndBlock(
-      kFakeUrl, data.data(), data.size(), mime::application::kOctet_stream, {},
-      transport, nullptr);
+  auto response = http::PostBinaryAndBlock(kFakeUrl,
+                                           data.data(),
+                                           data.size(),
+                                           mime::application::kOctet_stream,
+                                           {},
+                                           transport,
+                                           nullptr);
   EXPECT_TRUE(response->IsSuccessful());
 }
 
@@ -272,16 +305,20 @@
               std::stoul(request.GetHeader(request_header::kContentLength)));
     EXPECT_EQ(chromeos::mime::text::kPlain,
               request.GetHeader(request_header::kContentType));
-    response->ReplyText(status_code::Ok, request.GetDataAsString(),
-                       chromeos::mime::text::kPlain);
+    response->ReplyText(status_code::Ok,
+                        request.GetDataAsString(),
+                        chromeos::mime::text::kPlain);
   };
 
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
   transport->AddHandler(kFakeUrl, request_type::kPost, base::Bind(PostHandler));
 
-  auto response = http::PostTextAndBlock(
-      kFakeUrl, fake_data, chromeos::mime::text::kPlain, {}, transport,
-      nullptr);
+  auto response = http::PostTextAndBlock(kFakeUrl,
+                                         fake_data,
+                                         chromeos::mime::text::kPlain,
+                                         {},
+                                         transport,
+                                         nullptr);
   EXPECT_TRUE(response->IsSuccessful());
   EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
   EXPECT_EQ(fake_data, response->GetDataAsString());
@@ -289,8 +326,8 @@
 
 TEST(HttpUtils, PostFormData) {
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kFakeUrl, request_type::kPost,
-                        base::Bind(EchoDataHandler));
+  transport->AddHandler(
+      kFakeUrl, request_type::kPost, base::Bind(EchoDataHandler));
 
   auto response = http::PostFormDataAndBlock(
       kFakeUrl, {
@@ -305,15 +342,15 @@
 
 TEST(HttpUtils, PostMultipartFormData) {
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kFakeUrl, request_type::kPost,
-                        base::Bind(EchoDataHandler));
+  transport->AddHandler(
+      kFakeUrl, request_type::kPost, base::Bind(EchoDataHandler));
 
   std::unique_ptr<FormData> form_data{new FormData{"boundary123"}};
   form_data->AddTextField("key1", "value1");
   form_data->AddTextField("key2", "value2");
   std::string expected_content_type = form_data->GetContentType();
-  auto response = http::PostFormDataAndBlock(kFakeUrl, std::move(form_data), {},
-                                             transport, nullptr);
+  auto response = http::PostFormDataAndBlock(
+      kFakeUrl, std::move(form_data), {}, transport, nullptr);
   EXPECT_TRUE(response->IsSuccessful());
   EXPECT_EQ(expected_content_type, response->GetContentType());
   const char expected_value[] =
@@ -330,15 +367,16 @@
 }
 
 TEST(HttpUtils, PostPatchJson) {
-  auto JsonHandler = [](const fake::ServerRequest& request,
-                        fake::ServerResponse* response) {
+  auto JsonHandler =
+      [](const fake::ServerRequest& request, fake::ServerResponse* response) {
     auto mime_type = chromeos::mime::RemoveParameters(
         request.GetHeader(request_header::kContentType));
     EXPECT_EQ(chromeos::mime::application::kJson, mime_type);
-    response->ReplyJson(status_code::Ok, {
-      {"method", request.GetMethod()},
-      {"data", request.GetDataAsString()},
-    });
+    response->ReplyJson(
+        status_code::Ok,
+        {
+         {"method", request.GetMethod()}, {"data", request.GetDataAsString()},
+        });
   };
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
   transport->AddHandler(kFakeUrl, "*", base::Bind(JsonHandler));
@@ -369,8 +407,8 @@
 }
 
 TEST(HttpUtils, ParseJsonResponse) {
-  auto JsonHandler = [](const fake::ServerRequest& request,
-                        fake::ServerResponse* response) {
+  auto JsonHandler =
+      [](const fake::ServerRequest& request, fake::ServerResponse* response) {
     int status_code = std::stoi(request.GetFormField("code"));
     response->ReplyJson(status_code, {{"data", request.GetFormField("value")}});
   };
@@ -433,9 +471,12 @@
     EXPECT_EQ("test_code", error->GetCode());
     EXPECT_EQ("Test message", error->GetMessage());
   };
-  http::SendRequestWithNoData(
-      request_type::kGet, "http://blah.com", {}, transport,
-      base::Bind(success_callback), base::Bind(error_callback));
+  http::SendRequestWithNoData(request_type::kGet,
+                              "http://blah.com",
+                              {},
+                              transport,
+                              base::Bind(success_callback),
+                              base::Bind(error_callback));
 }
 
 }  // namespace http
diff --git a/chromeos/key_value_store.cc b/chromeos/key_value_store.cc
index 1f614ca..8914229 100644
--- a/chromeos/key_value_store.cc
+++ b/chromeos/key_value_store.cc
@@ -65,7 +65,7 @@
   if (key_value->second == "true") {
     *value = true;
     return true;
-  } else if (key_value-> second == "false") {
+  } else if (key_value->second == "false") {
     *value = false;
     return true;
   }
diff --git a/chromeos/key_value_store_unittest.cc b/chromeos/key_value_store_unittest.cc
index 81bc4a0..668cdff 100644
--- a/chromeos/key_value_store_unittest.cc
+++ b/chromeos/key_value_store_unittest.cc
@@ -58,9 +58,12 @@
   ASSERT_EQ(blob.size(), base::WriteFile(temp_file_, blob.data(), blob.size()));
   EXPECT_TRUE(store_.Load(temp_file_));
 
-  map<string, string> expected = {
-      {"A", "B"}, {"C", ""}, {"", ""}, {"FOO", "BAR=BAZ"}, {"BAR", "BAX"},
-      {"MISSING", "NEWLINE"}};
+  map<string, string> expected = {{"A", "B"},
+                                  {"C", ""},
+                                  {"", ""},
+                                  {"FOO", "BAR=BAZ"},
+                                  {"BAR", "BAX"},
+                                  {"MISSING", "NEWLINE"}};
 
   // Test expected values
   string value;
diff --git a/chromeos/map_utils.h b/chromeos/map_utils.h
index b79d1e3..cf4fcd6 100644
--- a/chromeos/map_utils.h
+++ b/chromeos/map_utils.h
@@ -45,7 +45,7 @@
 // Given an STL map, returns a vector of key-value pairs from the map.
 template<typename T>
 inline std::vector<std::pair<typename T::key_type, typename T::mapped_type>>
-    MapToVector(const T& map) {
+MapToVector(const T& map) {
   std::vector<std::pair<typename T::key_type, typename T::mapped_type>> vector;
   vector.reserve(map.size());
   for (const auto& pair : map)
@@ -56,10 +56,10 @@
 // Given an STL map, returns the value associated with a given key or a default
 // value if the key is not present in the map.
 template<typename T>
-inline typename T::mapped_type
-    GetOrDefault(const T& map,
-                 typename T::key_type key,
-                 const typename T::mapped_type& def) {
+inline typename T::mapped_type GetOrDefault(
+    const T& map,
+    typename T::key_type key,
+    const typename T::mapped_type& def) {
   typename T::const_iterator it = map.find(key);
   if (it == map.end())
     return def;
diff --git a/chromeos/map_utils_unittest.cc b/chromeos/map_utils_unittest.cc
index 5b796fa..b04620e 100644
--- a/chromeos/map_utils_unittest.cc
+++ b/chromeos/map_utils_unittest.cc
@@ -14,17 +14,11 @@
  public:
   void SetUp() override {
     map_ = {
-      {"key1", 1},
-      {"key2", 2},
-      {"key3", 3},
-      {"key4", 4},
-      {"key5", 5},
+        {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}, {"key5", 5},
     };
   }
 
-  void TearDown() override {
-    map_.clear();
-  }
+  void TearDown() override { map_.clear(); }
 
   std::map<std::string, int> map_;
 };
@@ -49,11 +43,7 @@
 TEST_F(MapUtilsTest, MapToVector) {
   std::vector<std::pair<std::string, int>> elements = MapToVector(map_);
   std::vector<std::pair<std::string, int>> expected{
-    {"key1", 1},
-    {"key2", 2},
-    {"key3", 3},
-    {"key4", 4},
-    {"key5", 5},
+      {"key1", 1}, {"key2", 2}, {"key3", 3}, {"key4", 4}, {"key5", 5},
   };
   EXPECT_EQ(expected, elements);
 }
diff --git a/chromeos/mime_utils.cc b/chromeos/mime_utils.cc
index a40a2f4..5e2263a 100644
--- a/chromeos/mime_utils.cc
+++ b/chromeos/mime_utils.cc
@@ -66,10 +66,11 @@
 // ***************************************************************************
 
 bool mime::Split(const std::string& mime_string,
-                 std::string* type, std::string* subtype,
+                 std::string* type,
+                 std::string* subtype,
                  mime::Parameters* parameters) {
-  std::vector<std::string> parts = chromeos::string_utils::Split(mime_string,
-                                                                 ';');
+  std::vector<std::string> parts =
+      chromeos::string_utils::Split(mime_string, ';');
   if (parts.empty())
     return false;
 
@@ -89,7 +90,8 @@
 }
 
 bool mime::Split(const std::string& mime_string,
-                 std::string* type, std::string* subtype) {
+                 std::string* type,
+                 std::string* subtype) {
   std::string mime = mime::RemoveParameters(mime_string);
   auto types = chromeos::string_utils::SplitAtFirst(mime, '/');
 
@@ -102,14 +104,14 @@
   return !types.first.empty() && !types.second.empty();
 }
 
-std::string mime::Combine(const std::string& type, const std::string& subtype,
+std::string mime::Combine(const std::string& type,
+                          const std::string& subtype,
                           const mime::Parameters& parameters) {
   std::vector<std::string> parts;
   parts.push_back(chromeos::string_utils::Join('/', type, subtype));
   for (const auto& pair : parameters) {
-    parts.push_back(chromeos::string_utils::Join('=',
-                                                 pair.first,
-                                                 EncodeParam(pair.second)));
+    parts.push_back(chromeos::string_utils::Join(
+        '=', pair.first, EncodeParam(pair.second)));
   }
   return chromeos::string_utils::Join("; ", parts);
 }
diff --git a/chromeos/mime_utils.h b/chromeos/mime_utils.h
index e8b8685..46d4b88 100644
--- a/chromeos/mime_utils.h
+++ b/chromeos/mime_utils.h
@@ -81,7 +81,8 @@
 // Splits a MIME string into type and subtype.
 // "text/plain;charset=utf-8" => ("text", "plain")
 CHROMEOS_EXPORT bool Split(const std::string& mime_string,
-                           std::string* type, std::string* subtype);
+                           std::string* type,
+                           std::string* subtype);
 
 // Splits a MIME string into type, subtype, and parameters.
 // "text/plain;charset=utf-8" => ("text", "plain", {{"charset","utf-8"}})
diff --git a/chromeos/mime_utils_unittest.cc b/chromeos/mime_utils_unittest.cc
index ac9292b..751d7fd 100644
--- a/chromeos/mime_utils_unittest.cc
+++ b/chromeos/mime_utils_unittest.cc
@@ -11,9 +11,9 @@
 TEST(MimeUtils, Combine) {
   std::string mime_string = mime::Combine(mime::types::kText, "xml");
   EXPECT_EQ(mime::text::kXml, mime_string);
-  EXPECT_EQ("application/json; charset=utf-8",
-            mime::Combine(mime::types::kApplication, "json",
-                          {{"charset", "utf-8"}}));
+  EXPECT_EQ(
+      "application/json; charset=utf-8",
+      mime::Combine(mime::types::kApplication, "json", {{"charset", "utf-8"}}));
 }
 
 TEST(MimeUtils, Split) {
@@ -23,8 +23,8 @@
   EXPECT_EQ("jpeg", s2);
 
   mime::Parameters parameters;
-  EXPECT_TRUE(mime::Split("application/json;charset=utf-8",
-    &s1, &s2, &parameters));
+  EXPECT_TRUE(
+      mime::Split("application/json;charset=utf-8", &s1, &s2, &parameters));
   EXPECT_EQ(mime::types::kApplication, s1);
   EXPECT_EQ("json", s2);
   EXPECT_EQ(mime::application::kJson, mime::Combine(s1, s2));
@@ -50,14 +50,13 @@
 }
 
 TEST(MimeUtils, AppendRemoveParams) {
-  std::string mime_string = mime::AppendParameter(mime::text::kXml,
-                                                  mime::parameters::kCharset,
-                                                  "utf-8");
+  std::string mime_string = mime::AppendParameter(
+      mime::text::kXml, mime::parameters::kCharset, "utf-8");
   EXPECT_EQ("text/xml; charset=utf-8", mime_string);
   mime_string = mime::AppendParameter(mime_string, "foo", "bar");
   EXPECT_EQ("text/xml; charset=utf-8; foo=bar", mime_string);
-  EXPECT_EQ("utf-8", mime::GetParameterValue(mime_string,
-                                             mime::parameters::kCharset));
+  EXPECT_EQ("utf-8",
+            mime::GetParameterValue(mime_string, mime::parameters::kCharset));
   EXPECT_EQ("bar", mime::GetParameterValue(mime_string, "foo"));
   EXPECT_EQ("", mime::GetParameterValue(mime_string, "baz"));
   mime_string = mime::RemoveParameters(mime_string);
diff --git a/chromeos/osrelease_reader.cc b/chromeos/osrelease_reader.cc
index 92a86f3..15f5065 100644
--- a/chromeos/osrelease_reader.cc
+++ b/chromeos/osrelease_reader.cc
@@ -34,9 +34,8 @@
   }
 
   base::FilePath osreleased = root_dir.Append("etc").Append("os-release.d");
-  base::FileEnumerator enumerator(osreleased,
-                                  false,
-                                  base::FileEnumerator::FILES);
+  base::FileEnumerator enumerator(
+      osreleased, false, base::FileEnumerator::FILES);
 
   for (base::FilePath path = enumerator.Next(); !path.empty();
        path = enumerator.Next()) {
diff --git a/chromeos/osrelease_reader_unittest.cc b/chromeos/osrelease_reader_unittest.cc
index a7f99da..ea5ec75 100644
--- a/chromeos/osrelease_reader_unittest.cc
+++ b/chromeos/osrelease_reader_unittest.cc
@@ -77,9 +77,8 @@
   string bonjour = "bonjour\ngarbage";
 
   base::WriteFile(osreleased_.Append("HELLO"), hello.data(), hello.size());
-  base::WriteFile(osreleased_.Append("BONJOUR"),
-                  bonjour.data(),
-                  bonjour.size());
+  base::WriteFile(
+      osreleased_.Append("BONJOUR"), bonjour.data(), bonjour.size());
 
   store_.LoadTestingOnly(temp_dir_.path());
 
diff --git a/chromeos/process.cc b/chromeos/process.cc
index 4376f5e..6e2a2a4 100644
--- a/chromeos/process.cc
+++ b/chromeos/process.cc
@@ -23,7 +23,9 @@
 
 namespace chromeos {
 
-bool ReturnTrue() { return true; }
+bool ReturnTrue() {
+  return true;
+}
 
 Process::Process() {
 }
@@ -36,10 +38,13 @@
       base::FilePath(base::StringPrintf("/proc/%d", pid)));
 }
 
-ProcessImpl::ProcessImpl() : pid_(0), uid_(-1), gid_(-1),
-                             pre_exec_(base::Bind(&ReturnTrue)),
-                             search_path_(false),
-                             inherit_parent_signal_mask_(false) {
+ProcessImpl::ProcessImpl()
+    : pid_(0),
+      uid_(-1),
+      gid_(-1),
+      pre_exec_(base::Bind(&ReturnTrue)),
+      search_path_(false),
+      inherit_parent_signal_mask_(false) {
 }
 
 ProcessImpl::~ProcessImpl() {
@@ -175,13 +180,12 @@
       IGNORE_EINTR(close(i->second.child_fd_));
     }
     if (!output_file_.empty()) {
-      int output_handle = HANDLE_EINTR(
-          open(output_file_.c_str(),
-               O_CREAT | O_WRONLY | O_TRUNC | O_EXCL, 0666));
+      int output_handle = HANDLE_EINTR(open(
+          output_file_.c_str(), O_CREAT | O_WRONLY | O_TRUNC | O_EXCL, 0666));
       int saved_errno = errno;
       if (output_handle < 0) {
-        LOG(ERROR) << "Could not create " << output_file_
-                   << ": " << saved_errno;
+        LOG(ERROR) << "Could not create " << output_file_ << ": "
+                   << saved_errno;
         // Avoid exit() to avoid atexit handlers from parent.
         _exit(kErrorExitStatus);
       }
@@ -252,8 +256,8 @@
   if (!WIFEXITED(status)) {
     DCHECK(WIFSIGNALED(status)) << old_pid
                                 << " neither exited, nor died on a signal?";
-    LOG(ERROR) << "Process " << old_pid << " did not exit normally: "
-               << WTERMSIG(status);
+    LOG(ERROR) << "Process " << old_pid
+               << " did not exit normally: " << WTERMSIG(status);
     return -1;
   }
   return WEXITSTATUS(status);
diff --git a/chromeos/process_information.cc b/chromeos/process_information.cc
index 6d3a7f8..9f1d773 100644
--- a/chromeos/process_information.cc
+++ b/chromeos/process_information.cc
@@ -6,9 +6,10 @@
 
 namespace chromeos {
 
-ProcessInformation::ProcessInformation()
-    : cmd_line_(), process_id_(-1) { }
-ProcessInformation::~ProcessInformation() { }
+ProcessInformation::ProcessInformation() : cmd_line_(), process_id_(-1) {
+}
+ProcessInformation::~ProcessInformation() {
+}
 
 std::string ProcessInformation::GetCommandLine() {
   std::string result;
diff --git a/chromeos/process_information.h b/chromeos/process_information.h
index 08b5742..bc2818e 100644
--- a/chromeos/process_information.h
+++ b/chromeos/process_information.h
@@ -29,9 +29,7 @@
     cmd_line_.swap(*value);
   }
 
-  const std::vector<std::string>& get_cmd_line() {
-    return cmd_line_;
-  }
+  const std::vector<std::string>& get_cmd_line() { return cmd_line_; }
 
   // Set the command line array.  This method DOES swap out the contents of
   // |value|.  The caller should expect an empty set on return.
@@ -40,9 +38,7 @@
     open_files_.swap(*value);
   }
 
-  const std::set<std::string>& get_open_files() {
-    return open_files_;
-  }
+  const std::set<std::string>& get_open_files() { return open_files_; }
 
   // Set the command line array.  This method DOES swap out the contents of
   // |value|.  The caller should expect an empty string on return.
@@ -51,17 +47,11 @@
     cwd_.swap(*value);
   }
 
-  const std::string& get_cwd() {
-    return cwd_;
-  }
+  const std::string& get_cwd() { return cwd_; }
 
-  void set_process_id(int value) {
-    process_id_ = value;
-  }
+  void set_process_id(int value) { process_id_ = value; }
 
-  int get_process_id() {
-    return process_id_;
-  }
+  int get_process_id() { return process_id_; }
 
  private:
   std::vector<std::string> cmd_line_;
diff --git a/chromeos/process_test.cc b/chromeos/process_test.cc
index 7ad51fa..eeaf14f 100644
--- a/chromeos/process_test.cc
+++ b/chromeos/process_test.cc
@@ -57,7 +57,7 @@
 TEST(SimpleProcess, BindFd) {
   int fds[2];
   char buf[16];
-  static const char *kMsg = "hello, world!";
+  static const char* kMsg = "hello, world!";
   ProcessImpl process;
   EXPECT_EQ(0, pipe(fds));
   process.AddArg(kBinEcho);
@@ -80,9 +80,7 @@
     ClearLog();
   }
 
-  void TearDown() {
-    base::DeleteFile(test_path_, true);
-  }
+  void TearDown() { base::DeleteFile(test_path_, true); }
 
  protected:
   void CheckStderrCaptured();
@@ -247,8 +245,7 @@
   EXPECT_EQ(static_cast<pid_t>(Process::kErrorExitStatus), process_.Run());
   std::string contents;
   EXPECT_TRUE(base::ReadFileToString(FilePath(output_file_), &contents));
-  EXPECT_NE(std::string::npos,
-            contents.find("Unable to set UID to 0: 1\n"));
+  EXPECT_NE(std::string::npos, contents.find("Unable to set UID to 0: 1\n"));
 }
 
 TEST_F(ProcessTest, WithIllegalGid) {
@@ -258,8 +255,7 @@
   EXPECT_EQ(static_cast<pid_t>(Process::kErrorExitStatus), process_.Run());
   std::string contents;
   EXPECT_TRUE(base::ReadFileToString(FilePath(output_file_), &contents));
-  EXPECT_NE(std::string::npos,
-            contents.find("Unable to set GID to 0: 1\n"));
+  EXPECT_NE(std::string::npos, contents.find("Unable to set GID to 0: 1\n"));
 }
 
 TEST_F(ProcessTest, NoParams) {
diff --git a/chromeos/secure_blob.cc b/chromeos/secure_blob.cc
index 857b612..1ef950b 100644
--- a/chromeos/secure_blob.cc
+++ b/chromeos/secure_blob.cc
@@ -10,16 +10,14 @@
 
 namespace chromeos {
 
-SecureBlob::SecureBlob()
-    : chromeos::Blob() {
+SecureBlob::SecureBlob() : chromeos::Blob() {
 }
 
 SecureBlob::SecureBlob(const_iterator begin, const_iterator end)
     : chromeos::Blob(begin, end) {
 }
 
-SecureBlob::SecureBlob(size_t size)
-    : chromeos::Blob(size) {
+SecureBlob::SecureBlob(size_t size) : chromeos::Blob(size) {
 }
 
 SecureBlob::SecureBlob(const std::string& from)
diff --git a/chromeos/secure_blob.h b/chromeos/secure_blob.h
index a9e3b8c..8bdc9da 100644
--- a/chromeos/secure_blob.h
+++ b/chromeos/secure_blob.h
@@ -35,8 +35,7 @@
   const void* const_data() const;
 
   std::string to_string() const;
-  static SecureBlob Combine(const SecureBlob& blob1,
-                            const SecureBlob& blob2);
+  static SecureBlob Combine(const SecureBlob& blob1, const SecureBlob& blob2);
 };
 
 // Secure memset(). This function is guaranteed to fill int the whole buffer
diff --git a/chromeos/secure_blob_unittest.cc b/chromeos/secure_blob_unittest.cc
index 857a5bb..409613f 100644
--- a/chromeos/secure_blob_unittest.cc
+++ b/chromeos/secure_blob_unittest.cc
@@ -18,20 +18,20 @@
 
 class SecureBlobTest : public ::testing::Test {
  public:
-  SecureBlobTest() { }
-  virtual ~SecureBlobTest() { }
+  SecureBlobTest() {}
+  virtual ~SecureBlobTest() {}
 
   static bool FindBlobInBlob(const chromeos::Blob& haystack,
                              const chromeos::Blob& needle) {
-    auto pos = std::search(haystack.begin(), haystack.end(), needle.begin(),
-                           needle.end());
+    auto pos = std::search(
+        haystack.begin(), haystack.end(), needle.begin(), needle.end());
     return (pos != haystack.end());
   }
 
   static int FindBlobIndexInBlob(const chromeos::Blob& haystack,
                                  const chromeos::Blob& needle) {
-    auto pos = std::search(haystack.begin(), haystack.end(), needle.begin(),
-                           needle.end());
+    auto pos = std::search(
+        haystack.begin(), haystack.end(), needle.begin(), needle.end());
     if (pos == haystack.end()) {
       return -1;
     }
diff --git a/chromeos/strings/string_utils.cc b/chromeos/strings/string_utils.cc
index 0e71891..10a7d57 100644
--- a/chromeos/strings/string_utils.cc
+++ b/chromeos/strings/string_utils.cc
@@ -36,9 +36,9 @@
   }
 
   if (trim_whitespaces) {
-    std::for_each(tokens.begin(), tokens.end(),
-                  [](std::string& str) {
-      base::TrimWhitespaceASCII(str, base::TRIM_ALL, &str); });
+    std::for_each(tokens.begin(), tokens.end(), [](std::string& str) {
+      base::TrimWhitespaceASCII(str, base::TRIM_ALL, &str);
+    });
     if (purge_empty_strings) {
       // We might have removed all the characters from a string if they were
       // all whitespaces. If we don't want empty strings, make sure we remove
@@ -99,12 +99,14 @@
 }
 
 std::string Join(char delimiter,
-                 const std::string& str1, const std::string& str2) {
+                 const std::string& str1,
+                 const std::string& str2) {
   return str1 + delimiter + str2;
 }
 
 std::string Join(const std::string& delimiter,
-                 const std::string& str1, const std::string& str2) {
+                 const std::string& str1,
+                 const std::string& str2) {
   return str1 + delimiter + str2;
 }
 
diff --git a/chromeos/strings/string_utils.h b/chromeos/strings/string_utils.h
index ff3113e..9535cd8 100644
--- a/chromeos/strings/string_utils.h
+++ b/chromeos/strings/string_utils.h
@@ -19,11 +19,10 @@
 // |trim_whitespaces| causes each element to have all whitespaces trimmed off.
 // |purge_empty_strings| specifies whether empty elements from the original
 // string should be omitted.
-CHROMEOS_EXPORT std::vector<std::string> Split(
-    const std::string& str,
-    char delimiter,
-    bool trim_whitespaces,
-    bool purge_empty_strings);
+CHROMEOS_EXPORT std::vector<std::string> Split(const std::string& str,
+                                               char delimiter,
+                                               bool trim_whitespaces,
+                                               bool purge_empty_strings);
 // Splits the string, trims all whitespaces, omits empty string parts.
 inline std::vector<std::string> Split(const std::string& str, char delimiter) {
   return Split(str, delimiter, true, true);
@@ -37,15 +36,12 @@
 
 // Splits the string into two pieces at the first position of the specified
 // delimiter.
-CHROMEOS_EXPORT std::pair<std::string, std::string> SplitAtFirst(
-    const std::string& str,
-    char delimiter,
-    bool trim_whitespaces);
+CHROMEOS_EXPORT std::pair<std::string, std::string>
+SplitAtFirst(const std::string& str, char delimiter, bool trim_whitespaces);
 // Splits the string into two pieces at the first position of the specified
 // delimiter. Both parts have all whitespaces trimmed off.
-inline std::pair<std::string, std::string> SplitAtFirst(
-    const std::string& str,
-    char delimiter) {
+inline std::pair<std::string, std::string> SplitAtFirst(const std::string& str,
+                                                        char delimiter) {
   return SplitAtFirst(str, delimiter, true);
 }
 
@@ -81,10 +77,14 @@
 // to a string. In most cases, it redirects the call to std::to_string with
 // two exceptions: for std::string itself and for double and bool.
 template<typename T>
-inline std::string ToString(T value) { return std::to_string(value); }
+inline std::string ToString(T value) {
+  return std::to_string(value);
+}
 // Having the following overload is handy for templates where the type
 // of template parameter isn't known and could be a string itself.
-inline std::string ToString(std::string value) { return value; }
+inline std::string ToString(std::string value) {
+  return value;
+}
 // We overload this for double because std::to_string(double) uses %f to
 // format the value and I would like to use a shorter %g format instead.
 CHROMEOS_EXPORT std::string ToString(double value);
diff --git a/chromeos/syslog_logging.cc b/chromeos/syslog_logging.cc
index 1c54b6c..79d0840 100644
--- a/chromeos/syslog_logging.cc
+++ b/chromeos/syslog_logging.cc
@@ -37,7 +37,7 @@
                           const char* file,
                           int line,
                           size_t message_start,
-                          const std::string &message) {
+                          const std::string& message) {
   switch (severity) {
     case logging::LOG_INFO:
       severity = kSyslogInfo;
@@ -60,7 +60,7 @@
       break;
   }
 
-  const char *str;
+  const char* str;
   if (s_log_header) {
     str = message.c_str();
   } else {
@@ -82,9 +82,9 @@
 }
 int GetLogFlags() {
   int flags = 0;
-  flags |= (s_log_to_syslog) ?kLogToSyslog :0;
-  flags |= (s_log_to_stderr) ?kLogToStderr :0;
-  flags |= (s_log_header) ?kLogHeader :0;
+  flags |= (s_log_to_syslog) ? kLogToSyslog : 0;
+  flags |= (s_log_to_stderr) ? kLogToStderr : 0;
+  flags |= (s_log_header) ? kLogHeader : 0;
   return flags;
 }
 void InitLog(int init_flags) {
@@ -96,8 +96,8 @@
   const bool kOptionTID = false;
   const bool kOptionTimestamp = false;
   const bool kOptionTickcount = false;
-  logging::SetLogItems(kOptionPID, kOptionTID, kOptionTimestamp,
-                       kOptionTickcount);
+  logging::SetLogItems(
+      kOptionPID, kOptionTID, kOptionTimestamp, kOptionTickcount);
   logging::SetLogMessageHandler(HandleMessage);
   SetLogFlags(init_flags);
 }
diff --git a/chromeos/syslog_logging_unittest.cc b/chromeos/syslog_logging_unittest.cc
index cb11119..982b83a 100644
--- a/chromeos/syslog_logging_unittest.cc
+++ b/chromeos/syslog_logging_unittest.cc
@@ -10,8 +10,8 @@
 
 class SyslogLoggingDeathTest : public ::testing::Test {
  public:
-  SyslogLoggingDeathTest() { }
-  virtual ~SyslogLoggingDeathTest() { }
+  SyslogLoggingDeathTest() {}
+  virtual ~SyslogLoggingDeathTest() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SyslogLoggingDeathTest);
@@ -20,13 +20,11 @@
 TEST_F(SyslogLoggingDeathTest, FatalLoggingIsFatal) {
   int old_flags = GetLogFlags();
   SetLogFlags(kLogToStderr);
-  EXPECT_DEATH({ LOG(FATAL) << "First Fatality!"; },
-               "First Fatality!");
+  EXPECT_DEATH({ LOG(FATAL) << "First Fatality!"; }, "First Fatality!");
   // No flags == don't log to syslog, stderr, or accumulated string.
   SetLogFlags(0);
   // Still a fatal log message
-  EXPECT_DEATH({ LOG(FATAL) << "Second Fatality!"; },
-               "Second Fatality!");
+  EXPECT_DEATH({ LOG(FATAL) << "Second Fatality!"; }, "Second Fatality!");
   SetLogFlags(old_flags);
 }
 
diff --git a/chromeos/test_helpers.h b/chromeos/test_helpers.h
index 89ffd3d..bfefe77 100644
--- a/chromeos/test_helpers.h
+++ b/chromeos/test_helpers.h
@@ -16,14 +16,13 @@
 
 #include "chromeos/syslog_logging.h"
 
-inline void ExpectFileEquals(const char* golden,
-                             const char* file_path) {
+inline void ExpectFileEquals(const char* golden, const char* file_path) {
   std::string contents;
   EXPECT_TRUE(base::ReadFileToString(base::FilePath(file_path), &contents));
   EXPECT_EQ(golden, contents);
 }
 
-inline void SetUpTests(int *argc, char** argv, bool log_to_stderr) {
+inline void SetUpTests(int* argc, char** argv, bool log_to_stderr) {
   CommandLine::Init(*argc, argv);
   ::chromeos::InitLog(log_to_stderr ? chromeos::kLogToStderr : 0);
   ::chromeos::LogToString(true);
diff --git a/chromeos/url_utils.cc b/chromeos/url_utils.cc
index 07cbc9a..3a2e166 100644
--- a/chromeos/url_utils.cc
+++ b/chromeos/url_utils.cc
@@ -21,8 +21,10 @@
 // If |exclude_fragment| is true, the function returns the start character and
 // the length of the query string alone. If it is false, the query string length
 // will include both the query string and the fragment.
-bool GetQueryStringPos(const std::string& url, bool exclude_fragment,
-                       size_t* query_pos, size_t* query_len) {
+bool GetQueryStringPos(const std::string& url,
+                       bool exclude_fragment,
+                       size_t* query_pos,
+                       size_t* query_len) {
   size_t query_start = url.find_first_of("?#");
   if (query_start == std::string::npos) {
     *query_pos = url.size();
@@ -61,13 +63,12 @@
   return query_string;
 }
 
-std::string url::Combine(
-    const std::string& url, const std::string& subpath) {
+std::string url::Combine(const std::string& url, const std::string& subpath) {
   return CombineMultiple(url, {subpath});
 }
 
-std::string url::CombineMultiple(
-    const std::string& url, const std::vector<std::string>& parts) {
+std::string url::CombineMultiple(const std::string& url,
+                                 const std::vector<std::string>& parts) {
   std::string result = url;
   if (!parts.empty()) {
     std::string query_string = TrimOffQueryString(&result);
@@ -85,8 +86,7 @@
   return result;
 }
 
-std::string url::GetQueryString(
-    const std::string& url, bool remove_fragment) {
+std::string url::GetQueryString(const std::string& url, bool remove_fragment) {
   std::string query_string;
   size_t query_pos, query_len;
   if (GetQueryStringPos(url, remove_fragment, &query_pos, &query_len)) {
@@ -104,8 +104,8 @@
   return data_encoding::WebParamsDecode(query_string);
 }
 
-std::string url::GetQueryStringValue(
-    const std::string& url, const std::string& name) {
+std::string url::GetQueryStringValue(const std::string& url,
+                                     const std::string& name) {
   return GetQueryStringValue(GetQueryStringParameters(url), name);
 }
 
@@ -118,8 +118,8 @@
   return std::string();
 }
 
-std::string url::RemoveQueryString(
-    const std::string& url, bool remove_fragment_too) {
+std::string url::RemoveQueryString(const std::string& url,
+                                   bool remove_fragment_too) {
   size_t query_pos, query_len;
   if (!GetQueryStringPos(url, !remove_fragment_too, &query_pos, &query_len))
     return url;
@@ -131,8 +131,9 @@
   return result;
 }
 
-std::string url::AppendQueryParam(
-    const std::string& url, const std::string& name, const std::string& value) {
+std::string url::AppendQueryParam(const std::string& url,
+                                  const std::string& name,
+                                  const std::string& value) {
   return AppendQueryParams(url, {{name, value}});
 }
 
diff --git a/chromeos/url_utils_unittest.cc b/chromeos/url_utils_unittest.cc
index 6c16e2c..d52d720 100644
--- a/chromeos/url_utils_unittest.cc
+++ b/chromeos/url_utils_unittest.cc
@@ -15,14 +15,12 @@
             url::Combine("http://sample.org/", "path"));
   EXPECT_EQ("path1/path2", url::Combine("", "path1/path2"));
   EXPECT_EQ("path1/path2", url::Combine("path1", "path2"));
-  EXPECT_EQ("http://sample.org",
-            url::Combine("http://sample.org", ""));
+  EXPECT_EQ("http://sample.org", url::Combine("http://sample.org", ""));
   EXPECT_EQ("http://sample.org/path",
             url::Combine("http://sample.org/", "/path"));
   EXPECT_EQ("http://sample.org/path",
             url::Combine("http://sample.org", "//////path"));
-  EXPECT_EQ("http://sample.org/",
-            url::Combine("http://sample.org", "///"));
+  EXPECT_EQ("http://sample.org/", url::Combine("http://sample.org", "///"));
   EXPECT_EQ("http://sample.org/obj/path1/path2",
             url::Combine("http://sample.org/obj", "path1/path2"));
   EXPECT_EQ("http://sample.org/obj/path1/path2#tag",
@@ -50,25 +48,19 @@
   EXPECT_EQ("?q=v&b=2",
             url::GetQueryString("http://s.com/?q=v&b=2#tag?2", true));
 
-  EXPECT_EQ("#tag?a=2",
-            url::GetQueryString("http://s.com/#tag?a=2", false));
-  EXPECT_EQ("",
-            url::GetQueryString("http://s.com/#tag?a=2", true));
+  EXPECT_EQ("#tag?a=2", url::GetQueryString("http://s.com/#tag?a=2", false));
+  EXPECT_EQ("", url::GetQueryString("http://s.com/#tag?a=2", true));
 
-  EXPECT_EQ("?a=2&b=2",
-            url::GetQueryString("?a=2&b=2", false));
-  EXPECT_EQ("?a=2&b=2",
-            url::GetQueryString("?a=2&b=2", true));
+  EXPECT_EQ("?a=2&b=2", url::GetQueryString("?a=2&b=2", false));
+  EXPECT_EQ("?a=2&b=2", url::GetQueryString("?a=2&b=2", true));
 
-  EXPECT_EQ("#s#?d#?f?#s?#d",
-            url::GetQueryString("#s#?d#?f?#s?#d", false));
-  EXPECT_EQ("",
-            url::GetQueryString("#s#?d#?f?#s?#d", true));
+  EXPECT_EQ("#s#?d#?f?#s?#d", url::GetQueryString("#s#?d#?f?#s?#d", false));
+  EXPECT_EQ("", url::GetQueryString("#s#?d#?f?#s?#d", true));
 }
 
 TEST(UrlUtils, GetQueryStringParameters) {
   auto params = url::GetQueryStringParameters(
-    "http://sample.org/path?k=v&&%3Dkey%3D=val%26&r#blah");
+      "http://sample.org/path?k=v&&%3Dkey%3D=val%26&r#blah");
 
   EXPECT_EQ(3, params.size());
   EXPECT_EQ("k", params[0].first);