diff --git a/libweave/src/buffet_config_unittest.cc b/libweave/src/buffet_config_unittest.cc
index 5274c5a..4b458fe 100644
--- a/libweave/src/buffet_config_unittest.cc
+++ b/libweave/src/buffet_config_unittest.cc
@@ -121,8 +121,10 @@
             config_->backup_polling_period());
   EXPECT_FALSE(config_->wifi_auto_setup_enabled());
   std::set<privetd::PairingType> pairing_types{
-      privetd::PairingType::kPinCode, privetd::PairingType::kEmbeddedCode,
-      privetd::PairingType::kUltrasound32, privetd::PairingType::kAudible32};
+      privetd::PairingType::kPinCode,
+      privetd::PairingType::kEmbeddedCode,
+      privetd::PairingType::kUltrasound32,
+      privetd::PairingType::kAudible32};
   EXPECT_EQ(pairing_types, config_->pairing_modes());
   EXPECT_EQ("/conf_code", config_->embedded_code_path().value());
   EXPECT_EQ("conf_name", config_->name());
diff --git a/libweave/src/buffet_testrunner.cc b/libweave/src/buffet_testrunner.cc
index 575f952..072461d 100644
--- a/libweave/src/buffet_testrunner.cc
+++ b/libweave/src/buffet_testrunner.cc
@@ -5,7 +5,7 @@
 #include <base/at_exit.h>
 #include <gtest/gtest.h>
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   base::AtExitManager exit_manager;
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
diff --git a/libweave/src/commands/cloud_command_proxy.cc b/libweave/src/commands/cloud_command_proxy.cc
index 7f9afcc..0ef511f 100644
--- a/libweave/src/commands/cloud_command_proxy.cc
+++ b/libweave/src/commands/cloud_command_proxy.cc
@@ -26,7 +26,7 @@
       cloud_backoff_entry_{std::move(backoff_entry)} {
   callback_token_ = state_change_queue_->AddOnStateUpdatedCallback(
       base::Bind(&CloudCommandProxy::OnDeviceStateUpdated,
-                  weak_ptr_factory_.GetWeakPtr()));
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void CloudCommandProxy::OnResultsChanged() {
@@ -94,9 +94,8 @@
             << cloud_backoff_entry_->GetTimeUntilRelease()
             << " due to backoff policy";
     task_runner_->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&CloudCommandProxy::SendCommandUpdate,
-                   backoff_weak_ptr_factory_.GetWeakPtr()),
+        FROM_HERE, base::Bind(&CloudCommandProxy::SendCommandUpdate,
+                              backoff_weak_ptr_factory_.GetWeakPtr()),
         cloud_backoff_entry_->GetTimeUntilRelease());
     return;
   }
diff --git a/libweave/src/commands/cloud_command_proxy_unittest.cc b/libweave/src/commands/cloud_command_proxy_unittest.cc
index 518d45f..5452f93 100644
--- a/libweave/src/commands/cloud_command_proxy_unittest.cc
+++ b/libweave/src/commands/cloud_command_proxy_unittest.cc
@@ -37,19 +37,21 @@
 
 class MockCloudCommandUpdateInterface : public CloudCommandUpdateInterface {
  public:
-  MOCK_METHOD4(UpdateCommand, void(const std::string&,
-                                   const base::DictionaryValue&,
-                                   const base::Closure&,
-                                   const base::Closure&));
+  MOCK_METHOD4(UpdateCommand,
+               void(const std::string&,
+                    const base::DictionaryValue&,
+                    const base::Closure&,
+                    const base::Closure&));
 };
 
 // Mock-like task runner that allow the tests to inspect the calls to
 // TaskRunner::PostDelayedTask and verify the delays.
 class TestTaskRunner : public base::TaskRunner {
  public:
-  MOCK_METHOD3(PostDelayedTask, bool(const tracked_objects::Location&,
-                                     const base::Closure&,
-                                     base::TimeDelta));
+  MOCK_METHOD3(PostDelayedTask,
+               bool(const tracked_objects::Location&,
+                    const base::Closure&,
+                    base::TimeDelta));
 
   bool RunsTasksOnCurrentThread() const override { return true; }
 };
@@ -148,9 +150,12 @@
         new TestBackoffEntry{&policy, &clock_}};
 
     // Finally construct the CloudCommandProxy we are going to test here.
-    std::unique_ptr<CloudCommandProxy> proxy{new CloudCommandProxy{
-        command_instance_.get(), &cloud_updater_, &state_change_queue_,
-        std::move(backoff), task_runner_}};
+    std::unique_ptr<CloudCommandProxy> proxy{
+        new CloudCommandProxy{command_instance_.get(),
+                              &cloud_updater_,
+                              &state_change_queue_,
+                              std::move(backoff),
+                              task_runner_}};
     command_instance_->AddProxy(std::move(proxy));
   }
 
diff --git a/libweave/src/commands/command_definition.cc b/libweave/src/commands/command_definition.cc
index 4dfa51e..0b7bcb3 100644
--- a/libweave/src/commands/command_definition.cc
+++ b/libweave/src/commands/command_definition.cc
@@ -35,10 +35,10 @@
     } else if (value == commands::attributes::kCommand_Visibility_Cloud) {
       cloud = true;
     } else {
-      chromeos::Error::AddToPrintf(
-          error, FROM_HERE, errors::commands::kDomain,
-          errors::commands::kInvalidPropValue,
-          "Invalid command visibility value '%s'", value.c_str());
+      chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+                                   errors::commands::kInvalidPropValue,
+                                   "Invalid command visibility value '%s'",
+                                   value.c_str());
       return false;
     }
   }
diff --git a/libweave/src/commands/command_definition.h b/libweave/src/commands/command_definition.h
index 55dcae6..21eed9c 100644
--- a/libweave/src/commands/command_definition.h
+++ b/libweave/src/commands/command_definition.h
@@ -71,7 +71,7 @@
   std::string category_;  // Cmd category. Could be "powerd" for "base.reboot".
   std::unique_ptr<const ObjectSchema> parameters_;  // Command parameters def.
   std::unique_ptr<const ObjectSchema> progress_;    // Command progress def.
-  std::unique_ptr<const ObjectSchema> results_;  // Command results def.
+  std::unique_ptr<const ObjectSchema> results_;     // Command results def.
   Visibility visibility_;  // Available to all by default.
   // Minimal role required to execute command.
   UserRole minimal_role_{UserRole::kUser};
diff --git a/libweave/src/commands/command_dictionary.cc b/libweave/src/commands/command_dictionary.cc
index f8103be..92dd316 100644
--- a/libweave/src/commands/command_dictionary.cc
+++ b/libweave/src/commands/command_dictionary.cc
@@ -56,11 +56,10 @@
       }
       const base::DictionaryValue* command_def_json = nullptr;
       if (!command_iter.value().GetAsDictionary(&command_def_json)) {
-        chromeos::Error::AddToPrintf(error, FROM_HERE,
-                                     errors::commands::kDomain,
-                                     errors::commands::kTypeMismatch,
-                                     "Expecting an object for command '%s'",
-                                     command_name.c_str());
+        chromeos::Error::AddToPrintf(
+            error, FROM_HERE, errors::commands::kDomain,
+            errors::commands::kTypeMismatch,
+            "Expecting an object for command '%s'", command_name.c_str());
         return false;
       }
       // Construct the compound command name as "pkg_name.cmd_name".
@@ -101,11 +100,8 @@
       }
 
       auto parameters_schema = BuildObjectSchema(
-          command_def_json,
-          commands::attributes::kCommand_Parameters,
-          base_parameters_def,
-          full_command_name,
-          error);
+          command_def_json, commands::attributes::kCommand_Parameters,
+          base_parameters_def, full_command_name, error);
       if (!parameters_schema)
         return false;
 
@@ -116,11 +112,8 @@
         return false;
 
       auto results_schema = BuildObjectSchema(
-          command_def_json,
-          commands::attributes::kCommand_Results,
-          base_results_def,
-          full_command_name,
-          error);
+          command_def_json, commands::attributes::kCommand_Results,
+          base_results_def, full_command_name, error);
       if (!results_schema)
         return false;
 
@@ -202,8 +195,7 @@
   }
 
   if (!object_schema->FromJson(schema_def, base_def, error)) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE,
-                                 errors::commands::kDomain,
+    chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
                                  errors::commands::kInvalidObjectSchema,
                                  "Invalid definition for command '%s'",
                                  command_name.c_str());
diff --git a/libweave/src/commands/command_dictionary_unittest.cc b/libweave/src/commands/command_dictionary_unittest.cc
index 45aa59b..e087943 100644
--- a/libweave/src/commands/command_dictionary_unittest.cc
+++ b/libweave/src/commands/command_dictionary_unittest.cc
@@ -161,12 +161,14 @@
   })");
   base_dict.LoadCommands(*json, "", nullptr, &error);
   EXPECT_TRUE(dict.LoadCommands(*json, "robotd", &base_dict, &error));
-  auto json2 = CreateDictionaryValue(
-      "{'base':{'jump':{'parameters':{},'results':{}}}}");
+  auto json2 =
+      CreateDictionaryValue("{'base':{'jump':{'parameters':{},'results':{}}}}");
   EXPECT_FALSE(dict.LoadCommands(*json2, "robotd", &base_dict, &error));
   EXPECT_EQ("invalid_command_name", error->GetCode());
-  EXPECT_EQ("The name of custom command 'jump' in package 'base' must start "
-            "with '_'", error->GetMessage());
+  EXPECT_EQ(
+      "The name of custom command 'jump' in package 'base' must start "
+      "with '_'",
+      error->GetMessage());
   error.reset();
 
   // If the command starts with "_", then it's Ok.
@@ -379,9 +381,9 @@
   })";
   EXPECT_JSON_EQ(expected, *json);
 
-  json = dict.GetCommandsAsJson(
-      [](const CommandDefinition* def) { return def->GetVisibility().local; },
-      false, nullptr);
+  json = dict.GetCommandsAsJson([](const CommandDefinition* def) {
+    return def->GetVisibility().local;
+  }, false, nullptr);
   ASSERT_NE(nullptr, json.get());
   expected = R"({
     'test': {
@@ -393,9 +395,9 @@
   })";
   EXPECT_JSON_EQ(expected, *json);
 
-  json = dict.GetCommandsAsJson(
-      [](const CommandDefinition* def) { return def->GetVisibility().cloud; },
-      false, nullptr);
+  json = dict.GetCommandsAsJson([](const CommandDefinition* def) {
+    return def->GetVisibility().cloud;
+  }, false, nullptr);
   ASSERT_NE(nullptr, json.get());
   expected = R"({
     'test': {
@@ -407,10 +409,9 @@
   })";
   EXPECT_JSON_EQ(expected, *json);
 
-  json = dict.GetCommandsAsJson(
-    [](const CommandDefinition* def) {
-      return def->GetVisibility().local && def->GetVisibility().cloud;
-    }, false, nullptr);
+  json = dict.GetCommandsAsJson([](const CommandDefinition* def) {
+    return def->GetVisibility().local && def->GetVisibility().cloud;
+  }, false, nullptr);
   ASSERT_NE(nullptr, json.get());
   expected = R"({
     'test': {
diff --git a/libweave/src/commands/command_instance_unittest.cc b/libweave/src/commands/command_instance_unittest.cc
index 53fe646..0da58d8 100644
--- a/libweave/src/commands/command_instance_unittest.cc
+++ b/libweave/src/commands/command_instance_unittest.cc
@@ -72,8 +72,7 @@
   StringPropType str_prop;
   IntPropType int_prop;
   native_types::Object params;
-  params["phrase"] = str_prop.CreateValue(std::string("iPityDaFool"),
-                                          nullptr);
+  params["phrase"] = str_prop.CreateValue(std::string("iPityDaFool"), nullptr);
   params["volume"] = int_prop.CreateValue(5, nullptr);
   CommandInstance instance{
       "robot.speak", "cloud", dict_.FindCommand("robot.speak"), params};
@@ -200,8 +199,7 @@
             first->GetMessage());
   auto inner = error->GetInnerError();
   EXPECT_EQ("invalid_parameter_value", inner->GetCode());
-  EXPECT_EQ("Invalid value for property 'volume'",
-            inner->GetMessage());
+  EXPECT_EQ("Invalid value for property 'volume'", inner->GetMessage());
   EXPECT_EQ("command_failed", error->GetCode());
   EXPECT_EQ("Failed to validate command 'robot.speak'", error->GetMessage());
 }
diff --git a/libweave/src/commands/command_manager.cc b/libweave/src/commands/command_manager.cc
index e636837..d8bc226 100644
--- a/libweave/src/commands/command_manager.cc
+++ b/libweave/src/commands/command_manager.cc
@@ -39,8 +39,8 @@
 
 bool CommandManager::LoadBaseCommands(const base::FilePath& json_file_path,
                                       chromeos::ErrorPtr* error) {
-  std::unique_ptr<const base::DictionaryValue> json = LoadJsonDict(
-      json_file_path, error);
+  std::unique_ptr<const base::DictionaryValue> json =
+      LoadJsonDict(json_file_path, error);
   if (!json)
     return false;
   return LoadBaseCommands(*json, error);
@@ -58,8 +58,8 @@
 
 bool CommandManager::LoadCommands(const base::FilePath& json_file_path,
                                   chromeos::ErrorPtr* error) {
-  std::unique_ptr<const base::DictionaryValue> json = LoadJsonDict(
-      json_file_path, error);
+  std::unique_ptr<const base::DictionaryValue> json =
+      LoadJsonDict(json_file_path, error);
   if (!json)
     return false;
   std::string category = json_file_path.BaseName().RemoveExtension().value();
@@ -80,8 +80,7 @@
     base::FilePath device_command_dir{root.Append("commands")};
     VLOG(2) << "Looking for commands in " << root.value();
     base::FileEnumerator enumerator(device_command_dir, false,
-                                    base::FileEnumerator::FILES,
-                                    pattern);
+                                    base::FileEnumerator::FILES, pattern);
     base::FilePath json_file_path = enumerator.Next();
     while (!json_file_path.empty()) {
       LOG(INFO) << "Loading command schema from " << json_file_path.value();
diff --git a/libweave/src/commands/command_manager.h b/libweave/src/commands/command_manager.h
index 6a6b6dc..a404256 100644
--- a/libweave/src/commands/command_manager.h
+++ b/libweave/src/commands/command_manager.h
@@ -24,7 +24,6 @@
 }  // namespace dbus_utils
 }  // namespace chromeos
 
-
 namespace buffet {
 
 class CommandInstance;
@@ -111,7 +110,7 @@
 
  private:
   CommandDictionary base_dictionary_;  // Base/std command definitions/schemas.
-  CommandDictionary dictionary_;  // Command definitions/schemas.
+  CommandDictionary dictionary_;       // Command definitions/schemas.
   DBusCommandDispacher command_dispatcher_;
   CommandQueue command_queue_;
   std::vector<base::Callback<void()>> on_command_changed_;
diff --git a/libweave/src/commands/command_manager_unittest.cc b/libweave/src/commands/command_manager_unittest.cc
index da37057..3087a49 100644
--- a/libweave/src/commands/command_manager_unittest.cc
+++ b/libweave/src/commands/command_manager_unittest.cc
@@ -152,12 +152,10 @@
                  test_commands_path.Append("test.json"));
   manager.Startup(base_path, test_path);
   EXPECT_EQ(3, manager.GetCommandDictionary().GetSize());
-  EXPECT_NE(nullptr,
-            manager.GetCommandDictionary().FindCommand("robot._jump"));
+  EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("robot._jump"));
   EXPECT_NE(nullptr,
             manager.GetCommandDictionary().FindCommand("robot._speak"));
-  EXPECT_NE(nullptr,
-            manager.GetCommandDictionary().FindCommand("test._yo"));
+  EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("test._yo"));
 }
 
 TEST(CommandManager, UpdateCommandVisibility) {
diff --git a/libweave/src/commands/command_queue_unittest.cc b/libweave/src/commands/command_queue_unittest.cc
index 662cf82..6b78709 100644
--- a/libweave/src/commands/command_queue_unittest.cc
+++ b/libweave/src/commands/command_queue_unittest.cc
@@ -50,12 +50,10 @@
 class FakeDispatcher {
  public:
   explicit FakeDispatcher(CommandQueue* queue) {
-    queue->AddOnCommandAddedCallback(
-        base::Bind(&FakeDispatcher::OnCommandAdded,
-                   weak_ptr_factory_.GetWeakPtr()));
-    queue->AddOnCommandRemovedCallback(
-        base::Bind(&FakeDispatcher::OnCommandRemoved,
-                   weak_ptr_factory_.GetWeakPtr()));
+    queue->AddOnCommandAddedCallback(base::Bind(
+        &FakeDispatcher::OnCommandAdded, weak_ptr_factory_.GetWeakPtr()));
+    queue->AddOnCommandRemovedCallback(base::Bind(
+        &FakeDispatcher::OnCommandRemoved, weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnCommandAdded(CommandInstance* command_instance) {
diff --git a/libweave/src/commands/dbus_command_dispatcher.h b/libweave/src/commands/dbus_command_dispatcher.h
index 4217582..12fdf78 100644
--- a/libweave/src/commands/dbus_command_dispatcher.h
+++ b/libweave/src/commands/dbus_command_dispatcher.h
@@ -30,8 +30,9 @@
 // command queue and D-Bus ExportedObjectManager.
 class DBusCommandDispacher final {
  public:
-  explicit DBusCommandDispacher(const base::WeakPtr<
-      chromeos::dbus_utils::ExportedObjectManager>& object_manager);
+  explicit DBusCommandDispacher(
+      const base::WeakPtr<chromeos::dbus_utils::ExportedObjectManager>&
+          object_manager);
 
   void OnCommandAdded(CommandInstance* command_instance);
 
diff --git a/libweave/src/commands/dbus_command_dispatcher_unittest.cc b/libweave/src/commands/dbus_command_dispatcher_unittest.cc
index 00c2da1..3f56ba1 100644
--- a/libweave/src/commands/dbus_command_dispatcher_unittest.cc
+++ b/libweave/src/commands/dbus_command_dispatcher_unittest.cc
@@ -52,12 +52,12 @@
     EXPECT_CALL(*bus_, AssertOnOriginThread()).Times(AnyNumber());
     EXPECT_CALL(*bus_, AssertOnDBusThread()).Times(AnyNumber());
     // Use a mock exported object manager.
-    mock_exported_object_manager_ = new dbus::MockExportedObject(
-        bus_.get(), kExportedObjectManagerPath);
+    mock_exported_object_manager_ =
+        new dbus::MockExportedObject(bus_.get(), kExportedObjectManagerPath);
     EXPECT_CALL(*bus_, GetExportedObject(kExportedObjectManagerPath))
         .WillRepeatedly(Return(mock_exported_object_manager_.get()));
-    EXPECT_CALL(*mock_exported_object_manager_,
-                ExportMethod(_, _, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*mock_exported_object_manager_, ExportMethod(_, _, _, _))
+        .Times(AnyNumber());
     om_.reset(new chromeos::dbus_utils::ExportedObjectManager(
         bus_.get(), kExportedObjectManagerPath));
     om_->RegisterAsync(AsyncEventSequencer::GetDefaultCompletionAction());
@@ -66,8 +66,8 @@
         base::Bind(&DBusCommandDispacher::OnCommandAdded,
                    base::Unretained(command_dispatcher_.get())));
     // Use a mock exported object for command proxy.
-    mock_exported_command_proxy_ = new dbus::MockExportedObject(
-        bus_.get(), kCmdObjPath);
+    mock_exported_command_proxy_ =
+        new dbus::MockExportedObject(bus_.get(), kCmdObjPath);
     EXPECT_CALL(*bus_, GetExportedObject(kCmdObjPath))
         .WillRepeatedly(Return(mock_exported_command_proxy_.get()));
     EXPECT_CALL(*mock_exported_command_proxy_, ExportMethod(_, _, _, _))
@@ -104,11 +104,10 @@
     on_exported_callback.Run(interface_name, method_name, true);
   }
 
-
   void AddNewCommand(const std::string& json, const std::string& id) {
-    auto command_instance = CommandInstance::FromJson(
-        CreateDictionaryValue(json.c_str()).get(), "cloud", dictionary_,
-        nullptr, nullptr);
+    auto command_instance =
+        CommandInstance::FromJson(CreateDictionaryValue(json.c_str()).get(),
+                                  "cloud", dictionary_, nullptr, nullptr);
     command_instance->SetID(id);
     // Two interfaces are added - Command and Properties.
     EXPECT_CALL(*mock_exported_object_manager_, SendSignal(_)).Times(2);
@@ -120,16 +119,13 @@
     return static_cast<DBusCommandProxy*>(command_instance->proxies_[0].get());
   }
 
-  void FinishCommand(DBusCommandProxy* proxy) {
-    proxy->Done();
-  }
+  void FinishCommand(DBusCommandProxy* proxy) { proxy->Done(); }
 
   void SetProgress(DBusCommandProxy* proxy,
                    const native_types::Object& progress) {
     EXPECT_TRUE(proxy->SetProgress(nullptr, ObjectToDBusVariant(progress)));
   }
 
-
   scoped_refptr<dbus::MockBus> bus_;
   scoped_refptr<dbus::MockExportedObject> mock_exported_object_manager_;
   scoped_refptr<dbus::MockExportedObject> mock_exported_command_proxy_;
@@ -176,7 +172,8 @@
     'parameters': {
       'delay': 20
     }
-  })", id);
+  })",
+                id);
   CommandInstance* command_instance = command_queue_.Find(id);
   ASSERT_NE(nullptr, command_instance);
   DBusCommandProxy* command_proxy = FindProxy(command_instance);
@@ -203,5 +200,4 @@
   EXPECT_EQ(nullptr, command_queue_.Find(id));
 }
 
-
 }  // namespace buffet
diff --git a/libweave/src/commands/dbus_command_proxy.cc b/libweave/src/commands/dbus_command_proxy.cc
index 1807a0e..d7cbd14 100644
--- a/libweave/src/commands/dbus_command_proxy.cc
+++ b/libweave/src/commands/dbus_command_proxy.cc
@@ -27,7 +27,7 @@
 }
 
 void DBusCommandProxy::RegisterAsync(
-      const AsyncEventSequencer::CompletionAction& completion_callback) {
+    const AsyncEventSequencer::CompletionAction& completion_callback) {
   dbus_adaptor_.RegisterWithDBusObject(&dbus_object_);
 
   // Set the initial property values before registering the DBus object.
@@ -39,10 +39,10 @@
       ObjectToDBusVariant(command_instance_->GetProgress()));
   dbus_adaptor_.SetOrigin(command_instance_->GetOrigin());
 
-  dbus_adaptor_.SetParameters(ObjectToDBusVariant(
-      command_instance_->GetParameters()));
-  dbus_adaptor_.SetResults(ObjectToDBusVariant(
-      command_instance_->GetResults()));
+  dbus_adaptor_.SetParameters(
+      ObjectToDBusVariant(command_instance_->GetParameters()));
+  dbus_adaptor_.SetResults(
+      ObjectToDBusVariant(command_instance_->GetResults()));
 
   // Register the command DBus object and expose its methods and properties.
   dbus_object_.RegisterAsync(completion_callback);
@@ -80,8 +80,8 @@
 
 bool DBusCommandProxy::SetResults(chromeos::ErrorPtr* error,
                                   const chromeos::VariantDictionary& results) {
-  LOG(INFO) << "Received call to Command<"
-            << command_instance_->GetName() << ">::SetResults()";
+  LOG(INFO) << "Received call to Command<" << command_instance_->GetName()
+            << ">::SetResults()";
 
   auto results_schema = command_instance_->GetCommandDefinition()->GetResults();
   native_types::Object obj;
@@ -93,22 +93,21 @@
 }
 
 void DBusCommandProxy::Abort() {
-  LOG(INFO) << "Received call to Command<"
-            << command_instance_->GetName() << ">::Abort()";
+  LOG(INFO) << "Received call to Command<" << command_instance_->GetName()
+            << ">::Abort()";
   command_instance_->Abort();
 }
 
 void DBusCommandProxy::Cancel() {
-  LOG(INFO) << "Received call to Command<"
-            << command_instance_->GetName() << ">::Cancel()";
+  LOG(INFO) << "Received call to Command<" << command_instance_->GetName()
+            << ">::Cancel()";
   command_instance_->Cancel();
 }
 
 void DBusCommandProxy::Done() {
-  LOG(INFO) << "Received call to Command<"
-            << command_instance_->GetName() << ">::Done()";
+  LOG(INFO) << "Received call to Command<" << command_instance_->GetName()
+            << ">::Done()";
   command_instance_->Done();
 }
 
-
 }  // namespace buffet
diff --git a/libweave/src/commands/dbus_command_proxy_unittest.cc b/libweave/src/commands/dbus_command_proxy_unittest.cc
index c211166..d933958 100644
--- a/libweave/src/commands/dbus_command_proxy_unittest.cc
+++ b/libweave/src/commands/dbus_command_proxy_unittest.cc
@@ -103,10 +103,11 @@
     // Use a mock exported object for the exported object manager.
     mock_exported_object_command_ =
         new dbus::MockExportedObject(bus_.get(), kCmdObjPath);
-    EXPECT_CALL(*bus_, GetExportedObject(kCmdObjPath)).Times(AnyNumber())
+    EXPECT_CALL(*bus_, GetExportedObject(kCmdObjPath))
+        .Times(AnyNumber())
         .WillRepeatedly(Return(mock_exported_object_command_.get()));
-    EXPECT_CALL(*mock_exported_object_command_,
-                ExportMethod(_, _, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*mock_exported_object_command_, ExportMethod(_, _, _, _))
+        .Times(AnyNumber());
 
     std::unique_ptr<CommandProxyInterface> command_proxy(
         new DBusCommandProxy(nullptr, bus_, command_instance_.get(), cmd_path));
@@ -145,8 +146,7 @@
 
 TEST_F(DBusCommandProxyTest, Init) {
   VariantDictionary params = {
-    {"height", int32_t{53}},
-    {"_jumpType", std::string{"_withKick"}},
+      {"height", int32_t{53}}, {"_jumpType", std::string{"_withKick"}},
   };
   EXPECT_EQ(CommandInstance::kStatusQueued, GetCommandAdaptor()->GetStatus());
   EXPECT_EQ(params, GetCommandAdaptor()->GetParameters());
@@ -178,8 +178,7 @@
 TEST_F(DBusCommandProxyTest, SetResults) {
   EXPECT_CALL(*mock_exported_object_command_, SendSignal(_)).Times(1);
   const VariantDictionary results = {
-    {"foo", int32_t{42}},
-    {"bar", std::string{"foobar"}},
+      {"foo", int32_t{42}}, {"bar", std::string{"foobar"}},
   };
   EXPECT_TRUE(GetCommandInterface()->SetResults(nullptr, results));
   EXPECT_EQ(results, GetCommandAdaptor()->GetResults());
@@ -188,7 +187,7 @@
 TEST_F(DBusCommandProxyTest, SetResults_UnknownProperty) {
   EXPECT_CALL(*mock_exported_object_command_, SendSignal(_)).Times(0);
   const VariantDictionary results = {
-    {"quux", int32_t{42}},
+      {"quux", int32_t{42}},
   };
   EXPECT_FALSE(GetCommandInterface()->SetResults(nullptr, results));
 }
@@ -196,8 +195,7 @@
 TEST_F(DBusCommandProxyTest, Abort) {
   EXPECT_CALL(*mock_exported_object_command_, SendSignal(_)).Times(1);
   GetCommandInterface()->Abort();
-  EXPECT_EQ(CommandInstance::kStatusAborted,
-            GetCommandAdaptor()->GetStatus());
+  EXPECT_EQ(CommandInstance::kStatusAborted, GetCommandAdaptor()->GetStatus());
 }
 
 TEST_F(DBusCommandProxyTest, Cancel) {
diff --git a/libweave/src/commands/object_schema.cc b/libweave/src/commands/object_schema.cc
index 0fcf3ac..2fec07b 100644
--- a/libweave/src/commands/object_schema.cc
+++ b/libweave/src/commands/object_schema.cc
@@ -59,10 +59,9 @@
 // Helper function for PropFromJson to handle the case of parameter being
 // defined as a JSON string like this:
 //   "prop":"..."
-std::unique_ptr<PropType> PropFromJsonString(
-    const base::Value& value,
-    const PropType* base_schema,
-    chromeos::ErrorPtr* error) {
+std::unique_ptr<PropType> PropFromJsonString(const base::Value& value,
+                                             const PropType* base_schema,
+                                             chromeos::ErrorPtr* error) {
   std::string type_name;
   CHECK(value.GetAsString(&type_name)) << "Unable to get string value";
   std::unique_ptr<PropType> prop = CreatePropType(type_name, error);
@@ -86,41 +85,41 @@
     const base::Value* first_element = nullptr;
     if (list->Get(0, &first_element)) {
       switch (first_element->GetType()) {
-      case base::Value::TYPE_BOOLEAN:
-        type_name = PropType::GetTypeStringFromType(ValueType::Boolean);
-        break;
-      case base::Value::TYPE_INTEGER:
-        type_name = PropType::GetTypeStringFromType(ValueType::Int);
-        break;
-      case base::Value::TYPE_DOUBLE:
-        type_name = PropType::GetTypeStringFromType(ValueType::Double);
-        break;
-      case base::Value::TYPE_STRING:
-        type_name = PropType::GetTypeStringFromType(ValueType::String);
-        break;
-      case base::Value::TYPE_DICTIONARY:
-        type_name = PropType::GetTypeStringFromType(ValueType::Object);
-        break;
-      case base::Value::TYPE_LIST: {
-        if (allow_arrays) {
-          type_name = PropType::GetTypeStringFromType(ValueType::Array);
-          const base::ListValue* first_element_list = nullptr;
-          if (first_element->GetAsList(&first_element_list)) {
-            // We do not allow arrays of arrays.
-            auto child_type = DetectArrayType(first_element_list, nullptr,
-                                              false);
-            if (child_type.empty()) {
-              type_name.clear();
-            } else {
-              type_name += '.' + child_type;
+        case base::Value::TYPE_BOOLEAN:
+          type_name = PropType::GetTypeStringFromType(ValueType::Boolean);
+          break;
+        case base::Value::TYPE_INTEGER:
+          type_name = PropType::GetTypeStringFromType(ValueType::Int);
+          break;
+        case base::Value::TYPE_DOUBLE:
+          type_name = PropType::GetTypeStringFromType(ValueType::Double);
+          break;
+        case base::Value::TYPE_STRING:
+          type_name = PropType::GetTypeStringFromType(ValueType::String);
+          break;
+        case base::Value::TYPE_DICTIONARY:
+          type_name = PropType::GetTypeStringFromType(ValueType::Object);
+          break;
+        case base::Value::TYPE_LIST: {
+          if (allow_arrays) {
+            type_name = PropType::GetTypeStringFromType(ValueType::Array);
+            const base::ListValue* first_element_list = nullptr;
+            if (first_element->GetAsList(&first_element_list)) {
+              // We do not allow arrays of arrays.
+              auto child_type =
+                  DetectArrayType(first_element_list, nullptr, false);
+              if (child_type.empty()) {
+                type_name.clear();
+              } else {
+                type_name += '.' + child_type;
+              }
             }
           }
+          break;
         }
-        break;
-      }
-      default:
-        // The rest are unsupported.
-        break;
+        default:
+          // The rest are unsupported.
+          break;
       }
     }
   }
@@ -130,10 +129,9 @@
 // Helper function for PropFromJson to handle the case of parameter being
 // defined as a JSON array like this:
 //   "prop":[...]
-std::unique_ptr<PropType> PropFromJsonArray(
-    const base::Value& value,
-    const PropType* base_schema,
-    chromeos::ErrorPtr* error) {
+std::unique_ptr<PropType> PropFromJsonArray(const base::Value& value,
+                                            const PropType* base_schema,
+                                            chromeos::ErrorPtr* error) {
   std::unique_ptr<PropType> prop;
   const base::ListValue* list = nullptr;
   CHECK(value.GetAsList(&list)) << "Unable to get array value";
@@ -203,8 +201,8 @@
 
   // If we have "enum", it's an array. Detect type from array elements.
   const base::ListValue* list = nullptr;
-  if (dict->GetListWithoutPathExpansion(
-      commands::attributes::kOneOf_Enum, &list))
+  if (dict->GetListWithoutPathExpansion(commands::attributes::kOneOf_Enum,
+                                        &list))
     return DetectArrayType(list, base_schema, true);
 
   // If we have "default", try to use it for type detection.
@@ -233,10 +231,9 @@
 // Helper function for PropFromJson to handle the case of parameter being
 // defined as a JSON object like this:
 //   "prop":{...}
-std::unique_ptr<PropType> PropFromJsonObject(
-    const base::Value& value,
-    const PropType* base_schema,
-    chromeos::ErrorPtr* error) {
+std::unique_ptr<PropType> PropFromJsonObject(const base::Value& value,
+                                             const PropType* base_schema,
+                                             chromeos::ErrorPtr* error) {
   std::unique_ptr<PropType> prop;
   const base::DictionaryValue* dict = nullptr;
   CHECK(value.GetAsDictionary(&dict)) << "Unable to get dictionary value";
@@ -265,8 +262,10 @@
 
 }  // anonymous namespace
 
-ObjectSchema::ObjectSchema() {}
-ObjectSchema::~ObjectSchema() {}
+ObjectSchema::ObjectSchema() {
+}
+ObjectSchema::~ObjectSchema() {
+}
 
 std::unique_ptr<ObjectSchema> ObjectSchema::Clone() const {
   std::unique_ptr<ObjectSchema> cloned{new ObjectSchema};
@@ -289,7 +288,8 @@
 }
 
 std::unique_ptr<base::DictionaryValue> ObjectSchema::ToJson(
-    bool full_schema, chromeos::ErrorPtr* error) const {
+    bool full_schema,
+    chromeos::ErrorPtr* error) const {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   for (const auto& pair : properties_) {
     auto PropDef = pair.second->ToJson(full_schema, error);
@@ -341,17 +341,17 @@
     return PropFromJsonObject(value, base_schema, error);
   }
   static const std::map<base::Value::Type, const char*> type_names = {
-    {base::Value::TYPE_NULL, "Null"},
-    {base::Value::TYPE_BOOLEAN, "Boolean"},
-    {base::Value::TYPE_INTEGER, "Integer"},
-    {base::Value::TYPE_DOUBLE, "Double"},
-    {base::Value::TYPE_STRING, "String"},
-    {base::Value::TYPE_BINARY, "Binary"},
-    {base::Value::TYPE_DICTIONARY, "Object"},
-    {base::Value::TYPE_LIST, "Array"},
+      {base::Value::TYPE_NULL, "Null"},
+      {base::Value::TYPE_BOOLEAN, "Boolean"},
+      {base::Value::TYPE_INTEGER, "Integer"},
+      {base::Value::TYPE_DOUBLE, "Double"},
+      {base::Value::TYPE_STRING, "String"},
+      {base::Value::TYPE_BINARY, "Binary"},
+      {base::Value::TYPE_DICTIONARY, "Object"},
+      {base::Value::TYPE_LIST, "Array"},
   };
-  const char* type_name = chromeos::GetOrDefault(type_names, value.GetType(),
-                                                 "<unknown>");
+  const char* type_name =
+      chromeos::GetOrDefault(type_names, value.GetType(), "<unknown>");
   chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
                                errors::commands::kUnknownType,
                                "Unexpected JSON value type: %s", type_name);
diff --git a/libweave/src/commands/object_schema.h b/libweave/src/commands/object_schema.h
index 4add1c7..d6eafed 100644
--- a/libweave/src/commands/object_schema.h
+++ b/libweave/src/commands/object_schema.h
@@ -63,7 +63,8 @@
   // then all properties and constraints are saved, otherwise, only
   // the overridden (not inherited) ones are saved.
   std::unique_ptr<base::DictionaryValue> ToJson(
-      bool full_schema, chromeos::ErrorPtr* error) const;
+      bool full_schema,
+      chromeos::ErrorPtr* error) const;
 
   // Loads the object schema from JSON. If |object_schema| is not nullptr, it is
   // used as a base schema to inherit omitted properties and constraints from.
diff --git a/libweave/src/commands/object_schema_unittest.cc b/libweave/src/commands/object_schema_unittest.cc
index 04ca232..12bf8a5 100644
--- a/libweave/src/commands/object_schema_unittest.cc
+++ b/libweave/src/commands/object_schema_unittest.cc
@@ -73,11 +73,10 @@
   IntPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_JSON_EQ("{}", *param2.ToJson(false, nullptr));
-  param2.FromJson(CreateDictionaryValue("{'minimum':3}").get(),
-                  &prop, nullptr);
+  param2.FromJson(CreateDictionaryValue("{'minimum':3}").get(), &prop, nullptr);
   EXPECT_JSON_EQ("{'minimum':3}", *param2.ToJson(false, nullptr));
-  param2.FromJson(CreateDictionaryValue("{'maximum':-7}").get(),
-                  &prop, nullptr);
+  param2.FromJson(CreateDictionaryValue("{'maximum':-7}").get(), &prop,
+                  nullptr);
   EXPECT_JSON_EQ("{'maximum':-7}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'minimum':0,'maximum':5}").get(),
                   &prop, nullptr);
@@ -85,8 +84,8 @@
   param2.FromJson(CreateDictionaryValue("{'enum':[1,2,3]}").get(), &prop,
                   nullptr);
   EXPECT_JSON_EQ("[1,2,3]", *param2.ToJson(false, nullptr));
-  param2.FromJson(CreateDictionaryValue("{'default':123}").get(),
-                  &prop, nullptr);
+  param2.FromJson(CreateDictionaryValue("{'default':123}").get(), &prop,
+                  nullptr);
   EXPECT_JSON_EQ("{'default':123}", *param2.ToJson(false, nullptr));
 }
 
@@ -100,14 +99,13 @@
   EXPECT_EQ(2, prop.GetMinValue());
   EXPECT_EQ(8, prop.GetMaxValue());
   prop.AddMinMaxConstraint(-2, 30);
-  param2.FromJson(CreateDictionaryValue("{'minimum':7}").get(),
-                  &prop, nullptr);
+  param2.FromJson(CreateDictionaryValue("{'minimum':7}").get(), &prop, nullptr);
   EXPECT_TRUE(param2.HasOverriddenAttributes());
   EXPECT_TRUE(param2.IsBasedOnSchema());
   EXPECT_EQ(7, param2.GetMinValue());
   EXPECT_EQ(30, param2.GetMaxValue());
-  param2.FromJson(CreateDictionaryValue("{'maximum':17}").get(),
-                  &prop, nullptr);
+  param2.FromJson(CreateDictionaryValue("{'maximum':17}").get(), &prop,
+                  nullptr);
   EXPECT_TRUE(param2.HasOverriddenAttributes());
   EXPECT_TRUE(param2.IsBasedOnSchema());
   EXPECT_EQ(-2, param2.GetMinValue());
@@ -198,15 +196,14 @@
   EXPECT_JSON_EQ("[true,false]", *param2.ToJson(false, nullptr));
   EXPECT_JSON_EQ("{'enum':[true,false],'type':'boolean'}",
                  *param2.ToJson(true, nullptr));
-  param2.FromJson(CreateDictionaryValue("{'default':true}").get(),
-                  &prop, nullptr);
+  param2.FromJson(CreateDictionaryValue("{'default':true}").get(), &prop,
+                  nullptr);
   EXPECT_JSON_EQ("{'default':true}", *param2.ToJson(false, nullptr));
 }
 
 TEST(CommandSchema, BoolPropType_FromJson) {
   BooleanPropType prop;
-  prop.FromJson(CreateDictionaryValue("{'enum':[true]}").get(), &prop,
-                nullptr);
+  prop.FromJson(CreateDictionaryValue("{'enum':[true]}").get(), &prop, nullptr);
   BooleanPropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_FALSE(param2.HasOverriddenAttributes());
@@ -224,8 +221,7 @@
 
 TEST(CommandSchema, BoolPropType_Validate) {
   BooleanPropType prop;
-  prop.FromJson(CreateDictionaryValue("{'enum':[true]}").get(), &prop,
-                nullptr);
+  prop.FromJson(CreateDictionaryValue("{'enum':[true]}").get(), &prop, nullptr);
   chromeos::ErrorPtr error;
   EXPECT_FALSE(prop.ValidateValue(CreateValue("false").get(), &error));
   EXPECT_EQ("out_of_range", error->GetCode());
@@ -284,8 +280,7 @@
   DoublePropType param2;
   param2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_JSON_EQ("{}", *param2.ToJson(false, nullptr));
-  param2.FromJson(CreateDictionaryValue("{'minimum':3}").get(), &prop,
-                  nullptr);
+  param2.FromJson(CreateDictionaryValue("{'minimum':3}").get(), &prop, nullptr);
   EXPECT_JSON_EQ("{'minimum':3.0}", *param2.ToJson(false, nullptr));
   param2.FromJson(CreateDictionaryValue("{'maximum':-7}").get(), &prop,
                   nullptr);
@@ -294,8 +289,8 @@
                   &prop, nullptr);
   EXPECT_JSON_EQ("{'maximum':5.0,'minimum':0.0}",
                  *param2.ToJson(false, nullptr));
-  param2.FromJson(CreateDictionaryValue("{'default':12.3}").get(),
-                  &prop, nullptr);
+  param2.FromJson(CreateDictionaryValue("{'default':12.3}").get(), &prop,
+                  nullptr);
   EXPECT_JSON_EQ("{'default':12.3}", *param2.ToJson(false, nullptr));
 }
 
@@ -309,8 +304,7 @@
   EXPECT_DOUBLE_EQ(2.5, prop.GetMinValue());
   EXPECT_DOUBLE_EQ(8.7, prop.GetMaxValue());
   prop.AddMinMaxConstraint(-2.2, 30.4);
-  param2.FromJson(CreateDictionaryValue("{'minimum':7}").get(), &prop,
-                  nullptr);
+  param2.FromJson(CreateDictionaryValue("{'minimum':7}").get(), &prop, nullptr);
   EXPECT_TRUE(param2.HasOverriddenAttributes());
   EXPECT_TRUE(param2.IsBasedOnSchema());
   EXPECT_DOUBLE_EQ(7.0, param2.GetMinValue());
@@ -413,8 +407,8 @@
                   &prop, nullptr);
   EXPECT_JSON_EQ("{'maxLength':5,'minLength':0}",
                  *param2.ToJson(false, nullptr));
-  param2.FromJson(CreateDictionaryValue("{'default':'abcd'}").get(),
-                  &prop, nullptr);
+  param2.FromJson(CreateDictionaryValue("{'default':'abcd'}").get(), &prop,
+                  nullptr);
   EXPECT_JSON_EQ("{'default':'abcd'}", *param2.ToJson(false, nullptr));
 }
 
@@ -440,8 +434,8 @@
   EXPECT_TRUE(param2.IsBasedOnSchema());
   EXPECT_EQ(3, param2.GetMinLength());
   EXPECT_EQ(8, param2.GetMaxLength());
-  param2.FromJson(CreateDictionaryValue(
-      "{'minLength':1,'maxLength':7}").get(), &prop, nullptr);
+  param2.FromJson(CreateDictionaryValue("{'minLength':1,'maxLength':7}").get(),
+                  &prop, nullptr);
   EXPECT_TRUE(param2.HasOverriddenAttributes());
   EXPECT_TRUE(param2.IsBasedOnSchema());
   EXPECT_EQ(1, param2.GetMinLength());
@@ -567,9 +561,11 @@
   EXPECT_JSON_EQ(expected, *prop2.ToJson(true, nullptr));
 
   ObjectPropType prop3;
-  ASSERT_TRUE(prop3.FromJson(CreateDictionaryValue(
-      "{'default':{'expires':3,'password':'abracadabra'}}").get(), &prop2,
-      nullptr));
+  ASSERT_TRUE(
+      prop3.FromJson(CreateDictionaryValue(
+                         "{'default':{'expires':3,'password':'abracadabra'}}")
+                         .get(),
+                     &prop2, nullptr));
   expected = R"({
     'default': {
       'expires': 3,
@@ -599,10 +595,12 @@
   EXPECT_JSON_EQ(expected, *prop3.ToJson(true, nullptr));
 
   ObjectPropType prop4;
-  ASSERT_TRUE(prop4.FromJson(CreateDictionaryValue(
-      "{'additionalProperties':true,"
-      "'default':{'expires':3,'password':'abracadabra'}}").get(), &prop2,
-      nullptr));
+  ASSERT_TRUE(
+      prop4.FromJson(CreateDictionaryValue(
+                         "{'additionalProperties':true,"
+                         "'default':{'expires':3,'password':'abracadabra'}}")
+                         .get(),
+                     &prop2, nullptr));
   expected = R"({
     'additionalProperties': true,
     'default': {
@@ -642,9 +640,10 @@
 
 TEST(CommandSchema, ObjectPropType_FromJson) {
   ObjectPropType base_prop;
-  EXPECT_TRUE(base_prop.FromJson(CreateDictionaryValue(
-      "{'properties':{'name':'string','age':'integer'}}").get(), nullptr,
-      nullptr));
+  EXPECT_TRUE(base_prop.FromJson(
+      CreateDictionaryValue("{'properties':{'name':'string','age':'integer'}}")
+          .get(),
+      nullptr, nullptr));
   auto schema = base_prop.GetObject()->GetObjectSchemaPtr();
   const PropType* prop = schema->GetProp("name");
   EXPECT_EQ(ValueType::String, prop->GetType());
@@ -652,9 +651,12 @@
   EXPECT_EQ(ValueType::Int, prop->GetType());
 
   ObjectPropType prop2;
-  ASSERT_TRUE(prop2.FromJson(CreateDictionaryValue(
-      "{'properties':{'name':'string','age':'integer'},"
-      "'default':{'name':'Bob','age':33}}").get(), nullptr, nullptr));
+  ASSERT_TRUE(
+      prop2.FromJson(CreateDictionaryValue(
+                         "{'properties':{'name':'string','age':'integer'},"
+                         "'default':{'name':'Bob','age':33}}")
+                         .get(),
+                     nullptr, nullptr));
   ASSERT_NE(nullptr, prop2.GetDefaultValue());
   const ObjectValue* defval = prop2.GetDefaultValue()->GetObject();
   ASSERT_NE(nullptr, defval);
@@ -666,26 +668,26 @@
 TEST(CommandSchema, ObjectPropType_Validate) {
   ObjectPropType prop;
   prop.FromJson(CreateDictionaryValue(
-      "{'properties':{'expires':'integer',"
-      "'password':{'maxLength':100,'minLength':6}}}").get(), nullptr,
-      nullptr);
+                    "{'properties':{'expires':'integer',"
+                    "'password':{'maxLength':100,'minLength':6}}}")
+                    .get(),
+                nullptr, nullptr);
   chromeos::ErrorPtr error;
-  EXPECT_TRUE(prop.ValidateValue(CreateValue(
-      "{'expires':10,'password':'abcdef'}").get(), &error));
+  EXPECT_TRUE(prop.ValidateValue(
+      CreateValue("{'expires':10,'password':'abcdef'}").get(), &error));
   error.reset();
 
-  EXPECT_FALSE(prop.ValidateValue(CreateValue(
-      "{'expires':10}").get(), &error));
+  EXPECT_FALSE(prop.ValidateValue(CreateValue("{'expires':10}").get(), &error));
   EXPECT_EQ("parameter_missing", error->GetCode());
   error.reset();
 
-  EXPECT_FALSE(prop.ValidateValue(CreateValue(
-      "{'password':'abcdef'}").get(), &error));
+  EXPECT_FALSE(
+      prop.ValidateValue(CreateValue("{'password':'abcdef'}").get(), &error));
   EXPECT_EQ("parameter_missing", error->GetCode());
   error.reset();
 
-  EXPECT_FALSE(prop.ValidateValue(CreateValue(
-      "{'expires':10,'password':'abcde'}").get(), &error));
+  EXPECT_FALSE(prop.ValidateValue(
+      CreateValue("{'expires':10,'password':'abcde'}").get(), &error));
   EXPECT_EQ("out_of_range", error->GetFirstError()->GetCode());
   error.reset();
 
@@ -693,29 +695,32 @@
   EXPECT_EQ("type_mismatch", error->GetCode());
   error.reset();
 
-  EXPECT_FALSE(prop.ValidateValue(CreateValue(
-      "{'expires':10,'password':'abcdef','retry':true}").get(), &error));
+  EXPECT_FALSE(prop.ValidateValue(
+      CreateValue("{'expires':10,'password':'abcdef','retry':true}").get(),
+      &error));
   EXPECT_EQ("unexpected_parameter", error->GetCode());
   error.reset();
 }
 
 TEST(CommandSchema, ObjectPropType_Validate_Enum) {
   ObjectPropType prop;
-  EXPECT_TRUE(prop.FromJson(CreateDictionaryValue(
-      "{'properties':{'width':'integer','height':'integer'},"
-      "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}").get(),
+  EXPECT_TRUE(prop.FromJson(
+      CreateDictionaryValue(
+          "{'properties':{'width':'integer','height':'integer'},"
+          "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}")
+          .get(),
       nullptr, nullptr));
   chromeos::ErrorPtr error;
-  EXPECT_TRUE(prop.ValidateValue(CreateValue(
-      "{'height':20,'width':10}").get(), &error));
+  EXPECT_TRUE(prop.ValidateValue(CreateValue("{'height':20,'width':10}").get(),
+                                 &error));
   error.reset();
 
-  EXPECT_TRUE(prop.ValidateValue(CreateValue(
-      "{'height':200,'width':100}").get(), &error));
+  EXPECT_TRUE(prop.ValidateValue(
+      CreateValue("{'height':200,'width':100}").get(), &error));
   error.reset();
 
-  EXPECT_FALSE(prop.ValidateValue(CreateValue(
-      "{'height':12,'width':10}").get(), &error));
+  EXPECT_FALSE(prop.ValidateValue(CreateValue("{'height':12,'width':10}").get(),
+                                  &error));
   EXPECT_EQ("out_of_range", error->GetCode());
   error.reset();
 }
@@ -723,9 +728,11 @@
 TEST(CommandSchema, ObjectPropType_CreateValue) {
   ObjectPropType prop;
   IntPropType int_type;
-  ASSERT_TRUE(prop.FromJson(CreateDictionaryValue(
-      "{'properties':{'width':'integer','height':'integer'},"
-      "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}").get(),
+  ASSERT_TRUE(prop.FromJson(
+      CreateDictionaryValue(
+          "{'properties':{'width':'integer','height':'integer'},"
+          "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}")
+          .get(),
       nullptr, nullptr));
   native_types::Object obj{
       {"width", int_type.CreateValue(10, nullptr)},
@@ -779,8 +786,8 @@
   prop2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
   EXPECT_JSON_EQ("{}", *prop2.ToJson(false, nullptr));
   EXPECT_TRUE(prop2.IsBasedOnSchema());
-  prop2.FromJson(CreateDictionaryValue("{'default':[1,2,3]}").get(),
-                 &prop, nullptr);
+  prop2.FromJson(CreateDictionaryValue("{'default':[1,2,3]}").get(), &prop,
+                 nullptr);
   EXPECT_JSON_EQ("{'default':[1,2,3]}", *prop2.ToJson(false, nullptr));
   EXPECT_JSON_EQ(
       "{'default':[1,2,3],'items':{'type':'integer'},'type':'array'}",
@@ -789,14 +796,16 @@
 
 TEST(CommandSchema, ArrayPropType_FromJson) {
   ArrayPropType prop;
-  EXPECT_TRUE(prop.FromJson(
-      CreateDictionaryValue("{'items':'integer'}").get(), nullptr, nullptr));
+  EXPECT_TRUE(prop.FromJson(CreateDictionaryValue("{'items':'integer'}").get(),
+                            nullptr, nullptr));
   EXPECT_EQ(ValueType::Int, prop.GetItemTypePtr()->GetType());
 
   ArrayPropType prop2;
-  ASSERT_TRUE(prop2.FromJson(CreateDictionaryValue(
-    "{'items':'string','default':['foo', 'bar', 'baz']}").get(), nullptr,
-      nullptr));
+  ASSERT_TRUE(
+      prop2.FromJson(CreateDictionaryValue(
+                         "{'items':'string','default':['foo', 'bar', 'baz']}")
+                         .get(),
+                     nullptr, nullptr));
   ASSERT_NE(nullptr, prop2.GetDefaultValue());
   const ArrayValue* defval = prop2.GetDefaultValue()->GetArray();
   ASSERT_NE(nullptr, defval);
@@ -806,9 +815,9 @@
 
 TEST(CommandSchema, ArrayPropType_Validate) {
   ArrayPropType prop;
-  prop.FromJson(CreateDictionaryValue(
-      "{'items':{'minimum':2.3, 'maximum':10.5}}").get(), nullptr,
-      nullptr);
+  prop.FromJson(
+      CreateDictionaryValue("{'items':{'minimum':2.3, 'maximum':10.5}}").get(),
+      nullptr, nullptr);
 
   chromeos::ErrorPtr error;
   EXPECT_TRUE(prop.ValidateValue(CreateValue("[3,4,10.5]").get(), &error));
@@ -829,9 +838,10 @@
 
 TEST(CommandSchema, ArrayPropType_Validate_Enum) {
   ArrayPropType prop;
-  prop.FromJson(CreateDictionaryValue(
-      "{'items':'integer', 'enum':[[1], [2,3], [4,5,6]]}").get(), nullptr,
-      nullptr);
+  prop.FromJson(
+      CreateDictionaryValue("{'items':'integer', 'enum':[[1], [2,3], [4,5,6]]}")
+          .get(),
+      nullptr, nullptr);
 
   chromeos::ErrorPtr error;
   EXPECT_TRUE(prop.ValidateValue(CreateValue("[2,3]").get(), &error));
@@ -850,8 +860,10 @@
 
 TEST(CommandSchema, ArrayPropType_CreateValue) {
   ArrayPropType prop;
-  ASSERT_TRUE(prop.FromJson(CreateDictionaryValue(
-      "{'items':{'properties':{'width':'integer','height':'integer'}}}").get(),
+  ASSERT_TRUE(prop.FromJson(
+      CreateDictionaryValue(
+          "{'items':{'properties':{'width':'integer','height':'integer'}}}")
+          .get(),
       nullptr, nullptr));
 
   chromeos::ErrorPtr error;
@@ -865,8 +877,10 @@
 
   IntPropType int_type;
   ObjectPropType obj_type;
-  ASSERT_TRUE(obj_type.FromJson(CreateDictionaryValue(
-      "{'properties':{'width':'integer','height':'integer'}}").get(),
+  ASSERT_TRUE(obj_type.FromJson(
+      CreateDictionaryValue(
+          "{'properties':{'width':'integer','height':'integer'}}")
+          .get(),
       nullptr, nullptr));
   arr.push_back(obj_type.CreateValue(
       native_types::Object{
@@ -897,8 +911,9 @@
 TEST(CommandSchema, ArrayPropType_NestedArrays_NotSupported) {
   ArrayPropType prop;
   chromeos::ErrorPtr error;
-  EXPECT_FALSE(prop.FromJson(CreateDictionaryValue(
-      "{'items':{'items':'integer'}}").get(), nullptr, &error));
+  EXPECT_FALSE(prop.FromJson(
+      CreateDictionaryValue("{'items':{'items':'integer'}}").get(), nullptr,
+      &error));
   EXPECT_EQ(errors::commands::kInvalidObjectSchema, error->GetCode());
   error.reset();
 }
@@ -907,7 +922,8 @@
 
 TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeName) {
   ObjectSchema schema;
-  const char* schema_str = "{"
+  const char* schema_str =
+      "{"
       "'param1':'integer',"
       "'param2':'number',"
       "'param3':'string'"
@@ -936,7 +952,8 @@
 
 TEST(CommandSchema, ObjectSchema_FromJson_Full_TypeName) {
   ObjectSchema schema;
-  const char* schema_str = "{"
+  const char* schema_str =
+      "{"
       "'param1':{'type':'integer'},"
       "'param2':{'type':'number'},"
       "'param3':{'type':'string'},"
@@ -971,7 +988,8 @@
 
 TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeDeduction_Scalar) {
   ObjectSchema schema;
-  const char* schema_str = "{"
+  const char* schema_str =
+      "{"
       "'param1' :{'minimum':2},"
       "'param2' :{'maximum':10},"
       "'param3' :{'maximum':8, 'minimum':2},"
@@ -1011,12 +1029,10 @@
   EXPECT_EQ("string", schema.GetProp("param16")->GetTypeAsString());
   EXPECT_EQ("array", schema.GetProp("param17")->GetTypeAsString());
   auto prop17 = schema.GetProp("param17");
-  EXPECT_EQ("integer",
-            prop17->GetArray()->GetItemTypePtr()->GetTypeAsString());
+  EXPECT_EQ("integer", prop17->GetArray()->GetItemTypePtr()->GetTypeAsString());
   EXPECT_EQ("array", schema.GetProp("param18")->GetTypeAsString());
   auto prop18 = schema.GetProp("param18");
-  EXPECT_EQ("number",
-            prop18->GetArray()->GetItemTypePtr()->GetTypeAsString());
+  EXPECT_EQ("number", prop18->GetArray()->GetItemTypePtr()->GetTypeAsString());
 
   int min_int = (std::numeric_limits<int>::min)();
   int max_int = (std::numeric_limits<int>::max)();
@@ -1065,7 +1081,8 @@
 
 TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeDeduction_Array) {
   ObjectSchema schema;
-  const char* schema_str = "{"
+  const char* schema_str =
+      "{"
       "'param1' :[0,1,2,3],"
       "'param2' :[0.0,1.1,2.2],"
       "'param3' :['id1', 'id2'],"
@@ -1079,7 +1096,7 @@
       "'param11':[[0,1],[2,3]],"
       "'param12':[['foo','bar']],"
       "'param13':{'enum':[['id0', 'id1']]}"
-     "}";
+      "}";
   EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
                               nullptr));
   EXPECT_EQ("integer", schema.GetProp("param1")->GetTypeAsString());
@@ -1130,7 +1147,8 @@
 }
 
 TEST(CommandSchema, ObjectSchema_FromJson_Inheritance) {
-  const char* base_schema_str = "{"
+  const char* base_schema_str =
+      "{"
       "'param0' :{'minimum':1, 'maximum':5},"
       "'param1' :{'minimum':1, 'maximum':5},"
       "'param2' :{'minimum':1, 'maximum':5},"
@@ -1158,7 +1176,8 @@
   ObjectSchema base_schema;
   EXPECT_TRUE(base_schema.FromJson(CreateDictionaryValue(base_schema_str).get(),
                                    nullptr, nullptr));
-  const char* schema_str = "{"
+  const char* schema_str =
+      "{"
       "'param1' :{},"
       "'param2' :{'minimum':2},"
       "'param3' :{'maximum':9},"
@@ -1254,17 +1273,18 @@
 
 TEST(CommandSchema, ObjectSchema_UseDefaults) {
   ObjectPropType prop;
-  const char* schema_str = "{'properties':{"
+  const char* schema_str =
+      "{'properties':{"
       "'param1':{'default':true},"
       "'param2':{'default':2},"
       "'param3':{'default':3.3},"
       "'param4':{'default':'four'},"
       "'param5':{'default':{'x':5,'y':6},"
-                "'properties':{'x':'integer','y':'integer'}},"
+      "'properties':{'x':'integer','y':'integer'}},"
       "'param6':{'default':[1,2,3]}"
       "}}";
-  ASSERT_TRUE(prop.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
-                            nullptr));
+  ASSERT_TRUE(
+      prop.FromJson(CreateDictionaryValue(schema_str).get(), nullptr, nullptr));
 
   // Omit all.
   auto value = prop.CreateValue();
@@ -1282,7 +1302,8 @@
 
   // Specify some.
   value = prop.CreateValue();
-  const char* val_json = "{"
+  const char* val_json =
+      "{"
       "'param1':false,"
       "'param3':33.3,"
       "'param5':{'x':-5,'y':-6}"
@@ -1301,7 +1322,8 @@
 
   // Specify all.
   value = prop.CreateValue();
-  val_json = "{"
+  val_json =
+      "{"
       "'param1':false,"
       "'param2':22,"
       "'param3':333.3,"
@@ -1325,7 +1347,8 @@
 TEST(CommandSchema, ObjectSchema_FromJson_BaseSchema_Failures) {
   ObjectSchema schema;
   chromeos::ErrorPtr error;
-  const char* schema_str = "{"
+  const char* schema_str =
+      "{"
       "'param1':{}"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1333,7 +1356,8 @@
   EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':{'type':'foo'}"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1341,7 +1365,8 @@
   EXPECT_EQ("unknown_type", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':[]"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1349,7 +1374,8 @@
   EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':{'minimum':'foo'}"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1357,7 +1383,8 @@
   EXPECT_EQ("type_mismatch", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':[1,2.2]"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1365,7 +1392,8 @@
   EXPECT_EQ("type_mismatch", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':{'minimum':1, 'enum':[1,2,3]}"  // can't have min/max & enum.
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1373,7 +1401,8 @@
   EXPECT_EQ("unexpected_parameter", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':{'maximum':1, 'blah':2}"  // 'blah' is unexpected.
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1381,7 +1410,8 @@
   EXPECT_EQ("unexpected_parameter", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':{'enum':[1,2,3],'default':5}"  // 'default' must be 1, 2, or 3.
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1389,7 +1419,8 @@
   EXPECT_EQ("out_of_range", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':[[1,2.3]]"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1397,7 +1428,8 @@
   EXPECT_EQ("type_mismatch", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':[[1,2],[3,4],['blah']]"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1405,7 +1437,8 @@
   EXPECT_EQ("type_mismatch", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':{'default':[]}"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1413,7 +1446,8 @@
   EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':[[[1]],[[2]]]"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1421,7 +1455,8 @@
   EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':{'enum':[[['foo']]]}"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
@@ -1429,7 +1464,8 @@
   EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
   error.reset();
 
-  schema_str = "{"
+  schema_str =
+      "{"
       "'param1':{'default':[[1],[2]]}"
       "}";
   EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
diff --git a/libweave/src/commands/prop_constraints.cc b/libweave/src/commands/prop_constraints.cc
index c8f78e4..29d3348 100644
--- a/libweave/src/commands/prop_constraints.cc
+++ b/libweave/src/commands/prop_constraints.cc
@@ -26,7 +26,8 @@
 }  // anonymous namespace
 
 // Constraint ----------------------------------------------------------------
-Constraint::~Constraint() {}
+Constraint::~Constraint() {
+}
 
 bool Constraint::ReportErrorLessThan(chromeos::ErrorPtr* error,
                                      const std::string& val,
@@ -34,8 +35,8 @@
   chromeos::Error::AddToPrintf(
       error, FROM_HERE, errors::commands::kDomain,
       errors::commands::kOutOfRange,
-      "Value %s is out of range. It must not be less than %s",
-      val.c_str(), limit.c_str());
+      "Value %s is out of range. It must not be less than %s", val.c_str(),
+      limit.c_str());
   return false;
 }
 
@@ -45,8 +46,8 @@
   chromeos::Error::AddToPrintf(
       error, FROM_HERE, errors::commands::kDomain,
       errors::commands::kOutOfRange,
-      "Value %s is out of range. It must not be greater than %s",
-      val.c_str(), limit.c_str());
+      "Value %s is out of range. It must not be greater than %s", val.c_str(),
+      limit.c_str());
   return false;
 }
 
@@ -75,8 +76,11 @@
 
 // ConstraintStringLength -----------------------------------------------------
 ConstraintStringLength::ConstraintStringLength(
-    const InheritableAttribute<int>& limit) : limit_(limit) {}
-ConstraintStringLength::ConstraintStringLength(int limit) : limit_(limit) {}
+    const InheritableAttribute<int>& limit)
+    : limit_(limit) {
+}
+ConstraintStringLength::ConstraintStringLength(int limit) : limit_(limit) {
+}
 
 bool ConstraintStringLength::HasOverriddenAttributes() const {
   return !limit_.is_inherited;
@@ -89,9 +93,12 @@
 
 // ConstraintStringLengthMin --------------------------------------------------
 ConstraintStringLengthMin::ConstraintStringLengthMin(
-    const InheritableAttribute<int>& limit) : ConstraintStringLength(limit) {}
+    const InheritableAttribute<int>& limit)
+    : ConstraintStringLength(limit) {
+}
 ConstraintStringLengthMin::ConstraintStringLengthMin(int limit)
-    : ConstraintStringLength(limit) {}
+    : ConstraintStringLength(limit) {
+}
 
 bool ConstraintStringLengthMin::Validate(const PropValue& value,
                                          chromeos::ErrorPtr* error) const {
@@ -115,22 +122,24 @@
   return true;
 }
 
-std::unique_ptr<Constraint>
-ConstraintStringLengthMin::Clone() const {
+std::unique_ptr<Constraint> ConstraintStringLengthMin::Clone() const {
   return std::unique_ptr<Constraint>{new ConstraintStringLengthMin{limit_}};
 }
 
-std::unique_ptr<Constraint>
-ConstraintStringLengthMin::CloneAsInherited() const {
+std::unique_ptr<Constraint> ConstraintStringLengthMin::CloneAsInherited()
+    const {
   return std::unique_ptr<Constraint>{
       new ConstraintStringLengthMin{limit_.value}};
 }
 
 // ConstraintStringLengthMax --------------------------------------------------
 ConstraintStringLengthMax::ConstraintStringLengthMax(
-    const InheritableAttribute<int>& limit) : ConstraintStringLength(limit) {}
+    const InheritableAttribute<int>& limit)
+    : ConstraintStringLength(limit) {
+}
 ConstraintStringLengthMax::ConstraintStringLengthMax(int limit)
-    : ConstraintStringLength(limit) {}
+    : ConstraintStringLength(limit) {
+}
 
 bool ConstraintStringLengthMax::Validate(const PropValue& value,
                                          chromeos::ErrorPtr* error) const {
@@ -148,22 +157,23 @@
   return true;
 }
 
-std::unique_ptr<Constraint>
-ConstraintStringLengthMax::Clone() const {
+std::unique_ptr<Constraint> ConstraintStringLengthMax::Clone() const {
   return std::unique_ptr<Constraint>{new ConstraintStringLengthMax{limit_}};
 }
 
-std::unique_ptr<Constraint>
-ConstraintStringLengthMax::CloneAsInherited() const {
+std::unique_ptr<Constraint> ConstraintStringLengthMax::CloneAsInherited()
+    const {
   return std::unique_ptr<Constraint>{
       new ConstraintStringLengthMax{limit_.value}};
 }
 
 // ConstraintOneOf --------------------------------------------------
 ConstraintOneOf::ConstraintOneOf(InheritableAttribute<native_types::Array> set)
-    : set_(std::move(set)) {}
+    : set_(std::move(set)) {
+}
 ConstraintOneOf::ConstraintOneOf(native_types::Array set)
-    : set_(std::move(set)) {}
+    : set_(std::move(set)) {
+}
 
 bool ConstraintOneOf::Validate(const PropValue& value,
                                chromeos::ErrorPtr* error) const {
diff --git a/libweave/src/commands/prop_constraints.h b/libweave/src/commands/prop_constraints.h
index ccfaaf0..71d273a 100644
--- a/libweave/src/commands/prop_constraints.h
+++ b/libweave/src/commands/prop_constraints.h
@@ -20,13 +20,7 @@
 
 namespace buffet {
 
-enum class ConstraintType {
-  Min,
-  Max,
-  StringLengthMin,
-  StringLengthMax,
-  OneOf
-};
+enum class ConstraintType { Min, Max, StringLengthMin, StringLengthMax, OneOf };
 
 // Abstract base class for all parameter constraints. Many constraints are
 // type-dependent. Thus, a numeric parameter could have "minimum" and/or
@@ -102,18 +96,15 @@
 
 // ConstraintMinMaxBase is a base class for numeric Minimum and Maximum
 // constraints.
-template<typename T>
+template <typename T>
 class ConstraintMinMaxBase : public Constraint {
  public:
   explicit ConstraintMinMaxBase(const InheritableAttribute<T>& limit)
       : limit_(limit) {}
-  explicit ConstraintMinMaxBase(const T& limit)
-      : limit_(limit) {}
+  explicit ConstraintMinMaxBase(const T& limit) : limit_(limit) {}
 
   // Implementation of Constraint::HasOverriddenAttributes().
-  bool HasOverriddenAttributes() const override {
-    return !limit_.is_inherited;
-  }
+  bool HasOverriddenAttributes() const override { return !limit_.is_inherited; }
 
   // Implementation of Constraint::ToJson().
   std::unique_ptr<base::Value> ToJson(
@@ -131,13 +122,12 @@
 };
 
 // Implementation of Minimum value constraint for Integer/Double types.
-template<typename T>
+template <typename T>
 class ConstraintMin : public ConstraintMinMaxBase<T> {
  public:
   explicit ConstraintMin(const InheritableAttribute<T>& limit)
       : ConstraintMinMaxBase<T>(limit) {}
-  explicit ConstraintMin(const T& limit)
-      : ConstraintMinMaxBase<T>(limit) {}
+  explicit ConstraintMin(const T& limit) : ConstraintMinMaxBase<T>(limit) {}
 
   // Implementation of Constraint::GetType().
   ConstraintType GetType() const override { return ConstraintType::Min; }
@@ -173,13 +163,12 @@
 };
 
 // Implementation of Maximum value constraint for Integer/Double types.
-template<typename T>
+template <typename T>
 class ConstraintMax : public ConstraintMinMaxBase<T> {
  public:
   explicit ConstraintMax(const InheritableAttribute<T>& limit)
       : ConstraintMinMaxBase<T>(limit) {}
-  explicit ConstraintMax(const T& limit)
-      : ConstraintMinMaxBase<T>(limit) {}
+  explicit ConstraintMax(const T& limit) : ConstraintMinMaxBase<T>(limit) {}
 
   // Implementation of Constraint::GetType().
   ConstraintType GetType() const override { return ConstraintType::Max; }
@@ -301,14 +290,10 @@
   explicit ConstraintOneOf(native_types::Array set);
 
   // Implementation of Constraint::GetType().
-  ConstraintType GetType() const override {
-    return ConstraintType::OneOf;
-  }
+  ConstraintType GetType() const override { return ConstraintType::OneOf; }
 
   // Implementation of Constraint::HasOverriddenAttributes().
-  bool HasOverriddenAttributes() const override {
-    return !set_.is_inherited;
-  }
+  bool HasOverriddenAttributes() const override { return !set_.is_inherited; }
 
   // Implementation of Constraint::Validate().
   bool Validate(const PropValue& value,
diff --git a/libweave/src/commands/prop_types.cc b/libweave/src/commands/prop_types.cc
index 8da4260..bfd1b50 100644
--- a/libweave/src/commands/prop_types.cc
+++ b/libweave/src/commands/prop_types.cc
@@ -225,12 +225,12 @@
 
 const PropType::TypeMap& PropType::GetTypeMap() {
   static TypeMap map = {
-    {ValueType::Int,         "integer"},
-    {ValueType::Double,      "number"},
-    {ValueType::String,      "string"},
-    {ValueType::Boolean,     "boolean"},
-    {ValueType::Object,      "object"},
-    {ValueType::Array,       "array"},
+      {ValueType::Int, "integer"},
+      {ValueType::Double, "number"},
+      {ValueType::String, "string"},
+      {ValueType::Boolean, "boolean"},
+      {ValueType::Object, "object"},
+      {ValueType::Array, "array"},
   };
   return map;
 }
@@ -257,37 +257,37 @@
 std::unique_ptr<PropType> PropType::Create(ValueType type) {
   PropType* prop = nullptr;
   switch (type) {
-  case buffet::ValueType::Int:
-    prop = new IntPropType;
-    break;
-  case buffet::ValueType::Double:
-    prop = new DoublePropType;
-    break;
-  case buffet::ValueType::String:
-    prop = new StringPropType;
-    break;
-  case buffet::ValueType::Boolean:
-    prop = new BooleanPropType;
-    break;
-  case buffet::ValueType::Object:
-    prop = new ObjectPropType;
-    break;
-  case buffet::ValueType::Array:
-    prop = new ArrayPropType;
-    break;
+    case buffet::ValueType::Int:
+      prop = new IntPropType;
+      break;
+    case buffet::ValueType::Double:
+      prop = new DoublePropType;
+      break;
+    case buffet::ValueType::String:
+      prop = new StringPropType;
+      break;
+    case buffet::ValueType::Boolean:
+      prop = new BooleanPropType;
+      break;
+    case buffet::ValueType::Object:
+      prop = new ObjectPropType;
+      break;
+    case buffet::ValueType::Array:
+      prop = new ArrayPropType;
+      break;
   }
   return std::unique_ptr<PropType>(prop);
 }
 
 bool PropType::GenerateErrorValueTypeMismatch(chromeos::ErrorPtr* error) const {
   chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
-                                errors::commands::kTypeMismatch,
-                                "Unable to convert value to type '%s'",
-                                GetTypeAsString().c_str());
+                               errors::commands::kTypeMismatch,
+                               "Unable to convert value to type '%s'",
+                               GetTypeAsString().c_str());
   return false;
 }
 
-template<typename T>
+template <typename T>
 static std::unique_ptr<Constraint> LoadOneOfConstraint(
     const base::DictionaryValue* value,
     const PropType* prop_type,
@@ -306,7 +306,7 @@
   return constraint;
 }
 
-template<class ConstraintClass, typename T>
+template <class ConstraintClass, typename T>
 static std::unique_ptr<Constraint> LoadMinMaxConstraint(
     const char* dict_key,
     const base::DictionaryValue* value,
@@ -326,7 +326,7 @@
 
 // PropTypeBase ----------------------------------------------------------------
 
-template<class Derived, class Value, typename T>
+template <class Derived, class Value, typename T>
 bool PropTypeBase<Derived, Value, T>::ConstraintsFromJson(
     const base::DictionaryValue* value,
     std::set<std::string>* processed_keys,
@@ -351,7 +351,7 @@
 
 // NumericPropTypeBase ---------------------------------------------------------
 
-template<class Derived, class Value, typename T>
+template <class Derived, class Value, typename T>
 bool NumericPropTypeBase<Derived, Value, T>::ConstraintsFromJson(
     const base::DictionaryValue* value,
     std::set<std::string>* processed_keys,
@@ -388,10 +388,9 @@
 
 // StringPropType -------------------------------------------------------------
 
-bool StringPropType::ConstraintsFromJson(
-    const base::DictionaryValue* value,
-    std::set<std::string>* processed_keys,
-    chromeos::ErrorPtr* error) {
+bool StringPropType::ConstraintsFromJson(const base::DictionaryValue* value,
+                                         std::set<std::string>* processed_keys,
+                                         chromeos::ErrorPtr* error) {
   if (!Base::ConstraintsFromJson(value, processed_keys, error))
     return false;
 
@@ -445,11 +444,11 @@
 // ObjectPropType -------------------------------------------------------------
 
 ObjectPropType::ObjectPropType()
-    : object_schema_{ObjectSchema::Create(), false} {}
+    : object_schema_{ObjectSchema::Create(), false} {
+}
 
 bool ObjectPropType::HasOverriddenAttributes() const {
-  return PropType::HasOverriddenAttributes() ||
-         !object_schema_.is_inherited;
+  return PropType::HasOverriddenAttributes() || !object_schema_.is_inherited;
 }
 
 std::unique_ptr<PropType> ObjectPropType::Clone() const {
@@ -462,7 +461,8 @@
 }
 
 std::unique_ptr<base::Value> ObjectPropType::ToJson(
-    bool full_schema, chromeos::ErrorPtr* error) const {
+    bool full_schema,
+    chromeos::ErrorPtr* error) const {
   std::unique_ptr<base::Value> value = PropType::ToJson(full_schema, error);
   if (value) {
     base::DictionaryValue* dict = nullptr;
@@ -577,11 +577,11 @@
 
 // ArrayPropType -------------------------------------------------------------
 
-ArrayPropType::ArrayPropType() {}
+ArrayPropType::ArrayPropType() {
+}
 
 bool ArrayPropType::HasOverriddenAttributes() const {
-  return PropType::HasOverriddenAttributes() ||
-         !item_type_.is_inherited;
+  return PropType::HasOverriddenAttributes() || !item_type_.is_inherited;
 }
 
 std::unique_ptr<PropType> ArrayPropType::Clone() const {
@@ -593,7 +593,8 @@
 }
 
 std::unique_ptr<base::Value> ArrayPropType::ToJson(
-    bool full_schema, chromeos::ErrorPtr* error) const {
+    bool full_schema,
+    chromeos::ErrorPtr* error) const {
   std::unique_ptr<base::Value> value = PropType::ToJson(full_schema, error);
   if (value) {
     base::DictionaryValue* dict = nullptr;
diff --git a/libweave/src/commands/prop_types.h b/libweave/src/commands/prop_types.h
index 1c31d04..156b556 100644
--- a/libweave/src/commands/prop_types.h
+++ b/libweave/src/commands/prop_types.h
@@ -38,8 +38,7 @@
   // of particular type. Also it is expected to have at most one constraint
   // of each type (e.g. it makes no sense to impose two "minimum" constraints
   // onto a numeric parameter).
-  using ConstraintMap = std::map<ConstraintType,
-                                 std::unique_ptr<Constraint>>;
+  using ConstraintMap = std::map<ConstraintType, std::unique_ptr<Constraint>>;
 
   PropType();
   virtual ~PropType();
@@ -55,9 +54,7 @@
   // is available.
   const PropValue* GetDefaultValue() const { return default_.value.get(); }
   // Gets the constraints specified for the parameter, if any.
-  const ConstraintMap& GetConstraints() const {
-    return constraints_;
-  }
+  const ConstraintMap& GetConstraints() const { return constraints_; }
   // Checks if any of the type attributes were overridden from the base
   // schema definition. If this type does not inherit from a base schema,
   // this method returns true.
@@ -87,7 +84,8 @@
   // type as a factory class.
   virtual std::unique_ptr<PropValue> CreateValue() const = 0;
   virtual std::unique_ptr<PropValue> CreateValue(
-      const chromeos::Any& val, chromeos::ErrorPtr* error) const = 0;
+      const chromeos::Any& val,
+      chromeos::ErrorPtr* error) const = 0;
 
   // Converts an array of PropValue containing the values of the types described
   // by this instance of PropType into an Any containing std::vector<T>, where
@@ -196,7 +194,7 @@
 
 // Base class for all the derived concrete implementations of property
 // type classes. Provides implementations for common methods of PropType base.
-template<class Derived, class Value, typename T>
+template <class Derived, class Value, typename T>
 class PropTypeBase : public PropType {
  public:
   // Overrides from PropType.
@@ -209,7 +207,8 @@
   }
 
   std::unique_ptr<PropValue> CreateValue(
-      const chromeos::Any& v, chromeos::ErrorPtr* error) const override {
+      const chromeos::Any& v,
+      chromeos::ErrorPtr* error) const override {
     std::unique_ptr<PropValue> prop_value;
     if (v.IsTypeCompatible<T>()) {
       std::unique_ptr<Value> value{new Value{Clone()}};
@@ -255,7 +254,7 @@
 };
 
 // Helper base class for Int and Double parameter types.
-template<class Derived, class Value, typename T>
+template <class Derived, class Value, typename T>
 class NumericPropTypeBase : public PropTypeBase<Derived, Value, T> {
  public:
   using Base = PropTypeBase<Derived, Value, T>;
@@ -268,10 +267,10 @@
   void AddMinMaxConstraint(T min_value, T max_value) {
     InheritableAttribute<T> min_attr(min_value, false);
     InheritableAttribute<T> max_attr(max_value, false);
-    this->AddConstraint(std::unique_ptr<ConstraintMin<T>>{
-        new ConstraintMin<T>{min_attr}});
-    this->AddConstraint(std::unique_ptr<ConstraintMax<T>>{
-        new ConstraintMax<T>{max_attr}});
+    this->AddConstraint(
+        std::unique_ptr<ConstraintMin<T>>{new ConstraintMin<T>{min_attr}});
+    this->AddConstraint(
+        std::unique_ptr<ConstraintMax<T>>{new ConstraintMax<T>{max_attr}});
   }
   T GetMinValue() const {
     auto mmc = static_cast<const ConstraintMin<T>*>(
@@ -354,7 +353,7 @@
                             chromeos::ErrorPtr* error) override;
 
   chromeos::Any ConvertArrayToDBusVariant(
-    const native_types::Array& source) const override;
+      const native_types::Array& source) const override;
 
   bool ConvertDBusVariantToArray(const chromeos::Any& source,
                                  native_types::Array* result,
diff --git a/libweave/src/commands/prop_values.cc b/libweave/src/commands/prop_values.cc
index 62a67be..28a2c43 100644
--- a/libweave/src/commands/prop_values.cc
+++ b/libweave/src/commands/prop_values.cc
@@ -9,11 +9,13 @@
 namespace buffet {
 
 PropValue::PropValue(std::unique_ptr<const PropType> type)
-    : type_{std::move(type)} {}
+    : type_{std::move(type)} {
+}
 
-PropValue::PropValue(const PropType* type_ptr)
-    : type_{type_ptr->Clone()} {}
+PropValue::PropValue(const PropType* type_ptr) : type_{type_ptr->Clone()} {
+}
 
-PropValue::~PropValue() {}
+PropValue::~PropValue() {
+}
 
 }  // namespace buffet
diff --git a/libweave/src/commands/prop_values.h b/libweave/src/commands/prop_values.h
index 5f46452..b178330 100644
--- a/libweave/src/commands/prop_values.h
+++ b/libweave/src/commands/prop_values.h
@@ -45,20 +45,29 @@
 // native C++ data representation.
 // The generic GetValueType<T>() is undefined, however particular
 // type specializations return the appropriate ValueType.
-template<typename T> ValueType GetValueType();  // Undefined.
-template<>
-inline ValueType GetValueType<int>() { return ValueType::Int; }
-template<>
-inline ValueType GetValueType<double>() { return ValueType::Double; }
-template<>
-inline ValueType GetValueType<std::string>() { return ValueType::String; }
-template<>
-inline ValueType GetValueType<bool>() { return ValueType::Boolean; }
-template<>
+template <typename T>
+ValueType GetValueType();  // Undefined.
+template <>
+inline ValueType GetValueType<int>() {
+  return ValueType::Int;
+}
+template <>
+inline ValueType GetValueType<double>() {
+  return ValueType::Double;
+}
+template <>
+inline ValueType GetValueType<std::string>() {
+  return ValueType::String;
+}
+template <>
+inline ValueType GetValueType<bool>() {
+  return ValueType::Boolean;
+}
+template <>
 inline ValueType GetValueType<native_types::Object>() {
   return ValueType::Object;
 }
-template<>
+template <>
 inline ValueType GetValueType<native_types::Array>() {
   return ValueType::Array;
 }
@@ -127,7 +136,7 @@
 };
 
 // A helper template base class for implementing value classes.
-template<typename Derived, typename T>
+template <typename Derived, typename T>
 class TypedValueBase : public PropValue {
  public:
   // To help refer to this base class from derived classes, define Base to
diff --git a/libweave/src/commands/schema_utils.cc b/libweave/src/commands/schema_utils.cc
index c46bcbb..c0067ab 100644
--- a/libweave/src/commands/schema_utils.cc
+++ b/libweave/src/commands/schema_utils.cc
@@ -31,12 +31,12 @@
 // Template version of ReportJsonTypeMismatch that deduces the type of expected
 // data from the value_out parameter passed to particular overload of
 // TypedValueFromJson() function. Always returns false.
-template<typename T>
-bool ReportUnexpectedJson(const base::Value* value_in, T*,
+template <typename T>
+bool ReportUnexpectedJson(const base::Value* value_in,
+                          T*,
                           chromeos::ErrorPtr* error) {
-  ReportJsonTypeMismatch(value_in,
-                         PropType::GetTypeStringFromType(GetValueType<T>()),
-                         error);
+  ReportJsonTypeMismatch(
+      value_in, PropType::GetTypeStringFromType(GetValueType<T>()), error);
   return false;
 }
 
@@ -148,11 +148,10 @@
           << "Unable to get parameter";
       if (!value->FromJson(param_value, error) ||
           !pair.second->ValidateValue(value->GetValueAsAny(), error)) {
-        chromeos::Error::AddToPrintf(error, FROM_HERE,
-                                     errors::commands::kDomain,
-                                     errors::commands::kInvalidPropValue,
-                                     "Invalid value for property '%s'",
-                                     pair.first.c_str());
+        chromeos::Error::AddToPrintf(
+            error, FROM_HERE, errors::commands::kDomain,
+            errors::commands::kInvalidPropValue,
+            "Invalid value for property '%s'", pair.first.c_str());
         return false;
       }
       value_out->emplace_hint(value_out->end(), pair.first, std::move(value));
@@ -278,8 +277,8 @@
   return value->GetValueAsAny();
 }
 
-chromeos::VariantDictionary
-ObjectToDBusVariant(const native_types::Object& object) {
+chromeos::VariantDictionary ObjectToDBusVariant(
+    const native_types::Object& object) {
   chromeos::VariantDictionary dict;
   for (const auto& pair : object) {
     // Since we are inserting the elements from native_types::Object which is
@@ -317,8 +316,7 @@
         << "An object type must have a schema defined for it";
     native_types::Object obj;
     if (!ObjectFromDBusVariant(type->GetObject()->GetObjectSchemaPtr(),
-                               value.Get<chromeos::VariantDictionary>(),
-                               &obj,
+                               value.Get<chromeos::VariantDictionary>(), &obj,
                                error)) {
       return result;
     }
@@ -347,11 +345,10 @@
       CHECK(prop_type) << "Value property type must be available";
       auto prop_value = PropValueFromDBusVariant(prop_type, it->second, error);
       if (!prop_value) {
-        chromeos::Error::AddToPrintf(error, FROM_HERE,
-                                     errors::commands::kDomain,
-                                     errors::commands::kInvalidPropValue,
-                                     "Invalid value for property '%s'",
-                                     pair.first.c_str());
+        chromeos::Error::AddToPrintf(
+            error, FROM_HERE, errors::commands::kDomain,
+            errors::commands::kInvalidPropValue,
+            "Invalid value for property '%s'", pair.first.c_str());
         return false;
       }
       obj->emplace_hint(obj->end(), pair.first, std::move(prop_value));
@@ -369,11 +366,10 @@
   if (!object_schema->GetExtraPropertiesAllowed()) {
     for (const auto& pair : dict) {
       if (keys_processed.find(pair.first) == keys_processed.end()) {
-        chromeos::Error::AddToPrintf(error, FROM_HERE,
-                                     errors::commands::kDomain,
-                                     errors::commands::kUnknownProperty,
-                                     "Unrecognized property '%s'",
-                                     pair.first.c_str());
+        chromeos::Error::AddToPrintf(
+            error, FROM_HERE, errors::commands::kDomain,
+            errors::commands::kUnknownProperty, "Unrecognized property '%s'",
+            pair.first.c_str());
         return false;
       }
     }
diff --git a/libweave/src/commands/schema_utils.h b/libweave/src/commands/schema_utils.h
index 8d02477..d16374c 100644
--- a/libweave/src/commands/schema_utils.h
+++ b/libweave/src/commands/schema_utils.h
@@ -42,7 +42,7 @@
 // The |value| still specifies the actual attribute values, whether it
 // is inherited or overridden, while |is_inherited| can be used to identify
 // if the attribute was inherited (true) or overridden (false).
-template<typename T>
+template <typename T>
 class InheritableAttribute final {
  public:
   InheritableAttribute() = default;
@@ -69,7 +69,7 @@
                                               chromeos::ErrorPtr* error);
 std::unique_ptr<base::Value> TypedValueToJson(const native_types::Array& value,
                                               chromeos::ErrorPtr* error);
-template<typename T>
+template <typename T>
 std::unique_ptr<base::Value> TypedValueToJson(const std::vector<T>& values,
                                               chromeos::ErrorPtr* error) {
   std::unique_ptr<base::ListValue> list(new base::ListValue);
@@ -125,14 +125,14 @@
 // which should work reliably for floating points also ("number" type).
 
 // Compare exact types using ==.
-template<typename T>
+template <typename T>
 inline typename std::enable_if<!std::is_floating_point<T>::value, bool>::type
 CompareValue(const T& v1, const T& v2) {
   return v1 == v2;
 }
 
 // Compare non-exact types (such as double) using precision margin (epsilon).
-template<typename T>
+template <typename T>
 inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type
 CompareValue(const T& v1, const T& v2) {
   return std::abs(v1 - v2) <= std::numeric_limits<T>::epsilon();
@@ -144,8 +144,8 @@
 chromeos::Any PropValueToDBusVariant(const PropValue* value);
 // Converts native_types::Object to chromeos::VariantDictionary
 // with proper conversion of all nested properties.
-chromeos::VariantDictionary
-ObjectToDBusVariant(const native_types::Object& object);
+chromeos::VariantDictionary ObjectToDBusVariant(
+    const native_types::Object& object);
 // Converts D-Bus variant to PropValue.
 // Has special handling for Object types where chromeos::VariantDictionary
 // is converted to native_types::Object.
diff --git a/libweave/src/commands/schema_utils_unittest.cc b/libweave/src/commands/schema_utils_unittest.cc
index 7e3debe..92194dd 100644
--- a/libweave/src/commands/schema_utils_unittest.cc
+++ b/libweave/src/commands/schema_utils_unittest.cc
@@ -177,9 +177,8 @@
                                  &type, &value, nullptr));
   native_types::Object value2;
   value2.insert(std::make_pair("age", age_prop.CreateValue(20, nullptr)));
-  value2.insert(std::make_pair("name",
-                               name_prop.CreateValue(std::string("Bob"),
-                                                     nullptr)));
+  value2.insert(std::make_pair(
+      "name", name_prop.CreateValue(std::string("Bob"), nullptr)));
   EXPECT_EQ(value2, value);
 
   chromeos::ErrorPtr error;
@@ -228,9 +227,11 @@
   EXPECT_EQ("foo", PropValueToDBusVariant(prop_value.get()).Get<std::string>());
 
   ObjectPropType obj_type;
-  ASSERT_TRUE(obj_type.FromJson(CreateDictionaryValue(
-      "{'properties':{'width':'integer','height':'integer'},"
-      "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}").get(),
+  ASSERT_TRUE(obj_type.FromJson(
+      CreateDictionaryValue(
+          "{'properties':{'width':'integer','height':'integer'},"
+          "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}")
+          .get(),
       nullptr, nullptr));
   native_types::Object obj{
       {"width", int_type.CreateValue(10, nullptr)},
@@ -290,7 +291,7 @@
 TEST(CommandSchemaUtils, PropValueFromDBusVariant_Double) {
   DoublePropType dbl_type;
   ASSERT_TRUE(dbl_type.FromJson(CreateDictionaryValue("{'maximum':2.0}").get(),
-                                 nullptr, nullptr));
+                                nullptr, nullptr));
 
   auto prop_value = PropValueFromDBusVariant(&dbl_type, 1.0, nullptr);
   ASSERT_NE(nullptr, prop_value.get());
@@ -306,10 +307,10 @@
 TEST(CommandSchemaUtils, PropValueFromDBusVariant_String) {
   StringPropType str_type;
   ASSERT_TRUE(str_type.FromJson(CreateDictionaryValue("{'minLength': 4}").get(),
-                                 nullptr, nullptr));
+                                nullptr, nullptr));
 
-  auto prop_value = PropValueFromDBusVariant(&str_type, std::string{"blah"},
-                                             nullptr);
+  auto prop_value =
+      PropValueFromDBusVariant(&str_type, std::string{"blah"}, nullptr);
   ASSERT_NE(nullptr, prop_value.get());
   EXPECT_EQ("blah", prop_value->GetValueAsAny().Get<std::string>());
 
@@ -322,14 +323,15 @@
 
 TEST(CommandSchemaUtils, PropValueFromDBusVariant_Object) {
   ObjectPropType obj_type;
-  ASSERT_TRUE(obj_type.FromJson(CreateDictionaryValue(
-      "{'properties':{'width':'integer','height':'integer'},"
-      "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}").get(),
+  ASSERT_TRUE(obj_type.FromJson(
+      CreateDictionaryValue(
+          "{'properties':{'width':'integer','height':'integer'},"
+          "'enum':[{'width':10,'height':20},{'width':100,'height':200}]}")
+          .get(),
       nullptr, nullptr));
 
   VariantDictionary obj{
-    {"width", 100},
-    {"height", 200},
+      {"width", 100}, {"height", 200},
   };
   auto prop_value = PropValueFromDBusVariant(&obj_type, obj, nullptr);
   ASSERT_NE(nullptr, prop_value.get());
diff --git a/libweave/src/commands/unittest_utils.h b/libweave/src/commands/unittest_utils.h
index b514204..1674084 100644
--- a/libweave/src/commands/unittest_utils.h
+++ b/libweave/src/commands/unittest_utils.h
@@ -49,15 +49,15 @@
   return make_prop_value<BooleanValue, bool>(value);
 }
 
-inline std::unique_ptr<const StringValue>
-make_string_prop_value(const std::string& value) {
+inline std::unique_ptr<const StringValue> make_string_prop_value(
+    const std::string& value) {
   return make_prop_value<StringValue, std::string>(value);
 }
 
 }  // namespace unittests
 }  // namespace buffet
 
-#define EXPECT_JSON_EQ(expected, actual) \
+#define EXPECT_JSON_EQ(expected, actual)        \
   EXPECT_PRED2(buffet::unittests::IsEqualValue, \
                *buffet::unittests::CreateValue(expected), actual)
 
diff --git a/libweave/src/device_registration_info.cc b/libweave/src/device_registration_info.cc
index 25ab205..f19b973 100644
--- a/libweave/src/device_registration_info.cc
+++ b/libweave/src/device_registration_info.cc
@@ -138,15 +138,14 @@
   command_manager_->AddOnCommandDefChanged(
       base::Bind(&DeviceRegistrationInfo::OnCommandDefsChanged,
                  weak_factory_.GetWeakPtr()));
-  state_manager_->AddOnChangedCallback(
-      base::Bind(&DeviceRegistrationInfo::OnStateChanged,
-                 weak_factory_.GetWeakPtr()));
+  state_manager_->AddOnChangedCallback(base::Bind(
+      &DeviceRegistrationInfo::OnStateChanged, weak_factory_.GetWeakPtr()));
 }
 
 DeviceRegistrationInfo::~DeviceRegistrationInfo() = default;
 
 std::pair<std::string, std::string>
-    DeviceRegistrationInfo::GetAuthorizationHeader() const {
+DeviceRegistrationInfo::GetAuthorizationHeader() const {
   return BuildAuthHeader("Bearer", access_token_);
 }
 
@@ -192,19 +191,20 @@
   base::TimeDelta min_delay =
       base::TimeDelta::FromSeconds(kMinStartDeviceRetryDelaySeconds);
   base::TimeDelta retry_delay = later * 2;
-  if (retry_delay > max_delay) { retry_delay = max_delay; }
-  if (retry_delay < min_delay) { retry_delay = min_delay; }
+  if (retry_delay > max_delay) {
+    retry_delay = max_delay;
+  }
+  if (retry_delay < min_delay) {
+    retry_delay = min_delay;
+  }
   task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&DeviceRegistrationInfo::StartDevice,
-                 weak_factory_.GetWeakPtr(), nullptr,
-                 retry_delay),
+      FROM_HERE, base::Bind(&DeviceRegistrationInfo::StartDevice,
+                            weak_factory_.GetWeakPtr(), nullptr, retry_delay),
       later);
 }
 
 bool DeviceRegistrationInfo::HaveRegistrationCredentials() const {
-  return !config_->refresh_token().empty() &&
-         !config_->device_id().empty() &&
+  return !config_->refresh_token().empty() && !config_->device_id().empty() &&
          !config_->robot_account().empty();
 }
 
@@ -264,23 +264,22 @@
       std::make_shared<CloudRequestErrorCallback>(error_callback);
 
   auto on_refresh_error = [shared_error_callback](
-      chromeos::http::RequestID id,
-      const chromeos::Error* error) {
+      chromeos::http::RequestID id, const chromeos::Error* error) {
     shared_error_callback->Run(error);
   };
 
   chromeos::http::FormFieldList form_data{
-    {"refresh_token", config_->refresh_token()},
-    {"client_id", config_->client_id()},
-    {"client_secret", config_->client_secret()},
-    {"grant_type", "refresh_token"},
+      {"refresh_token", config_->refresh_token()},
+      {"client_id", config_->client_id()},
+      {"client_secret", config_->client_secret()},
+      {"grant_type", "refresh_token"},
   };
 
   chromeos::http::PostFormData(
       GetOAuthURL("token"), form_data, {}, transport_,
       base::Bind(&DeviceRegistrationInfo::OnRefreshAccessTokenSuccess,
-                 weak_factory_.GetWeakPtr(),
-                 success_callback, shared_error_callback),
+                 weak_factory_.GetWeakPtr(), success_callback,
+                 shared_error_callback),
       base::Bind(on_refresh_error));
 }
 
@@ -298,8 +297,7 @@
 
   int expires_in = 0;
   if (!json->GetString("access_token", &access_token_) ||
-      !json->GetInteger("expires_in", &expires_in) ||
-      access_token_.empty() ||
+      !json->GetInteger("expires_in", &expires_in) || access_token_.empty() ||
       expires_in <= 0) {
     LOG(ERROR) << "Access token unavailable.";
     chromeos::Error::AddTo(&error, FROM_HERE, kErrorDomainOAuth2,
@@ -308,8 +306,8 @@
     error_callback->Run(error.get());
     return;
   }
-  access_token_expiration_ = base::Time::Now() +
-                             base::TimeDelta::FromSeconds(expires_in);
+  access_token_expiration_ =
+      base::Time::Now() + base::TimeDelta::FromSeconds(expires_in);
   LOG(INFO) << "Access token is refreshed for additional " << expires_in
             << " seconds.";
 
@@ -438,8 +436,8 @@
                            {{"key", config_->api_key()}});
   std::unique_ptr<chromeos::http::Response> response =
       chromeos::http::PatchJsonAndBlock(url, &req_json, {}, transport_, error);
-  auto json_resp = chromeos::http::ParseJsonResponse(response.get(), nullptr,
-                                                     error);
+  auto json_resp =
+      chromeos::http::ParseJsonResponse(response.get(), nullptr, error);
   if (!json_resp)
     return std::string();
   if (!response->IsSuccessful()) {
@@ -447,8 +445,8 @@
     return std::string();
   }
 
-  url = GetServiceURL("registrationTickets/" + ticket_id +
-                      "/finalize?key=" + config_->api_key());
+  url = GetServiceURL("registrationTickets/" + ticket_id + "/finalize?key=" +
+                      config_->api_key());
   response = chromeos::http::SendRequestWithNoDataAndBlock(
       chromeos::http::request_type::kPost, url, {}, transport_, error);
   if (!response)
@@ -474,14 +472,15 @@
   }
 
   // Now get access_token and refresh_token
-  response = chromeos::http::PostFormDataAndBlock(GetOAuthURL("token"), {
-    {"code", auth_code},
-    {"client_id", config_->client_id()},
-    {"client_secret", config_->client_secret()},
-    {"redirect_uri", "oob"},
-    {"scope", "https://www.googleapis.com/auth/clouddevices"},
-    {"grant_type", "authorization_code"}
-  }, {}, transport_, error);
+  response = chromeos::http::PostFormDataAndBlock(
+      GetOAuthURL("token"),
+      {{"code", auth_code},
+       {"client_id", config_->client_id()},
+       {"client_secret", config_->client_secret()},
+       {"redirect_uri", "oob"},
+       {"scope", "https://www.googleapis.com/auth/clouddevices"},
+       {"grant_type", "authorization_code"}},
+      {}, transport_, error);
   if (!response)
     return std::string();
 
@@ -492,14 +491,14 @@
       !json_resp->GetString("refresh_token", &refresh_token) ||
       !json_resp->GetInteger("expires_in", &expires_in) ||
       access_token_.empty() || refresh_token.empty() || expires_in <= 0) {
-    chromeos::Error::AddTo(error, FROM_HERE,
-                           kErrorDomainGCD, "unexpected_response",
+    chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainGCD,
+                           "unexpected_response",
                            "Device access_token missing in response");
     return std::string();
   }
 
-  access_token_expiration_ = base::Time::Now() +
-                             base::TimeDelta::FromSeconds(expires_in);
+  access_token_expiration_ =
+      base::Time::Now() + base::TimeDelta::FromSeconds(expires_in);
 
   BuffetConfig::Transaction change{config_.get()};
   change.set_device_id(device_id);
@@ -554,9 +553,8 @@
             << cloud_backoff_entry_->GetTimeUntilRelease()
             << " due to backoff policy";
     task_runner_->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&DeviceRegistrationInfo::SendCloudRequest, AsWeakPtr(),
-                   data),
+        FROM_HERE, base::Bind(&DeviceRegistrationInfo::SendCloudRequest,
+                              AsWeakPtr(), data),
         cloud_backoff_entry_->GetTimeUntilRelease());
     return;
   }
@@ -602,8 +600,8 @@
   }
 
   chromeos::ErrorPtr error;
-  auto json_resp = chromeos::http::ParseJsonResponse(response.get(), nullptr,
-                                                     &error);
+  auto json_resp =
+      chromeos::http::ParseJsonResponse(response.get(), nullptr, &error);
   if (!json_resp) {
     data->error_callback.Run(error.get());
     return;
@@ -655,29 +653,25 @@
   data->error_callback.Run(error);
 }
 
-void DeviceRegistrationInfo::StartDevice(
-    chromeos::ErrorPtr* error,
-    const base::TimeDelta& retry_delay) {
+void DeviceRegistrationInfo::StartDevice(chromeos::ErrorPtr* error,
+                                         const base::TimeDelta& retry_delay) {
   if (!VerifyRegistrationCredentials(error))
     return;
-  auto handle_start_device_failure_cb = base::Bind(
-      &IgnoreCloudErrorWithCallback,
-      base::Bind(&DeviceRegistrationInfo::ScheduleStartDevice,
-                 weak_factory_.GetWeakPtr(),
-                 retry_delay));
+  auto handle_start_device_failure_cb =
+      base::Bind(&IgnoreCloudErrorWithCallback,
+                 base::Bind(&DeviceRegistrationInfo::ScheduleStartDevice,
+                            weak_factory_.GetWeakPtr(), retry_delay));
   // "Starting" a device just means that we:
   //   1) push an updated device resource
   //   2) fetch an initial set of outstanding commands
   //   3) abort any commands that we've previously marked as "in progress"
   //      or as being in an error state; publish queued commands
-  auto abort_commands_cb = base::Bind(
-      &DeviceRegistrationInfo::ProcessInitialCommandList,
-      weak_factory_.GetWeakPtr());
+  auto abort_commands_cb =
+      base::Bind(&DeviceRegistrationInfo::ProcessInitialCommandList,
+                 weak_factory_.GetWeakPtr());
   auto fetch_commands_cb = base::Bind(
-      &DeviceRegistrationInfo::FetchCommands,
-      weak_factory_.GetWeakPtr(),
-      abort_commands_cb,
-      handle_start_device_failure_cb);
+      &DeviceRegistrationInfo::FetchCommands, weak_factory_.GetWeakPtr(),
+      abort_commands_cb, handle_start_device_failure_cb);
   UpdateDeviceResource(fetch_commands_cb, handle_start_device_failure_cb);
 }
 
@@ -745,25 +739,21 @@
     const base::DictionaryValue& command_patch,
     const base::Closure& on_success,
     const base::Closure& on_error) {
-  DoCloudRequest(
-      chromeos::http::request_type::kPatch,
-      GetServiceURL("commands/" + command_id),
-      &command_patch,
-      base::Bind(&IgnoreCloudResultWithCallback, on_success),
-      base::Bind(&IgnoreCloudErrorWithCallback, on_error));
+  DoCloudRequest(chromeos::http::request_type::kPatch,
+                 GetServiceURL("commands/" + command_id), &command_patch,
+                 base::Bind(&IgnoreCloudResultWithCallback, on_success),
+                 base::Bind(&IgnoreCloudErrorWithCallback, on_error));
 }
 
-void DeviceRegistrationInfo::NotifyCommandAborted(
-    const std::string& command_id,
-    chromeos::ErrorPtr error) {
+void DeviceRegistrationInfo::NotifyCommandAborted(const std::string& command_id,
+                                                  chromeos::ErrorPtr error) {
   base::DictionaryValue command_patch;
   command_patch.SetString(commands::attributes::kCommand_State,
                           CommandInstance::kStatusAborted);
   if (error) {
     command_patch.SetString(commands::attributes::kCommand_ErrorCode,
-                            chromeos::string_utils::Join(":",
-                                                         error->GetDomain(),
-                                                         error->GetCode()));
+                            chromeos::string_utils::Join(
+                                ":", error->GetDomain(), error->GetCode()));
     std::vector<std::string> messages;
     const chromeos::Error* current_error = error.get();
     while (current_error) {
@@ -773,22 +763,19 @@
     command_patch.SetString(commands::attributes::kCommand_ErrorMessage,
                             chromeos::string_utils::Join(";", messages));
   }
-  UpdateCommand(command_id,
-                command_patch,
-                base::Bind(&base::DoNothing),
+  UpdateCommand(command_id, command_patch, base::Bind(&base::DoNothing),
                 base::Bind(&DeviceRegistrationInfo::RetryNotifyCommandAborted,
-                           weak_factory_.GetWeakPtr(),
-                           command_id, base::Passed(std::move(error))));
+                           weak_factory_.GetWeakPtr(), command_id,
+                           base::Passed(std::move(error))));
 }
 
 void DeviceRegistrationInfo::RetryNotifyCommandAborted(
     const std::string& command_id,
     chromeos::ErrorPtr error) {
   task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&DeviceRegistrationInfo::NotifyCommandAborted,
-                 weak_factory_.GetWeakPtr(),
-                 command_id, base::Passed(std::move(error))),
+      FROM_HERE, base::Bind(&DeviceRegistrationInfo::NotifyCommandAborted,
+                            weak_factory_.GetWeakPtr(), command_id,
+                            base::Passed(std::move(error))),
       base::TimeDelta::FromSeconds(kAbortCommandRetryDelaySeconds));
 }
 
@@ -822,9 +809,7 @@
   }
 
   DoCloudRequest(
-      chromeos::http::request_type::kPut,
-      GetDeviceURL(),
-      device_resource.get(),
+      chromeos::http::request_type::kPut, GetDeviceURL(), device_resource.get(),
       base::Bind(&DeviceRegistrationInfo::OnUpdateDeviceResourceSuccess,
                  AsWeakPtr()),
       base::Bind(&DeviceRegistrationInfo::OnUpdateDeviceResourceError,
@@ -890,8 +875,7 @@
       LOG(WARNING) << "Command with no state at " << *command;
       continue;
     }
-    if (command_state == "error" &&
-        command_state == "inProgress" &&
+    if (command_state == "error" && command_state == "inProgress" &&
         command_state == "paused") {
       // It's a limbo command, abort it.
       std::string command_id;
@@ -903,11 +887,10 @@
       std::unique_ptr<base::DictionaryValue> cmd_copy{command_dict->DeepCopy()};
       cmd_copy->SetString("state", "aborted");
       // TODO(wiley) We could consider handling this error case more gracefully.
-      DoCloudRequest(
-          chromeos::http::request_type::kPut,
-          GetServiceURL("commands/" + command_id),
-          cmd_copy.get(),
-          base::Bind(&IgnoreCloudResult), base::Bind(&IgnoreCloudError));
+      DoCloudRequest(chromeos::http::request_type::kPut,
+                     GetServiceURL("commands/" + command_id), cmd_copy.get(),
+                     base::Bind(&IgnoreCloudResult),
+                     base::Bind(&IgnoreCloudError));
     } else {
       // Normal command, publish it to local clients.
       PublishCommand(*command_dict);
@@ -947,9 +930,11 @@
     std::unique_ptr<chromeos::BackoffEntry> backoff_entry{
         new chromeos::BackoffEntry{cloud_backoff_policy_.get()}};
     std::unique_ptr<CommandProxyInterface> cloud_proxy{
-        new CloudCommandProxy{command_instance.get(), this,
+        new CloudCommandProxy{command_instance.get(),
+                              this,
                               state_manager_->GetStateChangeQueue(),
-                              std::move(backoff_entry), task_runner_}};
+                              std::move(backoff_entry),
+                              task_runner_}};
     command_instance->AddProxy(std::move(cloud_proxy));
     command_manager_->AddCommand(std::move(command_instance));
   }
@@ -963,7 +948,7 @@
   StateChangeQueueInterface::UpdateID update_id = 0;
   std::vector<StateChange> state_changes;
   std::tie(update_id, state_changes) =
-    state_manager_->GetAndClearRecordedStateChanges();
+      state_manager_->GetAndClearRecordedStateChanges();
   if (state_changes.empty())
     return;
 
diff --git a/libweave/src/device_registration_info.h b/libweave/src/device_registration_info.h
index 56cae31..8c9cf80 100644
--- a/libweave/src/device_registration_info.h
+++ b/libweave/src/device_registration_info.h
@@ -106,14 +106,14 @@
   // The base URL used to construct the full URL looks like this:
   //    https://www.googleapis.com/clouddevices/v1/devices/<device_id>/
   std::string GetDeviceURL(
-    const std::string& subpath = {},
-    const chromeos::data_encoding::WebParamList& params = {}) const;
+      const std::string& subpath = {},
+      const chromeos::data_encoding::WebParamList& params = {}) const;
 
   // Similar to GetServiceURL, GetOAuthURL() returns a URL of OAuth 2.0 server.
   // The base URL used is https://accounts.google.com/o/oauth2/.
   std::string GetOAuthURL(
-    const std::string& subpath = {},
-    const chromeos::data_encoding::WebParamList& params = {}) const;
+      const std::string& subpath = {},
+      const chromeos::data_encoding::WebParamList& params = {}) const;
 
   // Starts GCD device if credentials available.
   void Start();
@@ -196,7 +196,8 @@
   // Parse the OAuth response, and sets registration status to
   // kInvalidCredentials if our registration is no longer valid.
   std::unique_ptr<base::DictionaryValue> ParseOAuthResponse(
-      chromeos::http::Response* response, chromeos::ErrorPtr* error);
+      chromeos::http::Response* response,
+      chromeos::ErrorPtr* error);
 
   // This attempts to open a notification channel. The channel needs to be
   // restarted anytime the access_token is refreshed.
@@ -207,12 +208,11 @@
   // and device removal.  It is a recommended way to do cloud API
   // requests.
   // TODO(antonm): Consider moving into some other class.
-  void DoCloudRequest(
-      const std::string& method,
-      const std::string& url,
-      const base::DictionaryValue* body,
-      const CloudRequestCallback& success_callback,
-      const CloudRequestErrorCallback& error_callback);
+  void DoCloudRequest(const std::string& method,
+                      const std::string& url,
+                      const base::DictionaryValue* body,
+                      const CloudRequestCallback& success_callback,
+                      const CloudRequestErrorCallback& error_callback);
 
   // Helper for DoCloudRequest().
   struct CloudRequestData {
@@ -227,17 +227,14 @@
       const std::shared_ptr<const CloudRequestData>& data,
       chromeos::http::RequestID request_id,
       std::unique_ptr<chromeos::http::Response> response);
-  void OnCloudRequestError(
-      const std::shared_ptr<const CloudRequestData>& data,
-      chromeos::http::RequestID request_id,
-      const chromeos::Error* error);
-  void RetryCloudRequest(
-      const std::shared_ptr<const CloudRequestData>& data);
+  void OnCloudRequestError(const std::shared_ptr<const CloudRequestData>& data,
+                           chromeos::http::RequestID request_id,
+                           const chromeos::Error* error);
+  void RetryCloudRequest(const std::shared_ptr<const CloudRequestData>& data);
   void OnAccessTokenRefreshed(
       const std::shared_ptr<const CloudRequestData>& data);
-  void OnAccessTokenError(
-      const std::shared_ptr<const CloudRequestData>& data,
-      const chromeos::Error* error);
+  void OnAccessTokenError(const std::shared_ptr<const CloudRequestData>& data,
+                          const chromeos::Error* error);
 
   void UpdateDeviceResource(const base::Closure& on_success,
                             const CloudRequestErrorCallback& on_failure);
diff --git a/libweave/src/device_registration_info_unittest.cc b/libweave/src/device_registration_info_unittest.cc
index 43bec4d..ba5a4e4 100644
--- a/libweave/src/device_registration_info_unittest.cc
+++ b/libweave/src/device_registration_info_unittest.cc
@@ -32,30 +32,38 @@
 
 namespace test_data {
 
-const char kServiceURL[]           = "http://gcd.server.com/";
-const char kOAuthURL[]             = "http://oauth.server.com/";
-const char kApiKey[]               = "GOadRdTf9FERf0k4w6EFOof56fUJ3kFDdFL3d7f";
-const char kClientId[]             = "123543821385-sfjkjshdkjhfk234sdfsdfkskd"
-                                     "fkjh7f.apps.googleusercontent.com";
-const char kClientSecret[]         = "5sdGdGlfolGlrFKfdFlgP6FG";
-const char kDeviceId[]             = "4a7ea2d1-b331-1e1f-b206-e863c7635196";
-const char kClaimTicketId[]        = "RTcUE";
-const char kAccessToken[]          = "ya29.1.AADtN_V-dLUM-sVZ0qVjG9Dxm5NgdS9J"
-                                     "Mx_JLUqhC9bED_YFjzHZtYt65ZzXCS35NMAeaVZ"
-                                     "Dei530-w0yE2urpQ";
-const char kRefreshToken[]         = "1/zQmxR6PKNvhcxf9SjXUrCjcmCrcqRKXctc6cp"
-                                     "1nI-GQ";
-const char kRobotAccountAuthCode[] = "4/Mf_ujEhPejVhOq-OxW9F5cSOnWzx."
-                                     "YgciVjTYGscRshQV0ieZDAqiTIjMigI";
-const char kRobotAccountEmail[]    = "6ed0b3f54f9bd619b942f4ad2441c252@"
-                                     "clouddevices.gserviceaccount.com";
-const char kUserAccountAuthCode[]  = "2/sd_GD1TGFKpJOLJ34-0g5fK0fflp.GlT"
-                                     "I0F5g7hNtFgj5HFGOf8FlGK9eflO";
-const char kUserAccessToken[]      = "sd56.4.FGDjG_F-gFGF-dFG6gGOG9Dxm5NgdS9"
-                                     "JMx_JLUqhC9bED_YFjLKjlkjLKJlkjLKjlKJea"
-                                     "VZDei530-w0yE2urpQ";
-const char kUserRefreshToken[]     = "1/zQLKjlKJlkLkLKjLkjLKjLkjLjLkjl0ftc6"
-                                     "cp1nI-GQ";
+const char kServiceURL[] = "http://gcd.server.com/";
+const char kOAuthURL[] = "http://oauth.server.com/";
+const char kApiKey[] = "GOadRdTf9FERf0k4w6EFOof56fUJ3kFDdFL3d7f";
+const char kClientId[] =
+    "123543821385-sfjkjshdkjhfk234sdfsdfkskd"
+    "fkjh7f.apps.googleusercontent.com";
+const char kClientSecret[] = "5sdGdGlfolGlrFKfdFlgP6FG";
+const char kDeviceId[] = "4a7ea2d1-b331-1e1f-b206-e863c7635196";
+const char kClaimTicketId[] = "RTcUE";
+const char kAccessToken[] =
+    "ya29.1.AADtN_V-dLUM-sVZ0qVjG9Dxm5NgdS9J"
+    "Mx_JLUqhC9bED_YFjzHZtYt65ZzXCS35NMAeaVZ"
+    "Dei530-w0yE2urpQ";
+const char kRefreshToken[] =
+    "1/zQmxR6PKNvhcxf9SjXUrCjcmCrcqRKXctc6cp"
+    "1nI-GQ";
+const char kRobotAccountAuthCode[] =
+    "4/Mf_ujEhPejVhOq-OxW9F5cSOnWzx."
+    "YgciVjTYGscRshQV0ieZDAqiTIjMigI";
+const char kRobotAccountEmail[] =
+    "6ed0b3f54f9bd619b942f4ad2441c252@"
+    "clouddevices.gserviceaccount.com";
+const char kUserAccountAuthCode[] =
+    "2/sd_GD1TGFKpJOLJ34-0g5fK0fflp.GlT"
+    "I0F5g7hNtFgj5HFGOf8FlGK9eflO";
+const char kUserAccessToken[] =
+    "sd56.4.FGDjG_F-gFGF-dFG6gGOG9Dxm5NgdS9"
+    "JMx_JLUqhC9bED_YFjLKjlkjLKJlkjLKjlKJea"
+    "VZDei530-w0yE2urpQ";
+const char kUserRefreshToken[] =
+    "1/zQLKjlKJlkLkLKjLkjLKjLkjLjLkjl0ftc6"
+    "cp1nI-GQ";
 }  // namespace test_data
 
 // Add the test device registration information.
@@ -107,8 +115,7 @@
   response->ReplyJson(chromeos::http::status_code::Ok, &json);
 }
 
-void OAuth2HandlerFail(const ServerRequest& request,
-                       ServerResponse* response) {
+void OAuth2HandlerFail(const ServerRequest& request, ServerResponse* response) {
   base::DictionaryValue json;
   EXPECT_EQ("refresh_token", request.GetFormField("grant_type"));
   EXPECT_EQ(test_data::kRefreshToken, request.GetFormField("refresh_token"));
@@ -134,12 +141,13 @@
   auth += test_data::kAccessToken;
   EXPECT_EQ(auth,
             request.GetHeader(chromeos::http::request_header::kAuthorization));
-  response->ReplyJson(chromeos::http::status_code::Ok, {
-    {"channel.supportedType", "xmpp"},
-    {"deviceKind", "vendor"},
-    {"id", test_data::kDeviceId},
-    {"kind", "clouddevices#device"},
-  });
+  response->ReplyJson(chromeos::http::status_code::Ok,
+                      {
+                          {"channel.supportedType", "xmpp"},
+                          {"deviceKind", "vendor"},
+                          {"id", test_data::kDeviceId},
+                          {"kind", "clouddevices#device"},
+                      });
 }
 
 void FinalizeTicketHandler(const ServerRequest& request,
@@ -147,17 +155,19 @@
   EXPECT_EQ(test_data::kApiKey, request.GetFormField("key"));
   EXPECT_TRUE(request.GetData().empty());
 
-  response->ReplyJson(chromeos::http::status_code::Ok, {
-    {"id", test_data::kClaimTicketId},
-    {"kind", "clouddevices#registrationTicket"},
-    {"oauthClientId", test_data::kClientId},
-    {"userEmail", "user@email.com"},
-    {"deviceDraft.id", test_data::kDeviceId},
-    {"deviceDraft.kind", "clouddevices#device"},
-    {"deviceDraft.channel.supportedType", "xmpp"},
-    {"robotAccountEmail", test_data::kRobotAccountEmail},
-    {"robotAccountAuthorizationCode", test_data::kRobotAccountAuthCode},
-  });
+  response->ReplyJson(
+      chromeos::http::status_code::Ok,
+      {
+          {"id", test_data::kClaimTicketId},
+          {"kind", "clouddevices#registrationTicket"},
+          {"oauthClientId", test_data::kClientId},
+          {"userEmail", "user@email.com"},
+          {"deviceDraft.id", test_data::kDeviceId},
+          {"deviceDraft.kind", "clouddevices#device"},
+          {"deviceDraft.channel.supportedType", "xmpp"},
+          {"robotAccountEmail", test_data::kRobotAccountEmail},
+          {"robotAccountAuthorizationCode", test_data::kRobotAccountAuthCode},
+      });
 }
 
 }  // anonymous namespace
@@ -174,9 +184,13 @@
 
     std::unique_ptr<BuffetConfig> config{new BuffetConfig{std::move(storage)}};
     config_ = config.get();
-    dev_reg_.reset(new DeviceRegistrationInfo{command_manager_, state_manager_,
-                                              std::move(config), transport_,
-                                              nullptr, true, nullptr});
+    dev_reg_.reset(new DeviceRegistrationInfo{command_manager_,
+                                              state_manager_,
+                                              std::move(config),
+                                              transport_,
+                                              nullptr,
+                                              true,
+                                              nullptr});
 
     ReloadConfig();
   }
@@ -186,8 +200,8 @@
     config_store.SetString("client_id", test_data::kClientId);
     config_store.SetString("client_secret", test_data::kClientSecret);
     config_store.SetString("api_key", test_data::kApiKey);
-    config_store.SetString("device_kind",  "vendor");
-    config_store.SetString("name",  "Coffee Pot");
+    config_store.SetString("device_kind", "vendor");
+    config_store.SetString("name", "Coffee Pot");
     config_store.SetString("description", "Easy to clean");
     config_store.SetString("location", "Kitchen");
     config_store.SetString("local_anonymous_access_role", "viewer");
@@ -222,9 +236,7 @@
     return succeeded;
   }
 
-  void SetAccessToken() {
-    dev_reg_->access_token_ = test_data::kAccessToken;
-  }
+  void SetAccessToken() { dev_reg_->access_token_ = test_data::kAccessToken; }
 
   RegistrationStatus GetRegistrationStatus() const {
     return dev_reg_->registration_status_;
@@ -248,14 +260,14 @@
   EXPECT_EQ(url, dev_reg_->GetServiceURL("registrationTickets"));
   url += "?key=";
   url += test_data::kApiKey;
-  EXPECT_EQ(url, dev_reg_->GetServiceURL("registrationTickets", {
-    {"key", test_data::kApiKey}
-  }));
+  EXPECT_EQ(url, dev_reg_->GetServiceURL("registrationTickets",
+                                         {{"key", test_data::kApiKey}}));
   url += "&restart=true";
-  EXPECT_EQ(url, dev_reg_->GetServiceURL("registrationTickets", {
-    {"key", test_data::kApiKey},
-    {"restart", "true"},
-  }));
+  EXPECT_EQ(url, dev_reg_->GetServiceURL(
+                     "registrationTickets",
+                     {
+                         {"key", test_data::kApiKey}, {"restart", "true"},
+                     }));
 }
 
 TEST_F(DeviceRegistrationInfoTest, GetOAuthURL) {
@@ -266,12 +278,12 @@
   url += "response_type=code&";
   url += "client_id=";
   url += test_data::kClientId;
-  EXPECT_EQ(url, dev_reg_->GetOAuthURL("auth", {
-    {"scope", "https://www.googleapis.com/auth/clouddevices"},
-    {"redirect_uri", "urn:ietf:wg:oauth:2.0:oob"},
-    {"response_type", "code"},
-    {"client_id", test_data::kClientId}
-  }));
+  EXPECT_EQ(url, dev_reg_->GetOAuthURL(
+                     "auth",
+                     {{"scope", "https://www.googleapis.com/auth/clouddevices"},
+                      {"redirect_uri", "urn:ietf:wg:oauth:2.0:oob"},
+                      {"response_type", "code"},
+                      {"client_id", test_data::kClientId}}));
 }
 
 TEST_F(DeviceRegistrationInfoTest, HaveRegistrationCredentials) {
@@ -339,8 +351,8 @@
   base::RunLoop run_loop;
 
   bool succeeded = false;
-  auto on_success =
-      [&run_loop, &succeeded, this](const base::DictionaryValue& info) {
+  auto on_success = [&run_loop, &succeeded, this](
+      const base::DictionaryValue& info) {
     EXPECT_EQ(1, transport_->GetRequestCount());
     std::string id;
     EXPECT_TRUE(info.GetString("id", &id));
@@ -456,13 +468,12 @@
   })");
   EXPECT_TRUE(command_manager_->LoadCommands(*json_cmds, "", nullptr));
 
-  transport_->AddHandler(dev_reg_->GetServiceURL(
-      std::string("registrationTickets/") + test_data::kClaimTicketId),
-      chromeos::http::request_type::kPatch,
-      base::Bind(update_ticket));
-  std::string ticket_url =
-      dev_reg_->GetServiceURL("registrationTickets/" +
-                             std::string(test_data::kClaimTicketId));
+  transport_->AddHandler(
+      dev_reg_->GetServiceURL(std::string("registrationTickets/") +
+                              test_data::kClaimTicketId),
+      chromeos::http::request_type::kPatch, base::Bind(update_ticket));
+  std::string ticket_url = dev_reg_->GetServiceURL(
+      "registrationTickets/" + std::string(test_data::kClaimTicketId));
   transport_->AddHandler(ticket_url + "/finalize",
                          chromeos::http::request_type::kPost,
                          base::Bind(FinalizeTicketHandler));
@@ -534,8 +545,7 @@
   ASSERT_NE(nullptr, command);
   StringPropType string_type;
   native_types::Object results{
-    {"status", string_type.CreateValue(std::string{"Ok"}, nullptr)}
-  };
+      {"status", string_type.CreateValue(std::string{"Ok"}, nullptr)}};
 
   // UpdateCommand when setting command results.
   auto update_command_results = [](const ServerRequest& request,
@@ -546,8 +556,7 @@
                         chromeos::http::FormFieldList{});
   };
 
-  transport_->AddHandler(command_url,
-                         chromeos::http::request_type::kPatch,
+  transport_->AddHandler(command_url, chromeos::http::request_type::kPatch,
                          base::Bind(update_command_results));
 
   command->SetResults(results);
@@ -567,8 +576,7 @@
                         chromeos::http::FormFieldList{});
   };
 
-  transport_->AddHandler(command_url,
-                         chromeos::http::request_type::kPatch,
+  transport_->AddHandler(command_url, chromeos::http::request_type::kPatch,
                          base::Bind(update_command_progress));
 
   native_types::Object progress{
@@ -584,12 +592,10 @@
                         chromeos::http::FormFieldList{});
   };
 
-  transport_->AddHandler(command_url,
-                         chromeos::http::request_type::kPatch,
+  transport_->AddHandler(command_url, chromeos::http::request_type::kPatch,
                          base::Bind(update_command_state));
 
   command->Cancel();
 }
 
-
 }  // namespace buffet
diff --git a/libweave/src/notification/notification_parser.cc b/libweave/src/notification/notification_parser.cc
index 4663050..1fe8878 100644
--- a/libweave/src/notification/notification_parser.cc
+++ b/libweave/src/notification/notification_parser.cc
@@ -67,5 +67,4 @@
   return true;
 }
 
-
 }  // namespace buffet
diff --git a/libweave/src/notification/pull_channel.cc b/libweave/src/notification/pull_channel.cc
index 249c1e9..69f20d1 100644
--- a/libweave/src/notification/pull_channel.cc
+++ b/libweave/src/notification/pull_channel.cc
@@ -13,8 +13,7 @@
 PullChannel::PullChannel(
     base::TimeDelta pull_interval,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
-    : pull_interval_{pull_interval},
-      timer_{true, true} {
+    : pull_interval_{pull_interval}, timer_{true, true} {
   timer_.SetTaskRunner(task_runner);
 }
 
@@ -22,7 +21,9 @@
   return "pull";
 }
 
-bool PullChannel::IsConnected() const { return true; }
+bool PullChannel::IsConnected() const {
+  return true;
+}
 
 void PullChannel::AddChannelParameters(base::DictionaryValue* channel_json) {
   // No extra parameters needed for "Pull" channel.
@@ -31,9 +32,9 @@
 void PullChannel::Start(NotificationDelegate* delegate) {
   CHECK(delegate);
   delegate_ = delegate;
-  timer_.Start(FROM_HERE, pull_interval_,
-               base::Bind(&PullChannel::OnTimer,
-                          weak_ptr_factory_.GetWeakPtr()));
+  timer_.Start(
+      FROM_HERE, pull_interval_,
+      base::Bind(&PullChannel::OnTimer, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PullChannel::Stop() {
diff --git a/libweave/src/notification/xml_node.cc b/libweave/src/notification/xml_node.cc
index 692710e..040d8eb 100644
--- a/libweave/src/notification/xml_node.cc
+++ b/libweave/src/notification/xml_node.cc
@@ -11,7 +11,8 @@
 
 XmlNode::XmlNode(const std::string& name,
                  std::map<std::string, std::string> attributes)
-    : name_{name}, attributes_{std::move(attributes)} {}
+    : name_{name}, attributes_{std::move(attributes)} {
+}
 
 const std::string& XmlNode::name() const {
   return name_;
diff --git a/libweave/src/notification/xml_node.h b/libweave/src/notification/xml_node.h
index 3b68a13..16c3b21 100644
--- a/libweave/src/notification/xml_node.h
+++ b/libweave/src/notification/xml_node.h
@@ -108,7 +108,6 @@
                                  bool recursive,
                                  std::vector<const XmlNode*>* children) const;
 
-
   const XmlNode* parent_{nullptr};  // Weak pointer to the parent node, if any.
   std::string name_;
   std::string text_;
@@ -121,4 +120,3 @@
 }  // namespace buffet
 
 #endif  // LIBWEAVE_SRC_NOTIFICATION_XML_NODE_H_
-
diff --git a/libweave/src/notification/xml_node_unittest.cc b/libweave/src/notification/xml_node_unittest.cc
index bd26364..6cbc9ec 100644
--- a/libweave/src/notification/xml_node_unittest.cc
+++ b/libweave/src/notification/xml_node_unittest.cc
@@ -42,14 +42,12 @@
 class XmlNodeTest : public testing::Test {
  public:
   void SetUp() override {
-    node_.reset(new XmlNode{"test_node",
-                            {{"attr1", "val1"}, {"attr2", "val2"}}});
+    node_.reset(
+        new XmlNode{"test_node", {{"attr1", "val1"}, {"attr2", "val2"}}});
   }
 
   // Accessor helpers for private members of XmlNode.
-  static const XmlNode* GetParent(const XmlNode& node) {
-    return node.parent_;
-  }
+  static const XmlNode* GetParent(const XmlNode& node) { return node.parent_; }
 
   static void SetText(XmlNode* node, const std::string& text) {
     node->SetText(text);
@@ -99,10 +97,8 @@
 }
 
 TEST_F(XmlNodeTest, Attributes) {
-  const std::map<std::string, std::string> expected_attrs{
-      {"attr1", "val1"},
-      {"attr2", "val2"}
-  };
+  const std::map<std::string, std::string> expected_attrs{{"attr1", "val1"},
+                                                          {"attr2", "val2"}};
   EXPECT_EQ(expected_attrs, node_->attributes());
   std::string attr = "bar";
   EXPECT_FALSE(node_->GetAttribute("foo", &attr));
diff --git a/libweave/src/notification/xmpp_channel.cc b/libweave/src/notification/xmpp_channel.cc
index 6c0a0e7..542ad61 100644
--- a/libweave/src/notification/xmpp_channel.cc
+++ b/libweave/src/notification/xmpp_channel.cc
@@ -24,24 +24,24 @@
 
 std::string BuildXmppStartStreamCommand() {
   return "<stream:stream to='clouddevices.gserviceaccount.com' "
-      "xmlns:stream='http://etherx.jabber.org/streams' "
-      "xml:lang='*' version='1.0' xmlns='jabber:client'>";
+         "xmlns:stream='http://etherx.jabber.org/streams' "
+         "xml:lang='*' version='1.0' xmlns='jabber:client'>";
 }
 
-std::string BuildXmppAuthenticateCommand(
-    const std::string& account, const std::string& token) {
+std::string BuildXmppAuthenticateCommand(const std::string& account,
+                                         const std::string& token) {
   chromeos::Blob credentials;
   credentials.push_back(0);
   credentials.insert(credentials.end(), account.begin(), account.end());
   credentials.push_back(0);
   credentials.insert(credentials.end(), token.begin(), token.end());
-  std::string msg = "<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' "
+  std::string msg =
+      "<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' "
       "mechanism='X-OAUTH2' auth:service='oauth2' "
       "auth:allow-non-google-login='true' "
       "auth:client-uses-full-bind-result='true' "
       "xmlns:auth='http://www.google.com/talk/protocol/auth'>" +
-      chromeos::data_encoding::Base64Encode(credentials) +
-      "</auth>";
+      chromeos::data_encoding::Base64Encode(credentials) + "</auth>";
   return msg;
 }
 
@@ -49,29 +49,29 @@
 // Note: In order to ensure a minimum of 20 seconds between server errors,
 // we have a 30s +- 10s (33%) jitter initial backoff.
 const chromeos::BackoffEntry::Policy kDefaultBackoffPolicy = {
-  // Number of initial errors (in sequence) to ignore before applying
-  // exponential back-off rules.
-  0,
+    // Number of initial errors (in sequence) to ignore before applying
+    // exponential back-off rules.
+    0,
 
-  // Initial delay for exponential back-off in ms.
-  30 * 1000,  // 30 seconds.
+    // Initial delay for exponential back-off in ms.
+    30 * 1000,  // 30 seconds.
 
-  // Factor by which the waiting time will be multiplied.
-  2,
+    // Factor by which the waiting time will be multiplied.
+    2,
 
-  // Fuzzing percentage. ex: 10% will spread requests randomly
-  // between 90%-100% of the calculated time.
-  0.33,  // 33%.
+    // Fuzzing percentage. ex: 10% will spread requests randomly
+    // between 90%-100% of the calculated time.
+    0.33,  // 33%.
 
-  // Maximum amount of time we are willing to delay our request in ms.
-  10 * 60 * 1000,  // 10 minutes.
+    // Maximum amount of time we are willing to delay our request in ms.
+    10 * 60 * 1000,  // 10 minutes.
 
-  // Time to keep an entry from being discarded even when it
-  // has no significant state, -1 to never discard.
-  -1,
+    // Time to keep an entry from being discarded even when it
+    // has no significant state, -1 to never discard.
+    -1,
 
-  // Don't use initial delay unless the last request was an error.
-  false,
+    // Don't use initial delay unless the last request was an error.
+    false,
 };
 
 const char kDefaultXmppHost[] = "talk.google.com";
@@ -251,8 +251,9 @@
     return;
   }
   state_ = XmppState::kSubscribeStarted;
-  std::string body = "<subscribe xmlns='google:push'>"
-                     "<item channel='cloud_devices' from=''/></subscribe>";
+  std::string body =
+      "<subscribe xmlns='google:push'>"
+      "<item channel='cloud_devices' from=''/></subscribe>";
   iq_stanza_handler_->SendRequest(
       "set", "", account_, body,
       base::Bind(&XmppChannel::OnSubscribed, task_ptr_factory_.GetWeakPtr()),
@@ -370,14 +371,15 @@
   Restart();
 }
 
-void XmppChannel::Connect(const std::string& host, uint16_t port,
+void XmppChannel::Connect(const std::string& host,
+                          uint16_t port,
                           const base::Closure& callback) {
   state_ = XmppState::kConnecting;
   LOG(INFO) << "Starting XMPP connection to " << host << ":" << port;
   int socket_fd = ConnectSocket(host, port);
   if (socket_fd >= 0) {
     raw_socket_ =
-      chromeos::FileStream::FromFileDescriptor(socket_fd, true, nullptr);
+        chromeos::FileStream::FromFileDescriptor(socket_fd, true, nullptr);
     if (!raw_socket_) {
       close(socket_fd);
       socket_fd = -1;
diff --git a/libweave/src/notification/xmpp_channel.h b/libweave/src/notification/xmpp_channel.h
index ab09418..9402b65 100644
--- a/libweave/src/notification/xmpp_channel.h
+++ b/libweave/src/notification/xmpp_channel.h
@@ -77,7 +77,8 @@
  protected:
   // These methods are internal helpers that can be overloaded by unit tests
   // to help provide unit-test-specific functionality.
-  virtual void Connect(const std::string& host, uint16_t port,
+  virtual void Connect(const std::string& host,
+                       uint16_t port,
                        const base::Closure& callback);
   virtual void SchedulePing(base::TimeDelta interval, base::TimeDelta timeout);
   void ScheduleRegularPing();
@@ -170,4 +171,3 @@
 }  // namespace buffet
 
 #endif  // LIBWEAVE_SRC_NOTIFICATION_XMPP_CHANNEL_H_
-
diff --git a/libweave/src/notification/xmpp_channel_unittest.cc b/libweave/src/notification/xmpp_channel_unittest.cc
index 7f5acc0..5f401ba 100644
--- a/libweave/src/notification/xmpp_channel_unittest.cc
+++ b/libweave/src/notification/xmpp_channel_unittest.cc
@@ -51,8 +51,7 @@
     "<bind xmlns=\"urn:ietf:params:xml:ns:xmpp-bind\">"
     "<jid>110cc78f78d7032cc7bf2c6e14c1fa7d@clouddevices.gserviceaccount.com"
     "/19853128</jid></bind></iq>";
-constexpr char kSessionResponse[] =
-    "<iq type=\"result\" id=\"2\"/>";
+constexpr char kSessionResponse[] = "<iq type=\"result\" id=\"2\"/>";
 constexpr char kSubscribedResponse[] =
     "<iq to=\""
     "110cc78f78d7032cc7bf2c6e14c1fa7d@clouddevices.gserviceaccount.com/"
@@ -87,9 +86,10 @@
 // TaskRunner::PostDelayedTask and verify the delays.
 class TestTaskRunner : public base::SingleThreadTaskRunner {
  public:
-  MOCK_METHOD3(PostDelayedTask, bool(const tracked_objects::Location&,
-                                     const base::Closure&,
-                                     base::TimeDelta));
+  MOCK_METHOD3(PostDelayedTask,
+               bool(const tracked_objects::Location&,
+                    const base::Closure&,
+                    base::TimeDelta));
   MOCK_METHOD3(PostNonNestableDelayedTask,
                bool(const tracked_objects::Location&,
                     const base::Closure&,
@@ -104,13 +104,15 @@
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::Clock* clock)
       : XmppChannel{kAccountName, kAccessToken, task_runner, nullptr},
-        fake_stream_{chromeos::Stream::AccessMode::READ_WRITE, task_runner,
+        fake_stream_{chromeos::Stream::AccessMode::READ_WRITE,
+                     task_runner,
                      clock} {}
 
   XmppState state() const { return state_; }
   void set_state(XmppState state) { state_ = state; }
 
-  void Connect(const std::string& host, uint16_t port,
+  void Connect(const std::string& host,
+               uint16_t port,
                const base::Closure& callback) override {
     set_state(XmppState::kConnecting);
     stream_ = &fake_stream_;
@@ -168,9 +170,7 @@
     }
   }
 
-  void SetIgnoreDelayedTasks(bool ignore) {
-    ignore_delayed_tasks_ = true;
-  }
+  void SetIgnoreDelayedTasks(bool ignore) { ignore_delayed_tasks_ = true; }
 
   std::unique_ptr<FakeXmppChannel> xmpp_client_;
   base::SimpleTestClock clock_;
@@ -194,8 +194,7 @@
 
 TEST_F(XmppChannelTest, HandleTLSCompleted) {
   StartWithState(XmppChannel::XmppState::kTlsCompleted);
-  xmpp_client_->fake_stream_.AddReadPacketString(
-      {}, kTlsStreamResponse);
+  xmpp_client_->fake_stream_.AddReadPacketString({}, kTlsStreamResponse);
   xmpp_client_->fake_stream_.ExpectWritePacketString({},
                                                      kAuthenticationMessage);
   RunTasks(4);
@@ -215,8 +214,8 @@
 
 TEST_F(XmppChannelTest, HandleAuthenticationFailedResponse) {
   StartWithState(XmppChannel::XmppState::kAuthenticationStarted);
-  xmpp_client_->fake_stream_.AddReadPacketString(
-      {}, kAuthenticationFailedResponse);
+  xmpp_client_->fake_stream_.AddReadPacketString({},
+                                                 kAuthenticationFailedResponse);
   RunTasks(3);
   EXPECT_EQ(XmppChannel::XmppState::kAuthenticationFailed,
             xmpp_client_->state());
@@ -228,28 +227,26 @@
   xmpp_client_->fake_stream_.AddReadPacketString({}, kRestartStreamResponse);
   xmpp_client_->fake_stream_.ExpectWritePacketString({}, kBindMessage);
   RunTasks(3);
-  EXPECT_EQ(XmppChannel::XmppState::kBindSent,
-            xmpp_client_->state());
+  EXPECT_EQ(XmppChannel::XmppState::kBindSent, xmpp_client_->state());
   EXPECT_TRUE(xmpp_client_->jid().empty());
 
   xmpp_client_->fake_stream_.AddReadPacketString({}, kBindResponse);
   xmpp_client_->fake_stream_.ExpectWritePacketString({}, kSessionMessage);
   RunTasks(9);
-  EXPECT_EQ(XmppChannel::XmppState::kSessionStarted,
-            xmpp_client_->state());
-  EXPECT_EQ("110cc78f78d7032cc7bf2c6e14c1fa7d@clouddevices.gserviceaccount.com"
-            "/19853128", xmpp_client_->jid());
+  EXPECT_EQ(XmppChannel::XmppState::kSessionStarted, xmpp_client_->state());
+  EXPECT_EQ(
+      "110cc78f78d7032cc7bf2c6e14c1fa7d@clouddevices.gserviceaccount.com"
+      "/19853128",
+      xmpp_client_->jid());
 
   xmpp_client_->fake_stream_.AddReadPacketString({}, kSessionResponse);
   xmpp_client_->fake_stream_.ExpectWritePacketString({}, kSubscribeMessage);
   RunTasks(4);
-  EXPECT_EQ(XmppChannel::XmppState::kSubscribeStarted,
-            xmpp_client_->state());
+  EXPECT_EQ(XmppChannel::XmppState::kSubscribeStarted, xmpp_client_->state());
 
   xmpp_client_->fake_stream_.AddReadPacketString({}, kSubscribedResponse);
   RunTasks(5);
-  EXPECT_EQ(XmppChannel::XmppState::kSubscribed,
-            xmpp_client_->state());
+  EXPECT_EQ(XmppChannel::XmppState::kSubscribed, xmpp_client_->state());
 }
 
 }  // namespace buffet
diff --git a/libweave/src/notification/xmpp_iq_stanza_handler.cc b/libweave/src/notification/xmpp_iq_stanza_handler.cc
index 95d3cc0..75529fa 100644
--- a/libweave/src/notification/xmpp_iq_stanza_handler.cc
+++ b/libweave/src/notification/xmpp_iq_stanza_handler.cc
@@ -39,9 +39,9 @@
         << "Source address contains invalid XML characters";
     base::StringAppendF(&from_attr, " from='%s'", from.c_str());
   }
-  return base::StringPrintf("<iq id='%s' type='%s'%s%s>%s</iq>",
-                            id.c_str(), type.c_str(), from_attr.c_str(),
-                            to_attr.c_str(), body.c_str());
+  return base::StringPrintf("<iq id='%s' type='%s'%s%s>%s</iq>", id.c_str(),
+                            type.c_str(), from_attr.c_str(), to_attr.c_str(),
+                            body.c_str());
 }
 
 }  // anonymous namespace
@@ -49,15 +49,15 @@
 IqStanzaHandler::IqStanzaHandler(
     XmppChannelInterface* xmpp_channel,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
-    : xmpp_channel_{xmpp_channel}, task_runner_{task_runner} {}
+    : xmpp_channel_{xmpp_channel}, task_runner_{task_runner} {
+}
 
-void IqStanzaHandler::SendRequest(
-    const std::string& type,
-    const std::string& from,
-    const std::string& to,
-    const std::string& body,
-    const ResponseCallback& response_callback,
-    const TimeoutCallback& timeout_callback) {
+void IqStanzaHandler::SendRequest(const std::string& type,
+                                  const std::string& from,
+                                  const std::string& to,
+                                  const std::string& body,
+                                  const ResponseCallback& response_callback,
+                                  const TimeoutCallback& timeout_callback) {
   return SendRequestWithCustomTimeout(
       type, from, to, body,
       base::TimeDelta::FromSeconds(kTimeoutIntervalSeconds), response_callback,
@@ -83,8 +83,8 @@
         timeout);
   }
 
-  std::string message = BuildIqStanza(std::to_string(last_request_id_),
-                                      type, to, from, body);
+  std::string message =
+      BuildIqStanza(std::to_string(last_request_id_), type, to, from, body);
   xmpp_channel_->SendMessage(message);
 }
 
@@ -112,8 +112,7 @@
     auto p = requests_.find(id);
     if (p != requests_.end()) {
       task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(p->second, base::Passed(std::move(stanza))));
+          FROM_HERE, base::Bind(p->second, base::Passed(std::move(stanza))));
       requests_.erase(p);
     }
   } else {
@@ -123,10 +122,9 @@
         "<error type='modify'>"
         "<feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
         "</error>";
-    std::string message = BuildIqStanza(id_str, "error",
-                                        stanza->GetAttributeOrEmpty("from"),
-                                        stanza->GetAttributeOrEmpty("to"),
-                                        error_body);
+    std::string message =
+        BuildIqStanza(id_str, "error", stanza->GetAttributeOrEmpty("from"),
+                      stanza->GetAttributeOrEmpty("to"), error_body);
     xmpp_channel_->SendMessage(message);
   }
   return true;
diff --git a/libweave/src/notification/xmpp_iq_stanza_handler.h b/libweave/src/notification/xmpp_iq_stanza_handler.h
index 4e80900..af19395 100644
--- a/libweave/src/notification/xmpp_iq_stanza_handler.h
+++ b/libweave/src/notification/xmpp_iq_stanza_handler.h
@@ -22,8 +22,7 @@
 
 class IqStanzaHandler {
  public:
-  using ResponseCallback =
-      base::Callback<void(std::unique_ptr<XmlNode>)>;
+  using ResponseCallback = base::Callback<void(std::unique_ptr<XmlNode>)>;
   using TimeoutCallback = base::Closure;
 
   IqStanzaHandler(
@@ -79,4 +78,3 @@
 }  // namespace buffet
 
 #endif  // LIBWEAVE_SRC_NOTIFICATION_XMPP_IQ_STANZA_HANDLER_H_
-
diff --git a/libweave/src/notification/xmpp_iq_stanza_handler_unittest.cc b/libweave/src/notification/xmpp_iq_stanza_handler_unittest.cc
index 36cf691..a953252 100644
--- a/libweave/src/notification/xmpp_iq_stanza_handler_unittest.cc
+++ b/libweave/src/notification/xmpp_iq_stanza_handler_unittest.cc
@@ -28,9 +28,10 @@
  public:
   TestTaskRunner() = default;
 
-  MOCK_METHOD3(PostDelayedTask, bool(const tracked_objects::Location&,
-                                     const base::Closure&,
-                                     base::TimeDelta));
+  MOCK_METHOD3(PostDelayedTask,
+               bool(const tracked_objects::Location&,
+                    const base::Closure&,
+                    base::TimeDelta));
   MOCK_METHOD3(PostNonNestableDelayedTask,
                bool(const tracked_objects::Location&,
                     const base::Closure&,
@@ -163,7 +164,8 @@
 
 TEST_F(IqStanzaHandlerTest, SequentialResponses) {
   EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _))
-      .Times(2).WillRepeatedly(Return(true));
+      .Times(2)
+      .WillRepeatedly(Return(true));
 
   EXPECT_CALL(mock_xmpp_channel_, SendMessage(_)).Times(2);
   iq_stanza_handler_->SendRequest("set", "", "", "<body/>",
@@ -172,7 +174,8 @@
                                   receiver_.callback(2), {});
 
   EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _))
-      .Times(2).WillRepeatedly(Invoke(task_invoker_));
+      .Times(2)
+      .WillRepeatedly(Invoke(task_invoker_));
 
   EXPECT_CALL(receiver_, OnResponse(1, "foo"));
   auto request = XmlParser{}.Parse("<iq id='1' type='result'><foo/></iq>");
@@ -185,7 +188,8 @@
 
 TEST_F(IqStanzaHandlerTest, OutOfOrderResponses) {
   EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _))
-      .Times(2).WillRepeatedly(Return(true));
+      .Times(2)
+      .WillRepeatedly(Return(true));
 
   EXPECT_CALL(mock_xmpp_channel_, SendMessage(_)).Times(2);
   iq_stanza_handler_->SendRequest("set", "", "", "<body/>",
@@ -194,7 +198,8 @@
                                   receiver_.callback(2), {});
 
   EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _))
-      .Times(2).WillRepeatedly(Invoke(task_invoker_));
+      .Times(2)
+      .WillRepeatedly(Invoke(task_invoker_));
 
   EXPECT_CALL(receiver_, OnResponse(2, "bar"));
   auto request = XmlParser{}.Parse("<iq id='2' type='result'><bar/></iq>");
diff --git a/libweave/src/notification/xmpp_stream_parser.cc b/libweave/src/notification/xmpp_stream_parser.cc
index b7bc939..9480e88 100644
--- a/libweave/src/notification/xmpp_stream_parser.cc
+++ b/libweave/src/notification/xmpp_stream_parser.cc
@@ -11,8 +11,7 @@
 XmppStreamParser::XmppStreamParser(Delegate* delegate) : delegate_{delegate} {
   parser_ = XML_ParserCreate(nullptr);
   XML_SetUserData(parser_, this);
-  XML_SetElementHandler(parser_,
-                        &XmppStreamParser::HandleElementStart,
+  XML_SetElementHandler(parser_, &XmppStreamParser::HandleElementStart,
                         &XmppStreamParser::HandleElementEnd);
   XML_SetCharacterDataHandler(parser_, &XmppStreamParser::HandleCharData);
 }
diff --git a/libweave/src/notification/xmpp_stream_parser.h b/libweave/src/notification/xmpp_stream_parser.h
index 2a1c401..2f5c87b 100644
--- a/libweave/src/notification/xmpp_stream_parser.h
+++ b/libweave/src/notification/xmpp_stream_parser.h
@@ -86,4 +86,3 @@
 }  // namespace buffet
 
 #endif  // LIBWEAVE_SRC_NOTIFICATION_XMPP_STREAM_PARSER_H_
-
diff --git a/libweave/src/notification/xmpp_stream_parser_unittest.cc b/libweave/src/notification/xmpp_stream_parser_unittest.cc
index 33c5e55..08cc4e5 100644
--- a/libweave/src/notification/xmpp_stream_parser_unittest.cc
+++ b/libweave/src/notification/xmpp_stream_parser_unittest.cc
@@ -43,9 +43,7 @@
 class XmppStreamParserTest : public testing::Test,
                              public XmppStreamParser::Delegate {
  public:
-  void SetUp() override {
-    parser_.reset(new XmppStreamParser{this});
-  }
+  void SetUp() override { parser_.reset(new XmppStreamParser{this}); }
 
   void OnStreamStart(const std::string& node_name,
                      std::map<std::string, std::string> attributes) override {
@@ -91,10 +89,8 @@
   parser_->ParseData("<foo bar=\"baz\" quux=\"1\">");
   EXPECT_TRUE(stream_started_);
   EXPECT_EQ("foo", stream_start_node_name_);
-  const std::map<std::string, std::string> expected_attrs{
-      {"bar", "baz"},
-      {"quux", "1"}
-  };
+  const std::map<std::string, std::string> expected_attrs{{"bar", "baz"},
+                                                          {"quux", "1"}};
   EXPECT_EQ(expected_attrs, stream_start_node_attributes_);
 }
 
@@ -109,10 +105,8 @@
   parser_->ParseData("=\"1\">");
   EXPECT_TRUE(stream_started_);
   EXPECT_EQ("foo", stream_start_node_name_);
-  const std::map<std::string, std::string> expected_attrs{
-      {"bar", "baz"},
-      {"quux", "1"}
-  };
+  const std::map<std::string, std::string> expected_attrs{{"bar", "baz"},
+                                                          {"quux", "1"}};
   EXPECT_EQ(expected_attrs, stream_start_node_attributes_);
 }
 
@@ -124,8 +118,7 @@
       {"id", "76EEB8FDB4495558"},
       {"version", "1.0"},
       {"xmlns:stream", "http://etherx.jabber.org/streams"},
-      {"xmlns", "jabber:client"}
-  };
+      {"xmlns", "jabber:client"}};
   // Try splitting the data into pieces from 1 character in size to the whole
   // data block and verify that we still can parse the whole message correctly.
   // Here |step| is the size of each individual data chunk.
@@ -159,11 +152,15 @@
     EXPECT_EQ("message", stanza2->name());
     ASSERT_EQ(2u, stanza2->attributes().size());
     EXPECT_TRUE(stanza2->GetAttribute("from", &value));
-    EXPECT_EQ("cloud-devices@clouddevices.google.com/"
-              "srvenc-xgbCfg9hX6tCpxoMYsExqg==", value);
+    EXPECT_EQ(
+        "cloud-devices@clouddevices.google.com/"
+        "srvenc-xgbCfg9hX6tCpxoMYsExqg==",
+        value);
     EXPECT_TRUE(stanza2->GetAttribute("to", &value));
-    EXPECT_EQ("4783f652b387449fc52a76f9a16e616f@clouddevices.gserviceaccount."
-              "com/5A85ED9C", value);
+    EXPECT_EQ(
+        "4783f652b387449fc52a76f9a16e616f@clouddevices.gserviceaccount."
+        "com/5A85ED9C",
+        value);
     ASSERT_EQ(1u, stanza2->children().size());
 
     const XmlNode* child = stanza2->children().back().get();
@@ -179,15 +176,18 @@
     EXPECT_EQ("push:recipient", child1->name());
     ASSERT_EQ(1u, child1->attributes().size());
     EXPECT_TRUE(child1->GetAttribute("to", &value));
-    EXPECT_EQ("4783f652b387449fc52a76f9a16e616f@clouddevices.gserviceaccount."
-              "com", value);
+    EXPECT_EQ(
+        "4783f652b387449fc52a76f9a16e616f@clouddevices.gserviceaccount."
+        "com",
+        value);
     EXPECT_TRUE(child1->children().empty());
 
     child2 = child->children()[1].get();
     EXPECT_EQ("push:data", child2->name());
     EXPECT_TRUE(child2->attributes().empty());
     EXPECT_TRUE(child2->children().empty());
-    const std::string expected_data = "eyJraW5kIjoiY2xvdWRkZXZpY2VzI25vdGlmaWNh"
+    const std::string expected_data =
+        "eyJraW5kIjoiY2xvdWRkZXZpY2VzI25vdGlmaWNh"
         "dGlvbiIsInR5cGUiOiJDT01NQU5EX0NSRUFURUQiLCJjb21tYW5kSWQiOiIwNWE3MTA5MC"
         "1hZWE4LWMzNzQtOTYwNS0xZTRhY2JhNDRmM2Y4OTAzZmM3Yy01NjExLWI5ODAtOTkyMy0y"
         "Njc2YjYwYzkxMGMiLCJkZXZpY2VJZCI6IjA1YTcxMDkwLWFlYTgtYzM3NC05NjA1LTFlNG"
diff --git a/libweave/src/privet/privet_handler.cc b/libweave/src/privet/privet_handler.cc
index 9b34498..67df4e7 100644
--- a/libweave/src/privet/privet_handler.cc
+++ b/libweave/src/privet/privet_handler.cc
@@ -597,9 +597,10 @@
              CreateManifestSection(model_id, *cloud_).release());
   output.Set(kInfoServicesKey, ToValue(cloud_->GetServices()).release());
 
-  output.Set(kInfoAuthenticationKey,
-             CreateInfoAuthSection(
-                 *security_, GetAnonymousMaxScope(*cloud_, wifi_)).release());
+  output.Set(
+      kInfoAuthenticationKey,
+      CreateInfoAuthSection(*security_, GetAnonymousMaxScope(*cloud_, wifi_))
+          .release());
 
   output.Set(kInfoEndpointsKey, CreateEndpointsSection(*device_).release());
 
diff --git a/libweave/src/privet/privet_handler_unittest.cc b/libweave/src/privet/privet_handler_unittest.cc
index a5491ff..a903d21 100644
--- a/libweave/src/privet/privet_handler_unittest.cc
+++ b/libweave/src/privet/privet_handler_unittest.cc
@@ -161,8 +161,8 @@
     EXPECT_CALL(cloud_, GetCloudId()).WillRepeatedly(Return(""));
     EXPECT_CALL(cloud_, GetConnectionState())
         .WillRepeatedly(ReturnRef(gcd_disabled_state_));
-    auto set_error =
-        [](const std::string&, const std::string&, chromeos::ErrorPtr* error) {
+    auto set_error = [](const std::string&, const std::string&,
+                        chromeos::ErrorPtr* error) {
       chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain,
                              "setupUnavailable", "");
     };
@@ -531,7 +531,8 @@
 
 TEST_F(PrivetHandlerSetupTest, SetupNameDescriptionLocation) {
   EXPECT_CALL(cloud_, UpdateDeviceInfo("testName", "testDescription",
-                                       "testLocation", _, _)).Times(1);
+                                       "testLocation", _, _))
+      .Times(1);
   const char kInput[] = R"({
     'name': 'testName',
     'description': 'testDescription',
@@ -572,8 +573,8 @@
       'passphrase': 'testPass'
     }
   })";
-  auto set_error =
-      [](const std::string&, const std::string&, chromeos::ErrorPtr* error) {
+  auto set_error = [](const std::string&, const std::string&,
+                      chromeos::ErrorPtr* error) {
     chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain, "deviceBusy", "");
   };
   EXPECT_CALL(wifi_, ConfigureCredentials(_, _, _))
@@ -614,8 +615,8 @@
     }
   })";
 
-  auto set_error =
-      [](const std::string&, const std::string&, chromeos::ErrorPtr* error) {
+  auto set_error = [](const std::string&, const std::string&,
+                      chromeos::ErrorPtr* error) {
     chromeos::Error::AddTo(error, FROM_HERE, errors::kDomain, "deviceBusy", "");
   };
   EXPECT_CALL(cloud_, Setup(_, _, _))
diff --git a/libweave/src/states/mock_state_change_queue_interface.h b/libweave/src/states/mock_state_change_queue_interface.h
index c11177a..5a2fcef 100644
--- a/libweave/src/states/mock_state_change_queue_interface.h
+++ b/libweave/src/states/mock_state_change_queue_interface.h
@@ -23,7 +23,7 @@
   MOCK_CONST_METHOD0(GetLastStateChangeId, UpdateID());
   MOCK_METHOD1(MockAddOnStateUpdatedCallback,
                base::CallbackList<void(UpdateID)>::Subscription*(
-                  const base::Callback<void(UpdateID)>&));
+                   const base::Callback<void(UpdateID)>&));
   MOCK_METHOD1(NotifyStateUpdatedOnServer, void(UpdateID));
 
  private:
diff --git a/libweave/src/states/state_change_queue_unittest.cc b/libweave/src/states/state_change_queue_unittest.cc
index c7778ee..e19ab08 100644
--- a/libweave/src/states/state_change_queue_unittest.cc
+++ b/libweave/src/states/state_change_queue_unittest.cc
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-
 #include "libweave/src/states/state_change_queue.h"
 
 #include <chromeos/bind_lambda.h>
@@ -14,13 +13,9 @@
 
 class StateChangeQueueTest : public ::testing::Test {
  public:
-  void SetUp() override {
-    queue_.reset(new StateChangeQueue(100));
-  }
+  void SetUp() override { queue_.reset(new StateChangeQueue(100)); }
 
-  void TearDown() override {
-    queue_.reset();
-  }
+  void TearDown() override { queue_.reset(); }
 
   std::unique_ptr<StateChangeQueue> queue_;
 };
@@ -33,9 +28,8 @@
 
 TEST_F(StateChangeQueueTest, UpdateOne) {
   StateChange change{
-    base::Time::Now(),
-    native_types::Object{{"prop.name", unittests::make_int_prop_value(23)}}
-  };
+      base::Time::Now(),
+      native_types::Object{{"prop.name", unittests::make_int_prop_value(23)}}};
   ASSERT_TRUE(queue_->NotifyPropertiesUpdated(change.timestamp,
                                               change.changed_properties));
   EXPECT_FALSE(queue_->IsEmpty());
@@ -51,19 +45,17 @@
 
 TEST_F(StateChangeQueueTest, UpdateMany) {
   StateChange change1{
-    base::Time::Now(),
-    native_types::Object{{"prop.name1", unittests::make_int_prop_value(23)}}
-  };
+      base::Time::Now(),
+      native_types::Object{{"prop.name1", unittests::make_int_prop_value(23)}}};
   ASSERT_TRUE(queue_->NotifyPropertiesUpdated(change1.timestamp,
                                               change1.changed_properties));
   StateChange change2{
-    base::Time::Now(),
-    native_types::Object{
-      {"prop.name1", unittests::make_int_prop_value(17)},
-      {"prop.name2", unittests::make_double_prop_value(1.0)},
-      {"prop.name3", unittests::make_bool_prop_value(false)},
-    }
-  };
+      base::Time::Now(),
+      native_types::Object{
+          {"prop.name1", unittests::make_int_prop_value(17)},
+          {"prop.name2", unittests::make_double_prop_value(1.0)},
+          {"prop.name3", unittests::make_bool_prop_value(false)},
+      }};
   ASSERT_TRUE(queue_->NotifyPropertiesUpdated(change2.timestamp,
                                               change2.changed_properties));
   EXPECT_EQ(2, queue_->GetLastStateChangeId());
@@ -103,11 +95,11 @@
   ASSERT_EQ(2, changes.size());
 
   native_types::Object expected1{
-    {"prop.name1", unittests::make_int_prop_value(3)},
-    {"prop.name2", unittests::make_int_prop_value(2)},
+      {"prop.name1", unittests::make_int_prop_value(3)},
+      {"prop.name2", unittests::make_int_prop_value(2)},
   };
   native_types::Object expected2{
-    {"prop.name1", unittests::make_int_prop_value(4)},
+      {"prop.name1", unittests::make_int_prop_value(4)},
   };
   EXPECT_EQ(timestamp, changes[0].timestamp);
   EXPECT_EQ(expected1, changes[0].changed_properties);
@@ -122,24 +114,23 @@
   base::TimeDelta time_delta2 = base::TimeDelta::FromMinutes(3);
 
   ASSERT_TRUE(queue_->NotifyPropertiesUpdated(
-      start_time,
-      native_types::Object{
-        {"prop.name1", unittests::make_int_prop_value(1)},
-        {"prop.name2", unittests::make_int_prop_value(2)},
-      }));
+      start_time, native_types::Object{
+                      {"prop.name1", unittests::make_int_prop_value(1)},
+                      {"prop.name2", unittests::make_int_prop_value(2)},
+                  }));
 
   ASSERT_TRUE(queue_->NotifyPropertiesUpdated(
       start_time + time_delta1,
       native_types::Object{
-        {"prop.name1", unittests::make_int_prop_value(3)},
-        {"prop.name3", unittests::make_int_prop_value(4)},
+          {"prop.name1", unittests::make_int_prop_value(3)},
+          {"prop.name3", unittests::make_int_prop_value(4)},
       }));
 
   ASSERT_TRUE(queue_->NotifyPropertiesUpdated(
       start_time + time_delta2,
       native_types::Object{
-        {"prop.name10", unittests::make_int_prop_value(10)},
-        {"prop.name11", unittests::make_int_prop_value(11)},
+          {"prop.name10", unittests::make_int_prop_value(10)},
+          {"prop.name11", unittests::make_int_prop_value(11)},
       }));
 
   EXPECT_EQ(3, queue_->GetLastStateChangeId());
@@ -147,16 +138,16 @@
   ASSERT_EQ(2, changes.size());
 
   native_types::Object expected1{
-    {"prop.name1", unittests::make_int_prop_value(3)},
-    {"prop.name2", unittests::make_int_prop_value(2)},
-    {"prop.name3", unittests::make_int_prop_value(4)},
+      {"prop.name1", unittests::make_int_prop_value(3)},
+      {"prop.name2", unittests::make_int_prop_value(2)},
+      {"prop.name3", unittests::make_int_prop_value(4)},
   };
   EXPECT_EQ(start_time + time_delta1, changes[0].timestamp);
   EXPECT_EQ(expected1, changes[0].changed_properties);
 
   native_types::Object expected2{
-    {"prop.name10", unittests::make_int_prop_value(10)},
-    {"prop.name11", unittests::make_int_prop_value(11)},
+      {"prop.name10", unittests::make_int_prop_value(10)},
+      {"prop.name11", unittests::make_int_prop_value(11)},
   };
   EXPECT_EQ(start_time + time_delta2, changes[1].timestamp);
   EXPECT_EQ(expected2, changes[1].changed_properties);
@@ -175,11 +166,10 @@
 TEST_F(StateChangeQueueTest, DelayedStateChangeNotification) {
   // When queue is not empty, registering a new callback will not trigger it.
   ASSERT_TRUE(queue_->NotifyPropertiesUpdated(
-      base::Time::Now(),
-      native_types::Object{
-        {"prop.name1", unittests::make_int_prop_value(1)},
-        {"prop.name2", unittests::make_int_prop_value(2)},
-      }));
+      base::Time::Now(), native_types::Object{
+                             {"prop.name1", unittests::make_int_prop_value(1)},
+                             {"prop.name2", unittests::make_int_prop_value(2)},
+                         }));
 
   auto callback = [](StateChangeQueueInterface::UpdateID id) {
     FAIL() << "This should not be called";
diff --git a/libweave/src/states/state_manager.cc b/libweave/src/states/state_manager.cc
index 4358c40..504f25b 100644
--- a/libweave/src/states/state_manager.cc
+++ b/libweave/src/states/state_manager.cc
@@ -24,7 +24,6 @@
 
 }  // namespace
 
-
 StateManager::StateManager(StateChangeQueueInterface* state_change_queue)
     : state_change_queue_(state_change_queue) {
   CHECK(state_change_queue_) << "State change queue not specified";
@@ -89,17 +88,15 @@
   } else {
     LOG(ERROR) << "Failed to read file for firmwareVersion.";
   }
-  CHECK(SetPropertyValue(kBaseStateFirmwareVersion,
-                         firmware_version,
-                         base::Time::Now(),
-                         nullptr));
+  CHECK(SetPropertyValue(kBaseStateFirmwareVersion, firmware_version,
+                         base::Time::Now(), nullptr));
 
   for (const auto& cb : on_changed_)
     cb.Run();
 }
 
 std::unique_ptr<base::DictionaryValue> StateManager::GetStateValuesAsJson(
-      chromeos::ErrorPtr* error) const {
+    chromeos::ErrorPtr* error) const {
   std::unique_ptr<base::DictionaryValue> dict{new base::DictionaryValue};
   for (const auto& pair : packages_) {
     auto pkg_value = pair.second->GetValuesAsJson(error);
@@ -152,16 +149,16 @@
   StatePackage* package = FindPackage(package_name);
   if (package == nullptr) {
     chromeos::Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
-                            errors::state::kPropertyNotDefined,
-                            "Unknown state property package '%s'",
-                            package_name.c_str());
+                                 errors::state::kPropertyNotDefined,
+                                 "Unknown state property package '%s'",
+                                 package_name.c_str());
     return false;
   }
   if (!package->SetPropertyValue(property_name, value, error))
     return false;
 
-  native_types::Object prop_set{{full_property_name,
-                                 package->GetProperty(property_name)}};
+  native_types::Object prop_set{
+      {full_property_name, package->GetProperty(property_name)}};
   state_change_queue_->NotifyPropertiesUpdated(timestamp, prop_set);
   return true;
 }
@@ -191,11 +188,10 @@
     }
     const base::DictionaryValue* package_dict = nullptr;
     if (!iter.value().GetAsDictionary(&package_dict)) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE,
-                                   chromeos::errors::json::kDomain,
-                                   chromeos::errors::json::kObjectExpected,
-                                   "State package '%s' must be an object",
-                                   package_name.c_str());
+      chromeos::Error::AddToPrintf(
+          error, FROM_HERE, chromeos::errors::json::kDomain,
+          chromeos::errors::json::kObjectExpected,
+          "State package '%s' must be an object", package_name.c_str());
       return false;
     }
     StatePackage* package = FindOrCreatePackage(package_name);
@@ -227,8 +223,7 @@
 
   if (!LoadStateDefinition(*json, category, error)) {
     chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
-                                 kFileReadError,
-                                 "Failed to load file '%s'",
+                                 kFileReadError, "Failed to load file '%s'",
                                  json_file_path.value().c_str());
     return false;
   }
@@ -243,8 +238,7 @@
     return false;
   if (!LoadStateDefinition(*json, kDefaultCategory, error)) {
     chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
-                                 kFileReadError,
-                                 "Failed to load file '%s'",
+                                 kFileReadError, "Failed to load file '%s'",
                                  json_file_path.value().c_str());
     return false;
   }
@@ -264,11 +258,10 @@
     }
     const base::DictionaryValue* package_dict = nullptr;
     if (!iter.value().GetAsDictionary(&package_dict)) {
-      chromeos::Error::AddToPrintf(error, FROM_HERE,
-                                   chromeos::errors::json::kDomain,
-                                   chromeos::errors::json::kObjectExpected,
-                                   "State package '%s' must be an object",
-                                   package_name.c_str());
+      chromeos::Error::AddToPrintf(
+          error, FROM_HERE, chromeos::errors::json::kDomain,
+          chromeos::errors::json::kObjectExpected,
+          "State package '%s' must be an object", package_name.c_str());
       return false;
     }
     StatePackage* package = FindPackage(package_name);
@@ -295,8 +288,7 @@
     return false;
   if (!LoadStateDefaults(*json, error)) {
     chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
-                                 kFileReadError,
-                                 "Failed to load file '%s'",
+                                 kFileReadError, "Failed to load file '%s'",
                                  json_file_path.value().c_str());
     return false;
   }
@@ -313,8 +305,8 @@
   StatePackage* package = FindPackage(package_name);
   if (package == nullptr) {
     std::unique_ptr<StatePackage> new_package{new StatePackage(package_name)};
-    package = packages_.emplace(package_name,
-                                std::move(new_package)).first->second.get();
+    package = packages_.emplace(package_name, std::move(new_package))
+                  .first->second.get();
   }
   return package;
 }
diff --git a/libweave/src/states/state_manager.h b/libweave/src/states/state_manager.h
index 83d1fdb..e502381 100644
--- a/libweave/src/states/state_manager.h
+++ b/libweave/src/states/state_manager.h
@@ -53,9 +53,7 @@
   // Returns all the categories the state properties are registered from.
   // As with GCD command handling, the category normally represent a device
   // service (daemon) that is responsible for a set of properties.
-  const std::set<std::string>& GetCategories() const {
-    return categories_;
-  }
+  const std::set<std::string>& GetCategories() const { return categories_; }
 
   // Returns the recorded state changes since last time this method has been
   // called.
diff --git a/libweave/src/states/state_package.cc b/libweave/src/states/state_package.cc
index 0b26006..825374e 100644
--- a/libweave/src/states/state_package.cc
+++ b/libweave/src/states/state_package.cc
@@ -28,9 +28,9 @@
   for (const auto& pair : schema.GetProps()) {
     if (types_.GetProp(pair.first)) {
       chromeos::Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
-                                    errors::state::kPropertyRedefinition,
-                                    "State property '%s.%s' is already defined",
-                                    name_.c_str(), pair.first.c_str());
+                                   errors::state::kPropertyRedefinition,
+                                   "State property '%s.%s' is already defined",
+                                   name_.c_str(), pair.first.c_str());
       return false;
     }
   }
@@ -53,9 +53,9 @@
     auto it = values_.find(property_name);
     if (it == values_.end()) {
       chromeos::Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
-                                    errors::state::kPropertyNotDefined,
-                                    "State property '%s.%s' is not defined",
-                                    name_.c_str(), property_name.c_str());
+                                   errors::state::kPropertyNotDefined,
+                                   "State property '%s.%s' is not defined",
+                                   name_.c_str(), property_name.c_str());
       return false;
     }
     auto new_value = it->second->GetPropType()->CreateValue();
@@ -68,7 +68,7 @@
 }
 
 std::unique_ptr<base::DictionaryValue> StatePackage::GetValuesAsJson(
-      chromeos::ErrorPtr* error) const {
+    chromeos::ErrorPtr* error) const {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
   for (const auto& pair : values_) {
     auto value = pair.second->ToJson(error);
@@ -86,9 +86,9 @@
   auto it = values_.find(property_name);
   if (it == values_.end()) {
     chromeos::Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
-                                  errors::state::kPropertyNotDefined,
-                                  "State property '%s.%s' is not defined",
-                                  name_.c_str(), property_name.c_str());
+                                 errors::state::kPropertyNotDefined,
+                                 "State property '%s.%s' is not defined",
+                                 name_.c_str(), property_name.c_str());
     return chromeos::Any();
   }
   return PropValueToDBusVariant(it->second.get());
@@ -100,13 +100,13 @@
   auto it = values_.find(property_name);
   if (it == values_.end()) {
     chromeos::Error::AddToPrintf(error, FROM_HERE, errors::state::kDomain,
-                                  errors::state::kPropertyNotDefined,
-                                  "State property '%s.%s' is not defined",
-                                  name_.c_str(), property_name.c_str());
+                                 errors::state::kPropertyNotDefined,
+                                 "State property '%s.%s' is not defined",
+                                 name_.c_str(), property_name.c_str());
     return false;
   }
-  auto new_value = PropValueFromDBusVariant(it->second->GetPropType(),
-                                            value, error);
+  auto new_value =
+      PropValueFromDBusVariant(it->second->GetPropType(), value, error);
   if (!new_value)
     return false;
   it->second = std::move(new_value);
diff --git a/libweave/src/states/state_package.h b/libweave/src/states/state_package.h
index 9666870..c2471f0 100644
--- a/libweave/src/states/state_package.h
+++ b/libweave/src/states/state_package.h
@@ -53,7 +53,7 @@
   //    }
   //  }
   std::unique_ptr<base::DictionaryValue> GetValuesAsJson(
-        chromeos::ErrorPtr* error) const;
+      chromeos::ErrorPtr* error) const;
 
   // Gets the value for a specific state property. |property_name| must not
   // include the package name as part of the property name.
@@ -65,11 +65,11 @@
                         const chromeos::Any& value,
                         chromeos::ErrorPtr* error);
 
-  std::shared_ptr<const PropValue>
-  GetProperty(const std::string& property_name) const {
+  std::shared_ptr<const PropValue> GetProperty(
+      const std::string& property_name) const {
     auto it = values_.find(property_name);
-    return it != values_.end() ?
-        it->second : std::shared_ptr<const PropValue>{};
+    return it != values_.end() ? it->second
+                               : std::shared_ptr<const PropValue>{};
   }
 
   // Returns the name of the this package.
diff --git a/libweave/src/states/state_package_unittest.cc b/libweave/src/states/state_package_unittest.cc
index 28aa62c..0b860cd 100644
--- a/libweave/src/states/state_package_unittest.cc
+++ b/libweave/src/states/state_package_unittest.cc
@@ -67,9 +67,7 @@
     ASSERT_TRUE(package_->AddSchemaFromJson(GetTestSchema().get(), nullptr));
     ASSERT_TRUE(package_->AddValuesFromJson(GetTestValues().get(), nullptr));
   }
-  void TearDown() override {
-    package_.reset();
-  }
+  void TearDown() override { package_.reset(); }
   std::unique_ptr<StatePackage> package_;
 };
 
@@ -250,13 +248,12 @@
   EXPECT_TRUE(value.IsEmpty());
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
   EXPECT_EQ(errors::state::kPropertyNotDefined, error->GetCode());
-  EXPECT_EQ("State property 'test.volume' is not defined",
-            error->GetMessage());
+  EXPECT_EQ("State property 'test.volume' is not defined", error->GetMessage());
 }
 
 TEST_F(StatePackageTest, SetPropertyValue_Simple) {
-  EXPECT_TRUE(package_->SetPropertyValue("color", std::string{"blue"},
-                                         nullptr));
+  EXPECT_TRUE(
+      package_->SetPropertyValue("color", std::string{"blue"}, nullptr));
   chromeos::Any value = package_->GetPropertyValue("color", nullptr);
   EXPECT_EQ("blue", value.TryGet<std::string>());
 
@@ -271,8 +268,7 @@
 
 TEST_F(StatePackageTest, SetPropertyValue_Object) {
   chromeos::VariantDictionary direction{
-    {"altitude", double{45.0}},
-    {"azimuth", double{15.0}},
+      {"altitude", double{45.0}}, {"azimuth", double{15.0}},
   };
   EXPECT_TRUE(package_->SetPropertyValue("direction", direction, nullptr));
 
@@ -314,8 +310,7 @@
 TEST_F(StatePackageTest, SetPropertyValue_Error_Object_TypeMismatch) {
   chromeos::ErrorPtr error;
   chromeos::VariantDictionary direction{
-    {"altitude", double{45.0}},
-    {"azimuth", int{15}},
+      {"altitude", double{45.0}}, {"azimuth", int{15}},
   };
   ASSERT_FALSE(package_->SetPropertyValue("direction", direction, &error));
   EXPECT_EQ(errors::commands::kDomain, error->GetDomain());
@@ -330,8 +325,7 @@
 TEST_F(StatePackageTest, SetPropertyValue_Error_Object_OutOfRange) {
   chromeos::ErrorPtr error;
   chromeos::VariantDictionary direction{
-    {"altitude", double{100.0}},
-    {"azimuth", double{290.0}},
+      {"altitude", double{100.0}}, {"azimuth", double{290.0}},
   };
   ASSERT_FALSE(package_->SetPropertyValue("direction", direction, &error));
   EXPECT_EQ(errors::commands::kDomain, error->GetDomain());
@@ -347,9 +341,9 @@
 TEST_F(StatePackageTest, SetPropertyValue_Error_Object_UnknownProperty) {
   chromeos::ErrorPtr error;
   chromeos::VariantDictionary direction{
-    {"altitude", double{10.0}},
-    {"azimuth", double{20.0}},
-    {"spin", double{30.0}},
+      {"altitude", double{10.0}},
+      {"azimuth", double{20.0}},
+      {"spin", double{30.0}},
   };
   ASSERT_FALSE(package_->SetPropertyValue("direction", direction, &error));
   EXPECT_EQ(errors::commands::kDomain, error->GetDomain());
@@ -360,7 +354,7 @@
 TEST_F(StatePackageTest, SetPropertyValue_Error_Object_MissingProperty) {
   chromeos::ErrorPtr error;
   chromeos::VariantDictionary direction{
-    {"altitude", double{10.0}},
+      {"altitude", double{10.0}},
   };
   ASSERT_FALSE(package_->SetPropertyValue("direction", direction, &error));
   EXPECT_EQ(errors::commands::kDomain, error->GetDomain());
@@ -373,8 +367,7 @@
   ASSERT_FALSE(package_->SetPropertyValue("volume", int{100}, &error));
   EXPECT_EQ(errors::state::kDomain, error->GetDomain());
   EXPECT_EQ(errors::state::kPropertyNotDefined, error->GetCode());
-  EXPECT_EQ("State property 'test.volume' is not defined",
-            error->GetMessage());
+  EXPECT_EQ("State property 'test.volume' is not defined", error->GetMessage());
 }
 
 }  // namespace buffet
diff --git a/libweave/src/storage_impls.cc b/libweave/src/storage_impls.cc
index 78b01cd..44a8925 100644
--- a/libweave/src/storage_impls.cc
+++ b/libweave/src/storage_impls.cc
@@ -14,7 +14,8 @@
 namespace buffet {
 
 FileStorage::FileStorage(const base::FilePath& file_path)
-    : file_path_(file_path) { }
+    : file_path_(file_path) {
+}
 
 std::unique_ptr<base::DictionaryValue> FileStorage::Load() {
   std::string json;
diff --git a/libweave/src/utils.cc b/libweave/src/utils.cc
index 547d371..411e74d 100644
--- a/libweave/src/utils.cc
+++ b/libweave/src/utils.cc
@@ -44,8 +44,7 @@
   if (!base::ReadFileToString(json_file_path, &json_string)) {
     chromeos::errors::system::AddSystemError(error, FROM_HERE, errno);
     chromeos::Error::AddToPrintf(error, FROM_HERE, kErrorDomainBuffet,
-                                 kFileReadError,
-                                 "Failed to read file '%s'",
+                                 kFileReadError, "Failed to read file '%s'",
                                  json_file_path.value().c_str());
     return {};
   }
@@ -60,12 +59,11 @@
   auto value = base::JSONReader::ReadAndReturnError(
       json_string, base::JSON_PARSE_RFC, nullptr, &error_message);
   if (!value) {
-    chromeos::Error::AddToPrintf(error, FROM_HERE,
-                                 chromeos::errors::json::kDomain,
-                                 chromeos::errors::json::kParseError,
-                                 "Error parsing JSON string '%s': %s",
-                                 LimitString(json_string, kMaxStrLen).c_str(),
-                                 error_message.c_str());
+    chromeos::Error::AddToPrintf(
+        error, FROM_HERE, chromeos::errors::json::kDomain,
+        chromeos::errors::json::kParseError,
+        "Error parsing JSON string '%s': %s",
+        LimitString(json_string, kMaxStrLen).c_str(), error_message.c_str());
     return result;
   }
   base::DictionaryValue* dict_value = nullptr;