[Sync] Move //sync to //components/sync.

components/sync/core_impl/sync_manager_impl_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
-#include "sync/internal_api/sync_manager_impl.h"
+#include "components/sync/core_impl/sync_manager_impl.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
+#include "components/sync/base/attachment_id_proto.h"
+#include "components/sync/base/cancelation_signal.h"
+#include "components/sync/base/cryptographer.h"
+#include "components/sync/base/extensions_activity.h"
+#include "components/sync/base/mock_unrecoverable_error_handler.h"
+#include "components/sync/base/model_type_test_util.h"
+#include "components/sync/base/time.h"
+#include "components/sync/core/change_record.h"
+#include "components/sync/core/http_post_provider_factory.h"
+#include "components/sync/core/http_post_provider_interface.h"
+#include "components/sync/core/read_node.h"
+#include "components/sync/core/read_transaction.h"
+#include "components/sync/core/test/test_entry_factory.h"
+#include "components/sync/core/test/test_internal_components_factory.h"
+#include "components/sync/core/test/test_user_share.h"
+#include "components/sync/core/write_node.h"
+#include "components/sync/core/write_transaction.h"
+#include "components/sync/core_impl/sync_encryption_handler_impl.h"
+#include "components/sync/core_impl/syncapi_internal.h"
+#include "components/sync/engine/events/protocol_event.h"
+#include "components/sync/engine/model_safe_worker.h"
+#include "components/sync/engine/polling_constants.h"
+#include "components/sync/engine_impl/sync_scheduler.h"
+#include "components/sync/js/js_backend.h"
+#include "components/sync/js/js_event_handler.h"
+#include "components/sync/js/js_test_util.h"
+#include "components/sync/protocol/bookmark_specifics.pb.h"
+#include "components/sync/protocol/encryption.pb.h"
+#include "components/sync/protocol/extension_specifics.pb.h"
+#include "components/sync/protocol/password_specifics.pb.h"
+#include "components/sync/protocol/preference_specifics.pb.h"
+#include "components/sync/protocol/proto_value_conversions.h"
+#include "components/sync/protocol/sync.pb.h"
+#include "components/sync/sessions_impl/sync_session.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/mutable_entry.h"
+#include "components/sync/syncable/nigori_util.h"
+#include "components/sync/syncable/syncable_id.h"
+#include "components/sync/syncable/syncable_read_transaction.h"
+#include "components/sync/syncable/syncable_util.h"
+#include "components/sync/syncable/syncable_write_transaction.h"
+#include "components/sync/test/callback_counter.h"
+#include "components/sync/test/engine/fake_model_worker.h"
+#include "components/sync/test/engine/fake_sync_scheduler.h"
+#include "components/sync/test/engine/test_id_factory.h"
+#include "components/sync/test/fake_encryptor.h"
 #include "google_apis/gaia/gaia_constants.h"
-#include "sync/engine/sync_scheduler.h"
-#include "sync/internal_api/public/base/attachment_id_proto.h"
-#include "sync/internal_api/public/base/cancelation_signal.h"
-#include "sync/internal_api/public/base/model_type_test_util.h"
-#include "sync/internal_api/public/change_record.h"
-#include "sync/internal_api/public/engine/model_safe_worker.h"
-#include "sync/internal_api/public/engine/polling_constants.h"
-#include "sync/internal_api/public/events/protocol_event.h"
-#include "sync/internal_api/public/http_post_provider_factory.h"
-#include "sync/internal_api/public/http_post_provider_interface.h"
-#include "sync/internal_api/public/read_node.h"
-#include "sync/internal_api/public/read_transaction.h"
-#include "sync/internal_api/public/test/test_entry_factory.h"
-#include "sync/internal_api/public/test/test_internal_components_factory.h"
-#include "sync/internal_api/public/test/test_user_share.h"
-#include "sync/internal_api/public/write_node.h"
-#include "sync/internal_api/public/write_transaction.h"
-#include "sync/internal_api/sync_encryption_handler_impl.h"
-#include "sync/internal_api/syncapi_internal.h"
-#include "sync/js/js_backend.h"
-#include "sync/js/js_event_handler.h"
-#include "sync/js/js_test_util.h"
-#include "sync/protocol/bookmark_specifics.pb.h"
-#include "sync/protocol/encryption.pb.h"
-#include "sync/protocol/extension_specifics.pb.h"
-#include "sync/protocol/password_specifics.pb.h"
-#include "sync/protocol/preference_specifics.pb.h"
-#include "sync/protocol/proto_value_conversions.h"
-#include "sync/protocol/sync.pb.h"
-#include "sync/sessions/sync_session.h"
-#include "sync/syncable/directory.h"
-#include "sync/syncable/entry.h"
-#include "sync/syncable/mutable_entry.h"
-#include "sync/syncable/nigori_util.h"
-#include "sync/syncable/syncable_id.h"
-#include "sync/syncable/syncable_read_transaction.h"
-#include "sync/syncable/syncable_util.h"
-#include "sync/syncable/syncable_write_transaction.h"
-#include "sync/test/callback_counter.h"
-#include "sync/test/engine/fake_model_worker.h"
-#include "sync/test/engine/fake_sync_scheduler.h"
-#include "sync/test/engine/test_id_factory.h"
-#include "sync/test/fake_encryptor.h"
-#include "sync/util/cryptographer.h"
-#include "sync/util/extensions_activity.h"
-#include "sync/util/mock_unrecoverable_error_handler.h"
-#include "sync/util/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/protobuf/src/google/protobuf/io/coded_stream.h"
 #include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h"
 #include "url/gurl.h"
 
 using base::ExpectDictStringValue;
 using testing::_;
 using testing::DoAll;
 using testing::InSequence;
@@ skipping 68 matching lines @@
   EXPECT_TRUE(node.InitBookmarkByCreation(parent_node, predecessor));
   return node.GetId();
 }
 
 // Creates the "synced" root node for a particular datatype. We use the syncable
 // methods here so that the syncer treats these nodes as if they were already
 // received from the server.
 int64_t MakeTypeRoot(UserShare* share, ModelType model_type) {
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(model_type, &specifics);
-  syncable::WriteTransaction trans(
-      FROM_HERE, syncable::UNITTEST, share->directory.get());
+  syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST,
+                                   share->directory.get());
   // Attempt to lookup by nigori tag.
   std::string type_tag = ModelTypeToRootTag(model_type);
   syncable::Id node_id = syncable::Id::CreateFromServerId(type_tag);
   syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
                                node_id);
   EXPECT_TRUE(entry.good());
   entry.PutBaseVersion(1);
   entry.PutServerVersion(1);
   entry.PutIsUnappliedUpdate(false);
   entry.PutParentId(syncable::Id::GetRoot());
   entry.PutServerParentId(syncable::Id::GetRoot());
   entry.PutServerIsDir(true);
   entry.PutIsDir(true);
   entry.PutServerSpecifics(specifics);
   entry.PutSpecifics(specifics);
   entry.PutUniqueServerTag(type_tag);
   entry.PutNonUniqueName(type_tag);
   entry.PutIsDel(false);
   return entry.GetMetahandle();
 }
 
 // Simulates creating a "synced" node as a child of the root datatype node.
 int64_t MakeServerNode(UserShare* share,
                        ModelType model_type,
                        const std::string& client_tag,
                        const std::string& hashed_tag,
                        const sync_pb::EntitySpecifics& specifics) {
-  syncable::WriteTransaction trans(
-      FROM_HERE, syncable::UNITTEST, share->directory.get());
+  syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST,
+                                   share->directory.get());
   syncable::Entry root_entry(&trans, syncable::GET_TYPE_ROOT, model_type);
   EXPECT_TRUE(root_entry.good());
   syncable::Id root_id = root_entry.GetId();
   syncable::Id node_id = syncable::Id::CreateFromServerId(client_tag);
   syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
                                node_id);
   EXPECT_TRUE(entry.good());
   entry.PutBaseVersion(1);
   entry.PutServerVersion(1);
   entry.PutIsUnappliedUpdate(false);
@@ skipping 177 matching lines @@
 
   ignore_result(MakeNodeWithRoot(user_share(), BOOKMARKS, "collideme"));
   ignore_result(MakeNodeWithRoot(user_share(), PREFERENCES, "collideme"));
   ignore_result(MakeNodeWithRoot(user_share(), AUTOFILL, "collideme"));
 
   {
     ReadTransaction trans(FROM_HERE, user_share());
 
     ReadNode bookmarknode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              bookmarknode.InitByClientTagLookup(BOOKMARKS,
-                  "collideme"));
+              bookmarknode.InitByClientTagLookup(BOOKMARKS, "collideme"));
 
     ReadNode prefnode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              prefnode.InitByClientTagLookup(PREFERENCES,
-                  "collideme"));
+              prefnode.InitByClientTagLookup(PREFERENCES, "collideme"));
 
     ReadNode autofillnode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              autofillnode.InitByClientTagLookup(AUTOFILL,
-                  "collideme"));
+              autofillnode.InitByClientTagLookup(AUTOFILL, "collideme"));
 
     EXPECT_NE(bookmarknode.GetId(), prefnode.GetId());
     EXPECT_NE(autofillnode.GetId(), prefnode.GetId());
     EXPECT_NE(bookmarknode.GetId(), autofillnode.GetId());
   }
 }
 
 TEST_F(SyncApiTest, ReadMissingTagsFails) {
   {
     ReadTransaction trans(FROM_HERE, user_share());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
-              node.InitByClientTagLookup(BOOKMARKS,
-                  "testtag"));
+              node.InitByClientTagLookup(BOOKMARKS, "testtag"));
   }
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
-              node.InitByClientTagLookup(BOOKMARKS,
-                  "testtag"));
+              node.InitByClientTagLookup(BOOKMARKS, "testtag"));
   }
 }
 
 // TODO(chron): Hook this all up to the server and write full integration tests
 //              for update->undelete behavior.
 TEST_F(SyncApiTest, TestDeleteBehavior) {
   int64_t node_id;
   int64_t folder_id;
   std::string test_title("test1");
 
@@ skipping 15 matching lines @@
     wnode.SetTitle(test_title);
 
     node_id = wnode.GetId();
   }
 
   // Ensure we can delete something with a tag.
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode wnode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              wnode.InitByClientTagLookup(BOOKMARKS,
-                  "testtag"));
+              wnode.InitByClientTagLookup(BOOKMARKS, "testtag"));
     EXPECT_FALSE(wnode.GetIsFolder());
     EXPECT_EQ(wnode.GetTitle(), test_title);
 
     wnode.Tombstone();
   }
 
   // Lookup of a node which was deleted should return failure,
   // but have found some data about the node.
   {
     ReadTransaction trans(FROM_HERE, user_share());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_IS_DEL,
-              node.InitByClientTagLookup(BOOKMARKS,
-                  "testtag"));
+              node.InitByClientTagLookup(BOOKMARKS, "testtag"));
     // Note that for proper function of this API this doesn't need to be
     // filled, we're checking just to make sure the DB worked in this test.
     EXPECT_EQ(node.GetTitle(), test_title);
   }
 
   {
     WriteTransaction trans(FROM_HERE, user_share());
     ReadNode folder_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, folder_node.InitByIdLookup(folder_id));
 
     WriteNode wnode(&trans);
     // This will undelete the tag.
     WriteNode::InitUniqueByCreationResult result =
         wnode.InitUniqueByCreation(BOOKMARKS, folder_node, "testtag");
     EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     EXPECT_EQ(wnode.GetIsFolder(), false);
     EXPECT_EQ(wnode.GetParentId(), folder_node.GetId());
     EXPECT_EQ(wnode.GetId(), node_id);
     EXPECT_NE(wnode.GetTitle(), test_title);  // Title should be cleared
     wnode.SetTitle(test_title);
   }
 
   // Now look up should work.
   {
     ReadTransaction trans(FROM_HERE, user_share());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(BOOKMARKS,
-                    "testtag"));
+              node.InitByClientTagLookup(BOOKMARKS, "testtag"));
     EXPECT_EQ(node.GetTitle(), test_title);
     EXPECT_EQ(node.GetModelType(), BOOKMARKS);
   }
 }
 
 TEST_F(SyncApiTest, WriteAndReadPassword) {
   KeyParams params = {"localhost", "username", "passphrase"};
   {
     ReadTransaction trans(FROM_HERE, user_share());
     trans.GetCryptographer()->AddKey(params);
   }
   {
     WriteTransaction trans(FROM_HERE, user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
     WriteNode::InitUniqueByCreationResult result =
-        password_node.InitUniqueByCreation(PASSWORDS,
-                                           root_node, "foo");
+        password_node.InitUniqueByCreation(PASSWORDS, root_node, "foo");
     EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     password_node.SetPasswordSpecifics(data);
   }
   {
     ReadTransaction trans(FROM_HERE, user_share());
 
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
@@ skipping 27 matching lines @@
         pref_node.InitUniqueByCreation(PREFERENCES, root_node, "bar");
     ASSERT_EQ(WriteNode::INIT_SUCCESS, result);
     pref_node.SetTitle("bar");
   }
   {
     ReadTransaction trans(FROM_HERE, user_share());
 
     ReadNode bookmark_node(&trans);
     ASSERT_EQ(BaseNode::INIT_OK, bookmark_node.InitByIdLookup(bookmark_id));
     EXPECT_EQ("foo", bookmark_node.GetTitle());
-    EXPECT_EQ(kEncryptedString,
-              bookmark_node.GetEntry()->GetNonUniqueName());
+    EXPECT_EQ(kEncryptedString, bookmark_node.GetEntry()->GetNonUniqueName());
 
     ReadNode pref_node(&trans);
     ASSERT_EQ(BaseNode::INIT_OK,
-              pref_node.InitByClientTagLookup(PREFERENCES,
-                                              "bar"));
+              pref_node.InitByClientTagLookup(PREFERENCES, "bar"));
     EXPECT_EQ(kEncryptedString, pref_node.GetTitle());
   }
 }
 
 // Non-unique name should not be empty. For bookmarks non-unique name is copied
 // from bookmark title. This test verifies that setting bookmark title to ""
 // results in single space title and non-unique name in internal representation.
 // GetTitle should still return empty string.
 TEST_F(SyncApiTest, WriteEmptyBookmarkTitle) {
   int bookmark_id;
@@ skipping 39 matching lines @@
   WriteTransaction trans(FROM_HERE, user_share());
   WriteNode node(&trans);
   EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
   EXPECT_TRUE(node.GetEntitySpecifics().unknown_fields().empty());
 
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("http://www.google.com");
   std::string unknown_fields;
   {
     ::google::protobuf::io::StringOutputStream unknown_fields_stream(
-         &unknown_fields);
+        &unknown_fields);
     ::google::protobuf::io::CodedOutputStream output(&unknown_fields_stream);
     const int tag = 5;
     const int value = 100;
     output.WriteTag(tag);
     output.WriteLittleEndian32(value);
   }
   *entity_specifics.mutable_unknown_fields() = unknown_fields;
   node.SetEntitySpecifics(entity_specifics);
   EXPECT_FALSE(node.GetEntitySpecifics().unknown_fields().empty());
   EXPECT_EQ(unknown_fields, node.GetEntitySpecifics().unknown_fields());
@@ skipping 254 matching lines @@
 };
 
 class SyncManagerObserverMock : public SyncManager::Observer {
  public:
   MOCK_METHOD1(OnSyncCycleCompleted,
                void(const SyncSessionSnapshot&));  // NOLINT
   MOCK_METHOD4(OnInitializationComplete,
                void(const WeakHandle<JsBackend>&,
                     const WeakHandle<DataTypeDebugInfoListener>&,
                     bool,
-                    syncer::ModelTypeSet));  // NOLINT
-  MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus));  // NOLINT
-  MOCK_METHOD1(OnUpdatedToken, void(const std::string&));  // NOLINT
+                    syncer::ModelTypeSet));                         // NOLINT
+  MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus));   // NOLINT
+  MOCK_METHOD1(OnUpdatedToken, void(const std::string&));           // NOLINT
   MOCK_METHOD1(OnActionableError, void(const SyncProtocolError&));  // NOLINT
-  MOCK_METHOD1(OnMigrationRequested, void(syncer::ModelTypeSet));  // NOLINT
-  MOCK_METHOD1(OnProtocolEvent, void(const ProtocolEvent&));  // NOLINT
+  MOCK_METHOD1(OnMigrationRequested, void(syncer::ModelTypeSet));   // NOLINT
+  MOCK_METHOD1(OnProtocolEvent, void(const ProtocolEvent&));        // NOLINT
 };
 
 class SyncEncryptionHandlerObserverMock
     : public SyncEncryptionHandler::Observer {
  public:
   MOCK_METHOD2(OnPassphraseRequired,
                void(PassphraseRequiredReason,
                     const sync_pb::EncryptedData&));  // NOLINT
-  MOCK_METHOD0(OnPassphraseAccepted, void());  // NOLINT
+  MOCK_METHOD0(OnPassphraseAccepted, void());         // NOLINT
   MOCK_METHOD2(OnBootstrapTokenUpdated,
                void(const std::string&, BootstrapTokenType type));  // NOLINT
-  MOCK_METHOD2(OnEncryptedTypesChanged,
-               void(ModelTypeSet, bool));  // NOLINT
-  MOCK_METHOD0(OnEncryptionComplete, void());  // NOLINT
+  MOCK_METHOD2(OnEncryptedTypesChanged, void(ModelTypeSet, bool));  // NOLINT
+  MOCK_METHOD0(OnEncryptionComplete, void());                       // NOLINT
   MOCK_METHOD1(OnCryptographerStateChanged, void(Cryptographer*));  // NOLINT
-  MOCK_METHOD2(OnPassphraseTypeChanged, void(PassphraseType,
-                                             base::Time));  // NOLINT
+  MOCK_METHOD2(OnPassphraseTypeChanged,
+               void(PassphraseType,
+                    base::Time));  // NOLINT
   MOCK_METHOD1(OnLocalSetPassphraseEncryption,
                void(const SyncEncryptionHandler::NigoriState&));  // NOLINT
 };
 
 }  // namespace
 
 class SyncManagerTest : public testing::Test,
                         public SyncManager::ChangeDelegate {
  protected:
-  enum NigoriStatus {
-    DONT_WRITE_NIGORI,
-    WRITE_TO_NIGORI
-  };
+  enum NigoriStatus { DONT_WRITE_NIGORI, WRITE_TO_NIGORI };
 
-  enum EncryptionStatus {
-    UNINITIALIZED,
-    DEFAULT_ENCRYPTION,
-    FULL_ENCRYPTION
-  };
+  enum EncryptionStatus { UNINITIALIZED, DEFAULT_ENCRYPTION, FULL_ENCRYPTION };
 
-  SyncManagerTest()
-      : sync_manager_("Test sync manager") {
+  SyncManagerTest() : sync_manager_("Test sync manager") {
     switches_.encryption_method =
         InternalComponentsFactory::ENCRYPTION_KEYSTORE;
   }
 
-  virtual ~SyncManagerTest() {
-  }
+  virtual ~SyncManagerTest() {}
 
   // Test implementation.
   void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     extensions_activity_ = new ExtensionsActivity();
 
     SyncCredentials credentials;
     credentials.account_id = "foo@bar.com";
     credentials.email = "foo@bar.com";
     credentials.sync_token = "sometoken";
     OAuth2TokenService::ScopeSet scope_set;
     scope_set.insert(GaiaConstants::kChromeSyncOAuth2Scope);
     credentials.scope_set = scope_set;
 
     sync_manager_.AddObserver(&manager_observer_);
-    EXPECT_CALL(manager_observer_, OnInitializationComplete(_, _, _, _)).
-        WillOnce(DoAll(SaveArg<0>(&js_backend_),
-            SaveArg<2>(&initialization_succeeded_)));
+    EXPECT_CALL(manager_observer_, OnInitializationComplete(_, _, _, _))
+        .WillOnce(DoAll(SaveArg<0>(&js_backend_),
+                        SaveArg<2>(&initialization_succeeded_)));
 
     EXPECT_FALSE(js_backend_.IsInitialized());
 
-    std::vector<scoped_refptr<ModelSafeWorker> > workers;
+    std::vector<scoped_refptr<ModelSafeWorker>> workers;
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
     // This works only because all routing info types are GROUP_PASSIVE.
     // If we had types in other groups, we would need additional workers
     // to support them.
     scoped_refptr<ModelSafeWorker> worker = new FakeModelWorker(GROUP_PASSIVE);
     workers.push_back(worker);
 
     SyncManager::InitArgs args;
     args.database_location = temp_dir_.path();
     args.service_url = GURL("https://example.com/");
     args.post_factory = std::unique_ptr<HttpPostProviderFactory>(
         new TestHttpPostProviderFactory());
     args.workers = workers;
     args.extensions_activity = extensions_activity_.get(),
     args.change_delegate = this;
     args.credentials = credentials;
     args.invalidator_client_id = "fake_invalidator_client_id";
     args.internal_components_factory.reset(GetFactory());
     args.encryptor = &encryptor_;
     args.unrecoverable_error_handler =
         MakeWeakHandle(mock_unrecoverable_error_handler_.GetWeakPtr());
     args.cancelation_signal = &cancelation_signal_;
     sync_manager_.Init(&args);
 
     sync_manager_.GetEncryptionHandler()->AddObserver(&encryption_observer_);
 
     EXPECT_TRUE(js_backend_.IsInitialized());
-    EXPECT_EQ(InternalComponentsFactory::STORAGE_ON_DISK,
-              storage_used_);
+    EXPECT_EQ(InternalComponentsFactory::STORAGE_ON_DISK, storage_used_);
 
     if (initialization_succeeded_) {
       for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
            i != routing_info.end(); ++i) {
         type_roots_[i->first] =
             MakeTypeRoot(sync_manager_.GetUserShare(), i->first);
       }
     }
 
     PumpLoop();
@@ skipping 52 matching lines @@
     if (encryption_status != UNINITIALIZED) {
       KeyParams params = {"localhost", "dummy", "foobar"};
       cryptographer->AddKey(params);
     } else {
       DCHECK_NE(nigori_status, WRITE_TO_NIGORI);
     }
     if (nigori_status == WRITE_TO_NIGORI) {
       sync_pb::NigoriSpecifics nigori;
       cryptographer->GetKeys(nigori.mutable_encryption_keybag());
       share->directory->GetNigoriHandler()->UpdateNigoriFromEncryptedTypes(
-          &nigori,
-          trans.GetWrappedTrans());
+          &nigori, trans.GetWrappedTrans());
       WriteNode node(&trans);
       EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(nigori_id));
       node.SetNigoriSpecifics(nigori);
     }
     return cryptographer->is_ready();
   }
 
   int64_t GetIdForDataType(ModelType type) {
     if (type_roots_.count(type) == 0)
       return 0;
     return type_roots_[type];
   }
 
-  void PumpLoop() {
-    base::RunLoop().RunUntilIdle();
-  }
+  void PumpLoop() { base::RunLoop().RunUntilIdle(); }
 
   void SetJsEventHandler(const WeakHandle<JsEventHandler>& event_handler) {
-    js_backend_.Call(FROM_HERE, &JsBackend::SetJsEventHandler,
-                     event_handler);
+    js_backend_.Call(FROM_HERE, &JsBackend::SetJsEventHandler, event_handler);
     PumpLoop();
   }
 
   // Looks up an entry by client tag and resets IS_UNSYNCED value to false.
   // Returns true if entry was previously unsynced, false if IS_UNSYNCED was
   // already false.
-  bool ResetUnsyncedEntry(ModelType type,
-                          const std::string& client_tag) {
+  bool ResetUnsyncedEntry(ModelType type, const std::string& client_tag) {
     UserShare* share = sync_manager_.GetUserShare();
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::UNITTEST, share->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST,
+                                     share->directory.get());
     const std::string hash = syncable::GenerateSyncableHash(type, client_tag);
-    syncable::MutableEntry entry(&trans, syncable::GET_BY_CLIENT_TAG,
-                                 hash);
+    syncable::MutableEntry entry(&trans, syncable::GET_BY_CLIENT_TAG, hash);
     EXPECT_TRUE(entry.good());
     if (!entry.GetIsUnsynced())
       return false;
     entry.PutIsUnsynced(false);
     return true;
   }
 
   virtual InternalComponentsFactory* GetFactory() {
     return new TestInternalComponentsFactory(
         GetSwitches(), InternalComponentsFactory::STORAGE_IN_MEMORY,
         &storage_used_);
   }
 
   // Returns true if we are currently encrypting all sync data.  May
   // be called on any thread.
   bool IsEncryptEverythingEnabledForTest() {
     return sync_manager_.GetEncryptionHandler()->IsEncryptEverythingEnabled();
   }
 
   // Gets the set of encrypted types from the cryptographer
   // Note: opens a transaction.  May be called from any thread.
   ModelTypeSet GetEncryptedTypes() {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     return GetEncryptedTypesWithTrans(&trans);
   }
 
   ModelTypeSet GetEncryptedTypesWithTrans(BaseTransaction* trans) {
-    return trans->GetDirectory()->GetNigoriHandler()->
-        GetEncryptedTypes(trans->GetWrappedTrans());
+    return trans->GetDirectory()->GetNigoriHandler()->GetEncryptedTypes(
+        trans->GetWrappedTrans());
   }
 
   void SimulateInvalidatorEnabledForTest(bool is_enabled) {
     DCHECK(sync_manager_.thread_checker_.CalledOnValidThread());
     sync_manager_.SetInvalidatorEnabled(is_enabled);
   }
 
   void SetProgressMarkerForType(ModelType type, bool set) {
     if (set) {
       sync_pb::DataTypeProgressMarker marker;
       marker.set_token("token");
       marker.set_data_type_id(GetSpecificsFieldNumberFromModelType(type));
       sync_manager_.directory()->SetDownloadProgress(type, marker);
     } else {
       sync_pb::DataTypeProgressMarker marker;
       sync_manager_.directory()->SetDownloadProgress(type, marker);
     }
   }
 
-  InternalComponentsFactory::Switches GetSwitches() const {
-    return switches_;
-  }
+  InternalComponentsFactory::Switches GetSwitches() const { return switches_; }
 
   void ExpectPassphraseAcceptance() {
     EXPECT_CALL(encryption_observer_, OnPassphraseAccepted());
     EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
     EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   }
 
   void SetImplicitPassphraseAndCheck(const std::string& passphrase) {
-    sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(
-        passphrase,
-        false);
+    sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(passphrase,
+                                                                  false);
     EXPECT_EQ(IMPLICIT_PASSPHRASE,
               sync_manager_.GetEncryptionHandler()->GetPassphraseType());
   }
 
   void SetCustomPassphraseAndCheck(const std::string& passphrase) {
     EXPECT_CALL(encryption_observer_,
-        OnPassphraseTypeChanged(CUSTOM_PASSPHRASE, _));
-    sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(
-        passphrase,
-        true);
+                OnPassphraseTypeChanged(CUSTOM_PASSPHRASE, _));
+    sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(passphrase,
+                                                                  true);
     EXPECT_EQ(CUSTOM_PASSPHRASE,
               sync_manager_.GetEncryptionHandler()->GetPassphraseType());
   }
 
   bool HasUnrecoverableError() {
     return mock_unrecoverable_error_handler_.invocation_count() > 0;
   }
 
  private:
   // Needed by |sync_manager_|.
@@ skipping 43 matching lines @@
   sync_manager_.GetEncryptionHandler()->Init();
   PumpLoop();
 
   const ModelTypeSet encrypted_types = GetEncryptedTypes();
   EXPECT_TRUE(encrypted_types.Has(PASSWORDS));
   EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByIdLookup(GetIdForDataType(NIGORI)));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(GetIdForDataType(NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encryption_keybag());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encryption_keybag()));
   }
 }
 
 // Attempt to refresh encryption when nigori not downloaded.
 TEST_F(SyncManagerTest, RefreshEncryptionNotReady) {
@@ skipping 23 matching lines @@
   sync_manager_.GetEncryptionHandler()->Init();
   PumpLoop();
 
   const ModelTypeSet encrypted_types = GetEncryptedTypes();
   EXPECT_TRUE(encrypted_types.Has(PASSWORDS));  // Hardcoded.
   EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
-    EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByIdLookup(GetIdForDataType(NIGORI)));
+    EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(GetIdForDataType(NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encryption_keybag());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encryption_keybag()));
   }
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithNoData) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
-  EXPECT_CALL(encryption_observer_,
-              OnEncryptedTypesChanged(
-                  HasModelTypes(EncryptableUserTypes()), true));
+  EXPECT_CALL(
+      encryption_observer_,
+      OnEncryptedTypesChanged(HasModelTypes(EncryptableUserTypes()), true));
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
   EXPECT_TRUE(IsEncryptEverythingEnabledForTest());
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithData) {
   size_t batch_size = 5;
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
 
   // Create some unencrypted unsynced data.
   int64_t folder = MakeFolderWithParent(sync_manager_.GetUserShare(), BOOKMARKS,
                                         GetIdForDataType(BOOKMARKS), NULL);
   // First batch_size nodes are children of folder.
   size_t i;
   for (i = 0; i < batch_size; ++i) {
     MakeBookmarkWithParent(sync_manager_.GetUserShare(), folder, NULL);
   }
   // Next batch_size nodes are a different type and on their own.
-  for (; i < 2*batch_size; ++i) {
+  for (; i < 2 * batch_size; ++i) {
     MakeNodeWithRoot(sync_manager_.GetUserShare(), SESSIONS,
                      base::StringPrintf("%" PRIuS "", i));
   }
   // Last batch_size nodes are a third type that will not need encryption.
-  for (; i < 3*batch_size; ++i) {
+  for (; i < 3 * batch_size; ++i) {
     MakeNodeWithRoot(sync_manager_.GetUserShare(), THEMES,
                      base::StringPrintf("%" PRIuS "", i));
   }
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_EQ(SyncEncryptionHandler::SensitiveTypes(),
               GetEncryptedTypesWithTrans(&trans));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        BOOKMARKS,
-        false /* not encrypted */));
+        trans.GetWrappedTrans(), BOOKMARKS, false /* not encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        SESSIONS,
-        false /* not encrypted */));
+        trans.GetWrappedTrans(), SESSIONS, false /* not encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        THEMES,
-        false /* not encrypted */));
+        trans.GetWrappedTrans(), THEMES, false /* not encrypted */));
   }
 
-  EXPECT_CALL(encryption_observer_,
-              OnEncryptedTypesChanged(
-                  HasModelTypes(EncryptableUserTypes()), true));
+  EXPECT_CALL(
+      encryption_observer_,
+      OnEncryptedTypesChanged(HasModelTypes(EncryptableUserTypes()), true));
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
   EXPECT_TRUE(IsEncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_EQ(EncryptableUserTypes(), GetEncryptedTypesWithTrans(&trans));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        BOOKMARKS,
-        true /* is encrypted */));
+        trans.GetWrappedTrans(), BOOKMARKS, true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        SESSIONS,
-        true /* is encrypted */));
+        trans.GetWrappedTrans(), SESSIONS, true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        THEMES,
-        true /* is encrypted */));
+        trans.GetWrappedTrans(), THEMES, true /* is encrypted */));
   }
 
   // Trigger's a ReEncryptEverything with new passphrase.
   testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
   EXPECT_CALL(encryption_observer_,
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   ExpectPassphraseAcceptance();
   SetCustomPassphraseAndCheck("new_passphrase");
   EXPECT_TRUE(IsEncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_EQ(EncryptableUserTypes(), GetEncryptedTypesWithTrans(&trans));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        BOOKMARKS,
-        true /* is encrypted */));
+        trans.GetWrappedTrans(), BOOKMARKS, true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        SESSIONS,
-        true /* is encrypted */));
+        trans.GetWrappedTrans(), SESSIONS, true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        THEMES,
-        true /* is encrypted */));
+        trans.GetWrappedTrans(), THEMES, true /* is encrypted */));
   }
   // Calling EncryptDataTypes with an empty encrypted types should not trigger
   // a reencryption and should just notify immediately.
   testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
   EXPECT_CALL(encryption_observer_,
-              OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN)).Times(0);
+              OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN))
+      .Times(0);
   EXPECT_CALL(encryption_observer_, OnPassphraseAccepted()).Times(0);
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete()).Times(0);
   sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
 }
 
 // Test that when there are no pending keys and the cryptographer is not
 // initialized, we add a key based on the current GAIA password.
 // (case 1 in SyncManager::SyncInternal::SetEncryptionPassphrase)
 TEST_F(SyncManagerTest, SetInitialGaiaPass) {
   EXPECT_FALSE(SetUpEncryption(DONT_WRITE_NIGORI, UNINITIALIZED));
@@ skipping 54 matching lines @@
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     verifier.Bootstrap(bootstrap_token);
 
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
     WriteNode::InitUniqueByCreationResult result =
-        password_node.InitUniqueByCreation(PASSWORDS,
-                                           root_node, "foo");
+        password_node.InitUniqueByCreation(PASSWORDS, root_node, "foo");
     EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     password_node.SetPasswordSpecifics(data);
   }
-    EXPECT_CALL(encryption_observer_,
+  EXPECT_CALL(encryption_observer_,
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   ExpectPassphraseAcceptance();
   SetCustomPassphraseAndCheck("new_passphrase");
   EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     // Verify the default key has changed.
     sync_pb::EncryptedData encrypted;
     cryptographer->GetKeys(&encrypted);
     EXPECT_FALSE(verifier.CanDecrypt(encrypted));
 
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              password_node.InitByClientTagLookup(PASSWORDS,
-                                                  "foo"));
+              password_node.InitByClientTagLookup(PASSWORDS, "foo"));
     const sync_pb::PasswordSpecificsData& data =
         password_node.GetPasswordSpecifics();
     EXPECT_EQ("secret", data.password_value());
   }
 }
 
 // Manually set the pending keys in the cryptographer/nigori to reflect the data
 // being encrypted with a new (unprovided) GAIA password, then supply the
 // password.
 // (case 7 in SyncManager::SyncInternal::SetDecryptionPassphrase)
@@ skipping 214 matching lines @@
   }
   EXPECT_CALL(encryption_observer_,
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   ExpectPassphraseAcceptance();
   SetCustomPassphraseAndCheck("new_passphrase");
   EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
-              password_node.InitByClientTagLookup(PASSWORDS,
-                                                  tag));
+              password_node.InitByClientTagLookup(PASSWORDS, tag));
   }
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
               password_node.InitByIdLookup(node_id));
   }
 }
 
 // Friended by WriteNode, so can't be in an anonymouse namespace.
@@ skipping 52 matching lines @@
     // We should de-canonicalize the title in GetTitle(), but the title in the
     // specifics should be stored in the server legal form.
     EXPECT_EQ(raw_title2, node2.GetTitle());
     EXPECT_EQ(title2, node2.GetBookmarkSpecifics().title());
     EXPECT_EQ(url2, node2.GetBookmarkSpecifics().url());
   }
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        BOOKMARKS,
-        false /* not encrypted */));
+        trans.GetWrappedTrans(), BOOKMARKS, false /* not encrypted */));
   }
 
-  EXPECT_CALL(encryption_observer_,
-              OnEncryptedTypesChanged(
-                  HasModelTypes(EncryptableUserTypes()), true));
+  EXPECT_CALL(
+      encryption_observer_,
+      OnEncryptedTypesChanged(HasModelTypes(EncryptableUserTypes()), true));
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
   EXPECT_TRUE(IsEncryptEverythingEnabledForTest());
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_EQ(EncryptableUserTypes(), GetEncryptedTypesWithTrans(&trans));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
-        trans.GetWrappedTrans(),
-        BOOKMARKS,
-        true /* is encrypted */));
+        trans.GetWrappedTrans(), BOOKMARKS, true /* is encrypted */));
 
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
     EXPECT_EQ(BOOKMARKS, node.GetModelType());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(title, node.GetBookmarkSpecifics().title());
     EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
 
     ReadNode node2(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, node2.InitByIdLookup(node_id2));
@@ skipping 40 matching lines @@
 }
 
 // Verifies WriteNode::UpdateEntryWithEncryption does not make unnecessary
 // changes.
 TEST_F(SyncManagerTest, UpdateEntryWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("url");
   entity_specifics.mutable_bookmark()->set_title("title");
   MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
-                 syncable::GenerateSyncableHash(BOOKMARKS,
-                                                client_tag),
+                 syncable::GenerateSyncableHash(BOOKMARKS, client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
   // Manually change to the same data. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
   }
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
-  EXPECT_CALL(encryption_observer_,
-              OnEncryptedTypesChanged(
-                  HasModelTypes(EncryptableUserTypes()), true));
+  EXPECT_CALL(
+      encryption_observer_,
+      OnEncryptedTypesChanged(HasModelTypes(EncryptableUserTypes()), true));
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
 
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
   sync_manager_.GetEncryptionHandler()->Init();
   PumpLoop();
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
-    EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
-        specifics.encrypted()));
+    EXPECT_TRUE(
+        cryptographer->CanDecryptUsingDefaultKey(specifics.encrypted()));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Set a new passphrase. Should set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
   EXPECT_CALL(encryption_observer_,
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   ExpectPassphraseAcceptance();
   SetCustomPassphraseAndCheck("new_passphrase");
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
-    EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
-        specifics.encrypted()));
+    EXPECT_TRUE(
+        cryptographer->CanDecryptUsingDefaultKey(specifics.encrypted()));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
 
   sync_manager_.GetEncryptionHandler()->Init();
   PumpLoop();
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
     Cryptographer* cryptographer = trans.GetCryptographer();
-    EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
-        specifics.encrypted()));
+    EXPECT_TRUE(
+        cryptographer->CanDecryptUsingDefaultKey(specifics.encrypted()));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to the same data. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_FALSE(node_entry->GetIsUnsynced());
     EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
     Cryptographer* cryptographer = trans.GetCryptographer();
-    EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
-        specifics.encrypted()));
+    EXPECT_TRUE(
+        cryptographer->CanDecryptUsingDefaultKey(specifics.encrypted()));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to different data. Should set is_unsynced.
   {
     entity_specifics.mutable_bookmark()->set_url("url2");
     entity_specifics.mutable_bookmark()->set_title("title2");
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_TRUE(node_entry->GetIsUnsynced());
     EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
     Cryptographer* cryptographer = trans.GetCryptographer();
-    EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
-                    specifics.encrypted()));
+    EXPECT_TRUE(
+        cryptographer->CanDecryptUsingDefaultKey(specifics.encrypted()));
   }
 }
 
 // Passwords have their own handling for encryption. Verify it does not result
 // in unnecessary writes via SetEntitySpecifics.
 TEST_F(SyncManagerTest, UpdatePasswordSetEntitySpecificsNoChange) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
-        data,
-        entity_specifics.mutable_password()->
-            mutable_encrypted());
+        data, entity_specifics.mutable_password()->mutable_encrypted());
   }
   MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
-                 syncable::GenerateSyncableHash(PASSWORDS,
-                                                client_tag),
+                 syncable::GenerateSyncableHash(PASSWORDS, client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Manually change to the same data via SetEntitySpecifics. Should not set
   // is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PASSWORDS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
   }
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 }
 
 // Passwords have their own handling for encryption. Verify it does not result
 // in unnecessary writes via SetPasswordSpecifics.
 TEST_F(SyncManagerTest, UpdatePasswordSetPasswordSpecifics) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
-        data,
-        entity_specifics.mutable_password()->
-            mutable_encrypted());
+        data, entity_specifics.mutable_password()->mutable_encrypted());
   }
   MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
-                 syncable::GenerateSyncableHash(PASSWORDS,
-                                                client_tag),
+                 syncable::GenerateSyncableHash(PASSWORDS, client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Manually change to the same data via SetPasswordSpecifics. Should not set
   // is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PASSWORDS, client_tag));
     node.SetPasswordSpecifics(node.GetPasswordSpecifics());
   }
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Manually change to different data. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PASSWORDS, client_tag));
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret2");
     cryptographer->Encrypt(
-        data,
-        entity_specifics.mutable_password()->mutable_encrypted());
+        data, entity_specifics.mutable_password()->mutable_encrypted());
     node.SetPasswordSpecifics(data);
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_TRUE(node_entry->GetIsUnsynced());
   }
 }
 
 // Passwords have their own handling for encryption. Verify setting a new
 // passphrase updates the data.
 TEST_F(SyncManagerTest, UpdatePasswordNewPassphrase) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
-        data,
-        entity_specifics.mutable_password()->mutable_encrypted());
+        data, entity_specifics.mutable_password()->mutable_encrypted());
   }
   MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
-                 syncable::GenerateSyncableHash(PASSWORDS,
-                                                client_tag),
+                 syncable::GenerateSyncableHash(PASSWORDS, client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Set a new passphrase. Should set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
   EXPECT_CALL(encryption_observer_,
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   ExpectPassphraseAcceptance();
   SetCustomPassphraseAndCheck("new_passphrase");
   EXPECT_TRUE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 }
 
 // Passwords have their own handling for encryption. Verify it does not result
 // in unnecessary writes via ReencryptEverything.
 TEST_F(SyncManagerTest, UpdatePasswordReencryptEverything) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
-        data,
-        entity_specifics.mutable_password()->mutable_encrypted());
+        data, entity_specifics.mutable_password()->mutable_encrypted());
   }
   MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
-                 syncable::GenerateSyncableHash(PASSWORDS,
-                                                client_tag),
+                 syncable::GenerateSyncableHash(PASSWORDS, client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
   sync_manager_.GetEncryptionHandler()->Init();
@@ skipping 11 matching lines @@
   {
     // Create a synced bookmark with undecryptable data.
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
 
     Cryptographer other_cryptographer(&encryptor_);
     KeyParams fake_params = {"localhost", "dummy", "fake_key"};
     other_cryptographer.AddKey(fake_params);
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     other_cryptographer.Encrypt(
-        data,
-        entity_specifics.mutable_password()->mutable_encrypted());
+        data, entity_specifics.mutable_password()->mutable_encrypted());
 
     // Set up the real cryptographer with a different key.
     KeyParams real_params = {"localhost", "username", "real_key"};
     trans.GetCryptographer()->AddKey(real_params);
   }
   MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, kClientTag,
-                 syncable::GenerateSyncableHash(PASSWORDS,
-                                                kClientTag),
+                 syncable::GenerateSyncableHash(PASSWORDS, kClientTag),
                  entity_specifics);
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, kClientTag));
 
   // Force a re-encrypt everything. Should trigger an unrecoverable error due
   // to being unable to decrypt the data that was previously applied.
   testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
   EXPECT_FALSE(HasUnrecoverableError());
   sync_manager_.GetEncryptionHandler()->Init();
   PumpLoop();
   EXPECT_TRUE(HasUnrecoverableError());
 }
 
 // Test that attempting to start up with corrupted bookmark data triggers
 // an unrecoverable error (rather than crashing).
 TEST_F(SyncManagerTest, ReencryptEverythingWithUnrecoverableErrorBookmarks) {
   const char kClientTag[] = "client_tag";
-  EXPECT_CALL(encryption_observer_,
-              OnEncryptedTypesChanged(
-                  HasModelTypes(EncryptableUserTypes()), true));
+  EXPECT_CALL(
+      encryption_observer_,
+      OnEncryptedTypesChanged(HasModelTypes(EncryptableUserTypes()), true));
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     // Create a synced bookmark with undecryptable data.
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
 
     Cryptographer other_cryptographer(&encryptor_);
     KeyParams fake_params = {"localhost", "dummy", "fake_key"};
     other_cryptographer.AddKey(fake_params);
     sync_pb::EntitySpecifics bm_specifics;
     bm_specifics.mutable_bookmark()->set_title("title");
     bm_specifics.mutable_bookmark()->set_url("url");
     sync_pb::EncryptedData encrypted;
     other_cryptographer.Encrypt(bm_specifics, &encrypted);
     entity_specifics.mutable_encrypted()->CopyFrom(encrypted);
 
     // Set up the real cryptographer with a different key.
     KeyParams real_params = {"localhost", "username", "real_key"};
     trans.GetCryptographer()->AddKey(real_params);
   }
   MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, kClientTag,
-                 syncable::GenerateSyncableHash(BOOKMARKS,
-                                                kClientTag),
+                 syncable::GenerateSyncableHash(BOOKMARKS, kClientTag),
                  entity_specifics);
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, kClientTag));
 
   // Force a re-encrypt everything. Should trigger an unrecoverable error due
   // to being unable to decrypt the data that was previously applied.
   testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
   EXPECT_FALSE(HasUnrecoverableError());
   sync_manager_.GetEncryptionHandler()->Init();
   PumpLoop();
   EXPECT_TRUE(HasUnrecoverableError());
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for bookmarks
 // when we write the same data, but does set it when we write new data.
 TEST_F(SyncManagerTest, SetBookmarkTitle) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("url");
   entity_specifics.mutable_bookmark()->set_title("title");
   MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
-                 syncable::GenerateSyncableHash(BOOKMARKS,
-                                                client_tag),
+                 syncable::GenerateSyncableHash(BOOKMARKS, client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
@@ skipping 14 matching lines @@
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // bookmarks when we write the same data, but does set it when we write new
 // data.
 TEST_F(SyncManagerTest, SetBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("url");
   entity_specifics.mutable_bookmark()->set_title("title");
   MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
-                 syncable::GenerateSyncableHash(BOOKMARKS,
-                                                client_tag),
+                 syncable::GenerateSyncableHash(BOOKMARKS, client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
-  EXPECT_CALL(encryption_observer_,
-              OnEncryptedTypesChanged(
-                  HasModelTypes(EncryptableUserTypes()), true));
+  EXPECT_CALL(
+      encryption_observer_,
+      OnEncryptedTypesChanged(HasModelTypes(EncryptableUserTypes()), true));
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
   sync_manager_.GetEncryptionHandler()->Init();
   PumpLoop();
   EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
@@ skipping 26 matching lines @@
   EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for non-bookmarks
 // when we write the same data, but does set it when we write new data.
 TEST_F(SyncManagerTest, SetNonBookmarkTitle) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_preference()->set_name("name");
   entity_specifics.mutable_preference()->set_value("value");
-  MakeServerNode(sync_manager_.GetUserShare(),
-                 PREFERENCES,
-                 client_tag,
-                 syncable::GenerateSyncableHash(PREFERENCES,
-                                                client_tag),
+  MakeServerNode(sync_manager_.GetUserShare(), PREFERENCES, client_tag,
+                 syncable::GenerateSyncableHash(PREFERENCES, client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, client_tag));
@@ skipping 13 matching lines @@
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // non-bookmarks when we write the same data or when we write new data
 // data (should remained kEncryptedString).
 TEST_F(SyncManagerTest, SetNonBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_preference()->set_name("name");
   entity_specifics.mutable_preference()->set_value("value");
-  MakeServerNode(sync_manager_.GetUserShare(),
-                 PREFERENCES,
-                 client_tag,
-                 syncable::GenerateSyncableHash(PREFERENCES,
-                                                client_tag),
+  MakeServerNode(sync_manager_.GetUserShare(), PREFERENCES, client_tag,
+                 syncable::GenerateSyncableHash(PREFERENCES, client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
-  EXPECT_CALL(encryption_observer_,
-              OnEncryptedTypesChanged(
-                  HasModelTypes(EncryptableUserTypes()), true));
+  EXPECT_CALL(
+      encryption_observer_,
+      OnEncryptedTypesChanged(HasModelTypes(EncryptableUserTypes()), true));
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
   sync_manager_.GetEncryptionHandler()->Init();
   PumpLoop();
   EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
@@ skipping 28 matching lines @@
 
 // Ensure that titles are truncated to 255 bytes, and attempting to reset
 // them to their longer version does not set IS_UNSYNCED.
 TEST_F(SyncManagerTest, SetLongTitle) {
   const int kNumChars = 512;
   const std::string kClientTag = "tag";
   std::string title(kNumChars, '0');
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_preference()->set_name("name");
   entity_specifics.mutable_preference()->set_value("value");
-  MakeServerNode(sync_manager_.GetUserShare(),
-                 PREFERENCES,
-                 "short_title",
-                 syncable::GenerateSyncableHash(PREFERENCES,
-                                                kClientTag),
+  MakeServerNode(sync_manager_.GetUserShare(), PREFERENCES, "short_title",
+                 syncable::GenerateSyncableHash(PREFERENCES, kClientTag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, kClientTag));
 
   // Manually change to the long title. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, kClientTag));
@@ skipping 39 matching lines @@
     Cryptographer* crypto = trans.GetCryptographer();
     sync_pb::EntitySpecifics bm_specifics;
     bm_specifics.mutable_bookmark()->set_title("title");
     bm_specifics.mutable_bookmark()->set_url("url");
     sync_pb::EncryptedData encrypted;
     crypto->Encrypt(bm_specifics, &encrypted);
     entity_specifics.mutable_encrypted()->CopyFrom(encrypted);
     AddDefaultFieldValue(BOOKMARKS, &entity_specifics);
   }
   MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
-                 syncable::GenerateSyncableHash(BOOKMARKS,
-                                                client_tag),
+                 syncable::GenerateSyncableHash(BOOKMARKS, client_tag),
                  entity_specifics);
 
   {
     // Verify the data.
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
@@ skipping 32 matching lines @@
   ModelSafeRoutingInfo routing_info;
   GetModelSafeRoutingInfo(&routing_info);
 
   {
     ReadTransaction read_trans(FROM_HERE, sync_manager_.GetUserShare());
     for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
          i != routing_info.end(); ++i) {
       // Transaction version is incremented when SyncManagerTest::SetUp()
       // creates a node of each type.
       EXPECT_EQ(1,
-                sync_manager_.GetUserShare()->directory->
-                    GetTransactionVersion(i->first));
+                sync_manager_.GetUserShare()->directory->GetTransactionVersion(
+                    i->first));
     }
   }
 
   // Create bookmark node to increment transaction version of bookmark model.
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("url");
   entity_specifics.mutable_bookmark()->set_title("title");
   MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
-                 syncable::GenerateSyncableHash(BOOKMARKS,
-                                                client_tag),
+                 syncable::GenerateSyncableHash(BOOKMARKS, client_tag),
                  entity_specifics);
 
   {
     ReadTransaction read_trans(FROM_HERE, sync_manager_.GetUserShare());
     for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
          i != routing_info.end(); ++i) {
       EXPECT_EQ(i->first == BOOKMARKS ? 2 : 1,
-                sync_manager_.GetUserShare()->directory->
-                    GetTransactionVersion(i->first));
+                sync_manager_.GetUserShare()->directory->GetTransactionVersion(
+                    i->first));
     }
   }
 }
 
 class MockSyncScheduler : public FakeSyncScheduler {
  public:
   MockSyncScheduler() : FakeSyncScheduler() {}
   virtual ~MockSyncScheduler() {}
 
   MOCK_METHOD2(Start, void(SyncScheduler::Mode, base::Time));
   MOCK_METHOD1(ScheduleConfiguration, void(const ConfigurationParams&));
 };
 
 class ComponentsFactory : public TestInternalComponentsFactory {
  public:
   ComponentsFactory(const Switches& switches,
                     SyncScheduler* scheduler_to_use,
                     sessions::SyncSessionContext** session_context,
                     InternalComponentsFactory::StorageOption* storage_used)
       : TestInternalComponentsFactory(
-          switches, InternalComponentsFactory::STORAGE_IN_MEMORY, storage_used),
+            switches,
+            InternalComponentsFactory::STORAGE_IN_MEMORY,
+            storage_used),
         scheduler_to_use_(scheduler_to_use),
         session_context_(session_context) {}
   ~ComponentsFactory() override {}
 
   std::unique_ptr<SyncScheduler> BuildScheduler(
       const std::string& name,
       sessions::SyncSessionContext* context,
       CancelationSignal* stop_handle) override {
     *session_context_ = context;
     return std::move(scheduler_to_use_);
   }
 
  private:
   std::unique_ptr<SyncScheduler> scheduler_to_use_;
   sessions::SyncSessionContext** session_context_;
 };
 
 class SyncManagerTestWithMockScheduler : public SyncManagerTest {
  public:
   SyncManagerTestWithMockScheduler() : scheduler_(NULL) {}
   InternalComponentsFactory* GetFactory() override {
     scheduler_ = new MockSyncScheduler();
     return new ComponentsFactory(GetSwitches(), scheduler_, &session_context_,
                                  &storage_used_);
   }
 
   MockSyncScheduler* scheduler() { return scheduler_; }
-  sessions::SyncSessionContext* session_context() {
-      return session_context_;
-  }
+  sessions::SyncSessionContext* session_context() { return session_context_; }
 
  private:
   MockSyncScheduler* scheduler_;
   sessions::SyncSessionContext* session_context_;
 };
 
 // Test that the configuration params are properly created and sent to
 // ScheduleConfigure. No callback should be invoked. Any disabled datatypes
 // should be purged.
 TEST_F(SyncManagerTestWithMockScheduler, BasicConfiguration) {
   ConfigureReason reason = CONFIGURE_REASON_RECONFIGURATION;
   ModelTypeSet types_to_download(BOOKMARKS, PREFERENCES);
   ModelSafeRoutingInfo new_routing_info;
   GetModelSafeRoutingInfo(&new_routing_info);
   ModelTypeSet enabled_types = GetRoutingInfoTypes(new_routing_info);
   ModelTypeSet disabled_types = Difference(ModelTypeSet::All(), enabled_types);
 
   ConfigurationParams params;
   EXPECT_CALL(*scheduler(), Start(SyncScheduler::CONFIGURATION_MODE, _));
-  EXPECT_CALL(*scheduler(), ScheduleConfiguration(_)).
-      WillOnce(SaveArg<0>(&params));
+  EXPECT_CALL(*scheduler(), ScheduleConfiguration(_))
+      .WillOnce(SaveArg<0>(&params));
 
   // Set data for all types.
   ModelTypeSet protocol_types = ProtocolTypes();
   for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
        iter.Inc()) {
     SetProgressMarkerForType(iter.Get(), true);
   }
 
   CallbackCounter ready_task_counter, retry_task_counter;
   sync_manager_.ConfigureSyncer(
-      reason,
-      types_to_download,
-      disabled_types,
-      ModelTypeSet(),
-      ModelTypeSet(),
-      new_routing_info,
-      base::Bind(&CallbackCounter::Callback,
-                 base::Unretained(&ready_task_counter)),
+      reason, types_to_download, disabled_types, ModelTypeSet(), ModelTypeSet(),
+      new_routing_info, base::Bind(&CallbackCounter::Callback,
+                                   base::Unretained(&ready_task_counter)),
       base::Bind(&CallbackCounter::Callback,
                  base::Unretained(&retry_task_counter)));
   EXPECT_EQ(0, ready_task_counter.times_called());
   EXPECT_EQ(0, retry_task_counter.times_called());
-  EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
-            params.source);
+  EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::RECONFIGURATION, params.source);
   EXPECT_EQ(types_to_download, params.types_to_download);
   EXPECT_EQ(new_routing_info, params.routing_info);
 
   // Verify all the disabled types were purged.
   EXPECT_EQ(enabled_types,
             sync_manager_.GetUserShare()->directory->InitialSyncEndedTypes());
   EXPECT_EQ(disabled_types, sync_manager_.GetTypesWithEmptyProgressMarkerToken(
                                 ModelTypeSet::All()));
 }
 
 // Test that on a reconfiguration (configuration where the session context
 // already has routing info), only those recently disabled types are purged.
 TEST_F(SyncManagerTestWithMockScheduler, ReConfiguration) {
   ConfigureReason reason = CONFIGURE_REASON_RECONFIGURATION;
   ModelTypeSet types_to_download(BOOKMARKS, PREFERENCES);
   ModelTypeSet disabled_types = ModelTypeSet(THEMES, SESSIONS);
   ModelSafeRoutingInfo old_routing_info;
   ModelSafeRoutingInfo new_routing_info;
   GetModelSafeRoutingInfo(&old_routing_info);
   new_routing_info = old_routing_info;
   new_routing_info.erase(THEMES);
   new_routing_info.erase(SESSIONS);
   ModelTypeSet enabled_types = GetRoutingInfoTypes(new_routing_info);
 
   ConfigurationParams params;
   EXPECT_CALL(*scheduler(), Start(SyncScheduler::CONFIGURATION_MODE, _));
-  EXPECT_CALL(*scheduler(), ScheduleConfiguration(_)).
-      WillOnce(SaveArg<0>(&params));
+  EXPECT_CALL(*scheduler(), ScheduleConfiguration(_))
+      .WillOnce(SaveArg<0>(&params));
 
   // Set data for all types except those recently disabled (so we can verify
   // only those recently disabled are purged) .
   ModelTypeSet protocol_types = ProtocolTypes();
   for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
        iter.Inc()) {
     if (!disabled_types.Has(iter.Get())) {
       SetProgressMarkerForType(iter.Get(), true);
     } else {
       SetProgressMarkerForType(iter.Get(), false);
     }
   }
 
   // Set the context to have the old routing info.
   session_context()->SetRoutingInfo(old_routing_info);
 
   CallbackCounter ready_task_counter, retry_task_counter;
   sync_manager_.ConfigureSyncer(
-      reason,
-      types_to_download,
-      ModelTypeSet(),
-      ModelTypeSet(),
-      ModelTypeSet(),
-      new_routing_info,
-      base::Bind(&CallbackCounter::Callback,
-                 base::Unretained(&ready_task_counter)),
+      reason, types_to_download, ModelTypeSet(), ModelTypeSet(), ModelTypeSet(),
+      new_routing_info, base::Bind(&CallbackCounter::Callback,
+                                   base::Unretained(&ready_task_counter)),
       base::Bind(&CallbackCounter::Callback,
                  base::Unretained(&retry_task_counter)));
   EXPECT_EQ(0, ready_task_counter.times_called());
   EXPECT_EQ(0, retry_task_counter.times_called());
-  EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
-            params.source);
+  EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::RECONFIGURATION, params.source);
   EXPECT_EQ(types_to_download, params.types_to_download);
   EXPECT_EQ(new_routing_info, params.routing_info);
 
   // Verify only the recently disabled types were purged.
   EXPECT_EQ(disabled_types, sync_manager_.GetTypesWithEmptyProgressMarkerToken(
                                 ProtocolTypes()));
 }
 
 // Test that SyncManager::ClearServerData invokes the scheduler.
 TEST_F(SyncManagerTestWithMockScheduler, ClearServerData) {
@@ skipping 14 matching lines @@
 
   UserShare* share = sync_manager_.GetUserShare();
 
   // The test harness automatically initializes all types in the routing info.
   // Check that autofill is not among them.
   ASSERT_FALSE(enabled_types.Has(AUTOFILL));
 
   // Further ensure that the test harness did not create its root node.
   {
     syncable::ReadTransaction trans(FROM_HERE, share->directory.get());
-    syncable::Entry autofill_root_node(&trans,
-                                       syncable::GET_TYPE_ROOT,
+    syncable::Entry autofill_root_node(&trans, syncable::GET_TYPE_ROOT,
                                        AUTOFILL);
     ASSERT_FALSE(autofill_root_node.good());
   }
 
   // One more redundant check.
   ASSERT_FALSE(
       sync_manager_.GetUserShare()->directory->InitialSyncEndedTypes().Has(
           AUTOFILL));
 
   // Give autofill a progress marker.
@@ skipping 18 matching lines @@
   prefs_marker.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(PREFERENCES));
   prefs_marker.set_token("token");
   share->directory->SetDownloadProgress(PREFERENCES, prefs_marker);
 
   // Add a fully synced preferences node under the root.
   std::string pref_client_tag = "prefABC";
   std::string pref_hashed_tag = "hashXYZ";
   sync_pb::EntitySpecifics pref_specifics;
   AddDefaultFieldValue(PREFERENCES, &pref_specifics);
-  int pref_meta = MakeServerNode(
-      share, PREFERENCES, pref_client_tag, pref_hashed_tag, pref_specifics);
+  int pref_meta = MakeServerNode(share, PREFERENCES, pref_client_tag,
+                                 pref_hashed_tag, pref_specifics);
 
   // And now, the purge.
   EXPECT_TRUE(sync_manager_.PurgePartiallySyncedTypes());
 
   // Ensure that autofill lost its progress marker, but preferences did not.
   ModelTypeSet empty_tokens =
       sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All());
   EXPECT_TRUE(empty_tokens.Has(AUTOFILL));
   EXPECT_FALSE(empty_tokens.Has(PREFERENCES));
 
@@ skipping 21 matching lines @@
 
   // Set progress markers for all types.
   ModelTypeSet protocol_types = ProtocolTypes();
   for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
        iter.Inc()) {
     SetProgressMarkerForType(iter.Get(), true);
   }
 
   // Verify all the enabled types remain after cleanup, and all the disabled
   // types were purged.
-  sync_manager_.PurgeDisabledTypes(disabled_types,
-                                   ModelTypeSet(),
+  sync_manager_.PurgeDisabledTypes(disabled_types, ModelTypeSet(),
                                    ModelTypeSet());
   EXPECT_EQ(enabled_types,
             sync_manager_.GetUserShare()->directory->InitialSyncEndedTypes());
   EXPECT_EQ(disabled_types, sync_manager_.GetTypesWithEmptyProgressMarkerToken(
                                 ModelTypeSet::All()));
 
   // Disable some more types.
   disabled_types.Put(BOOKMARKS);
   disabled_types.Put(PREFERENCES);
   ModelTypeSet new_enabled_types =
       Difference(ModelTypeSet::All(), disabled_types);
 
   // Verify only the non-disabled types remain after cleanup.
-  sync_manager_.PurgeDisabledTypes(disabled_types,
-                                   ModelTypeSet(),
+  sync_manager_.PurgeDisabledTypes(disabled_types, ModelTypeSet(),
                                    ModelTypeSet());
   EXPECT_EQ(new_enabled_types,
             sync_manager_.GetUserShare()->directory->InitialSyncEndedTypes());
   EXPECT_EQ(disabled_types, sync_manager_.GetTypesWithEmptyProgressMarkerToken(
                                 ModelTypeSet::All()));
 }
 
 // Test PurgeDisabledTypes properly unapplies types by deleting their local data
 // and preserving their server data and progress marker.
 TEST_F(SyncManagerTest, PurgeUnappliedTypes) {
@@ skipping 19 matching lines @@
   // 2. Locally created preference, server unknown, unsynced
   // 3. Locally deleted preference, server known, unsynced
   // 4. Server deleted preference, locally known.
   // 5. Server created preference, locally unknown, unapplied.
   // 6. A fully synced bookmark (no unique_client_tag).
   UserShare* share = sync_manager_.GetUserShare();
   sync_pb::EntitySpecifics pref_specifics;
   AddDefaultFieldValue(PREFERENCES, &pref_specifics);
   sync_pb::EntitySpecifics bm_specifics;
   AddDefaultFieldValue(BOOKMARKS, &bm_specifics);
-  int pref1_meta = MakeServerNode(
-      share, PREFERENCES, "pref1", "hash1", pref_specifics);
+  int pref1_meta =
+      MakeServerNode(share, PREFERENCES, "pref1", "hash1", pref_specifics);
   int64_t pref2_meta = MakeNodeWithRoot(share, PREFERENCES, "pref2");
-  int pref3_meta = MakeServerNode(
-      share, PREFERENCES, "pref3", "hash3", pref_specifics);
-  int pref4_meta = MakeServerNode(
-      share, PREFERENCES, "pref4", "hash4", pref_specifics);
-  int pref5_meta = MakeServerNode(
-      share, PREFERENCES, "pref5", "hash5", pref_specifics);
-  int bookmark_meta = MakeServerNode(
-      share, BOOKMARKS, "bookmark", "", bm_specifics);
+  int pref3_meta =
+      MakeServerNode(share, PREFERENCES, "pref3", "hash3", pref_specifics);
+  int pref4_meta =
+      MakeServerNode(share, PREFERENCES, "pref4", "hash4", pref_specifics);
+  int pref5_meta =
+      MakeServerNode(share, PREFERENCES, "pref5", "hash5", pref_specifics);
+  int bookmark_meta =
+      MakeServerNode(share, BOOKMARKS, "bookmark", "", bm_specifics);
 
   {
-    syncable::WriteTransaction trans(FROM_HERE,
-                                     syncable::SYNCER,
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
                                      share->directory.get());
     // Pref's 1 and 2 are already set up properly.
     // Locally delete pref 3.
     syncable::MutableEntry pref3(&trans, GET_BY_HANDLE, pref3_meta);
     pref3.PutIsDel(true);
     pref3.PutIsUnsynced(true);
     // Delete pref 4 at the server.
     syncable::MutableEntry pref4(&trans, GET_BY_HANDLE, pref4_meta);
     pref4.PutServerIsDel(true);
     pref4.PutIsUnappliedUpdate(true);
     pref4.PutServerVersion(2);
     // Pref 5 is an new unapplied update.
     syncable::MutableEntry pref5(&trans, GET_BY_HANDLE, pref5_meta);
     pref5.PutIsUnappliedUpdate(true);
     pref5.PutIsDel(true);
     pref5.PutBaseVersion(-1);
     // Bookmark is already set up properly
   }
 
   // Take a snapshot to clear all the dirty bits.
   share->directory.get()->SaveChanges();
 
   // Now request a purge for the unapplied types.
   disabled_types.PutAll(unapplied_types);
-  sync_manager_.PurgeDisabledTypes(disabled_types,
-                                   ModelTypeSet(),
+  sync_manager_.PurgeDisabledTypes(disabled_types, ModelTypeSet(),
                                    unapplied_types);
 
   // Verify the unapplied types still have progress markers and initial sync
   // ended after cleanup.
   EXPECT_TRUE(
       sync_manager_.GetUserShare()->directory->InitialSyncEndedTypes().HasAll(
           unapplied_types));
   EXPECT_TRUE(
-      sync_manager_.GetTypesWithEmptyProgressMarkerToken(unapplied_types).
-          Empty());
+      sync_manager_.GetTypesWithEmptyProgressMarkerToken(unapplied_types)
+          .Empty());
 
   // Ensure the items were unapplied as necessary.
   {
     syncable::ReadTransaction trans(FROM_HERE, share->directory.get());
     syncable::Entry pref_node(&trans, GET_BY_HANDLE, pref1_meta);
     ASSERT_TRUE(pref_node.good());
     EXPECT_TRUE(pref_node.GetKernelCopy().is_dirty());
     EXPECT_FALSE(pref_node.GetIsUnsynced());
     EXPECT_TRUE(pref_node.GetIsUnappliedUpdate());
     EXPECT_TRUE(pref_node.GetIsDel());
@@ skipping 61 matching lines @@
                         const ImmutableChangeRecordList& changes) override {
     last_changes_ = changes;
   }
 
   void OnChangesComplete(ModelType model_type) override {}
 
   const ImmutableChangeRecordList& GetRecentChangeList() {
     return last_changes_;
   }
 
-  UserShare* share() {
-    return sync_manager_.GetUserShare();
-  }
+  UserShare* share() { return sync_manager_.GetUserShare(); }
 
   // Set some flags so our nodes reasonably approximate the real world scenario
   // and can get past CheckTreeInvariants.
   //
   // It's never going to be truly accurate, since we're squashing update
   // receipt, processing and application into a single transaction.
-  void SetNodeProperties(syncable::MutableEntry *entry) {
+  void SetNodeProperties(syncable::MutableEntry* entry) {
     entry->PutId(id_factory_.NewServerId());
     entry->PutBaseVersion(10);
     entry->PutServerVersion(10);
   }
 
   // Looks for the given change in the list.  Returns the index at which it was
   // found.  Returns -1 on lookup failure.
   size_t FindChangeInList(int64_t id, ChangeRecord::Action action) {
     SCOPED_TRACE(id);
     for (size_t i = 0; i < last_changes_.Get().size(); ++i) {
-      if (last_changes_.Get()[i].id == id
-          && last_changes_.Get()[i].action == action) {
+      if (last_changes_.Get()[i].id == id &&
+          last_changes_.Get()[i].action == action) {
         return i;
       }
     }
     ADD_FAILURE() << "Failed to find specified change";
     return static_cast<size_t>(-1);
   }
 
   // Returns the current size of the change list.
   //
   // Note that spurious changes do not necessarily indicate a problem.
   // Assertions on change list size can help detect problems, but it may be
   // necessary to reduce their strictness if the implementation changes.
-  size_t GetChangeListSize() {
-    return last_changes_.Get().size();
-  }
+  size_t GetChangeListSize() { return last_changes_.Get().size(); }
 
   void ClearChangeList() { last_changes_ = ImmutableChangeRecordList(); }
 
  protected:
   ImmutableChangeRecordList last_changes_;
   TestIdFactory id_factory_;
 };
 
 // Test creation of a folder and a bookmark.
 TEST_F(SyncManagerChangeProcessingTest, AddBookmarks) {
   int64_t type_root = GetIdForDataType(BOOKMARKS);
   int64_t folder_id = kInvalidId;
   int64_t child_id = kInvalidId;
 
   // Create a folder and a bookmark under it.
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
     syncable::Entry root(&trans, syncable::GET_BY_HANDLE, type_root);
     ASSERT_TRUE(root.good());
 
-    syncable::MutableEntry folder(&trans, syncable::CREATE,
-                                  BOOKMARKS, root.GetId(), "folder");
+    syncable::MutableEntry folder(&trans, syncable::CREATE, BOOKMARKS,
+                                  root.GetId(), "folder");
     ASSERT_TRUE(folder.good());
     SetNodeProperties(&folder);
     folder.PutIsDir(true);
     folder_id = folder.GetMetahandle();
 
-    syncable::MutableEntry child(&trans, syncable::CREATE,
-                                 BOOKMARKS, folder.GetId(), "child");
+    syncable::MutableEntry child(&trans, syncable::CREATE, BOOKMARKS,
+                                 folder.GetId(), "child");
     ASSERT_TRUE(child.good());
     SetNodeProperties(&child);
     child_id = child.GetMetahandle();
   }
 
   // The closing of the above scope will delete the transaction.  Its processed
   // changes should be waiting for us in a member of the test harness.
   EXPECT_EQ(2UL, GetChangeListSize());
 
   // We don't need to check these return values here.  The function will add a
@@ skipping 41 matching lines @@
 }
 
 // Test moving a bookmark into an empty folder.
 TEST_F(SyncManagerChangeProcessingTest, MoveBookmarkIntoEmptyFolder) {
   int64_t type_root = GetIdForDataType(BOOKMARKS);
   int64_t folder_b_id = kInvalidId;
   int64_t child_id = kInvalidId;
 
   // Create two folders.  Place a child under folder A.
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
     syncable::Entry root(&trans, syncable::GET_BY_HANDLE, type_root);
     ASSERT_TRUE(root.good());
 
-    syncable::MutableEntry folder_a(&trans, syncable::CREATE,
-                                    BOOKMARKS, root.GetId(), "folderA");
+    syncable::MutableEntry folder_a(&trans, syncable::CREATE, BOOKMARKS,
+                                    root.GetId(), "folderA");
     ASSERT_TRUE(folder_a.good());
     SetNodeProperties(&folder_a);
     folder_a.PutIsDir(true);
 
-    syncable::MutableEntry folder_b(&trans, syncable::CREATE,
-                                    BOOKMARKS, root.GetId(), "folderB");
+    syncable::MutableEntry folder_b(&trans, syncable::CREATE, BOOKMARKS,
+                                    root.GetId(), "folderB");
     ASSERT_TRUE(folder_b.good());
     SetNodeProperties(&folder_b);
     folder_b.PutIsDir(true);
     folder_b_id = folder_b.GetMetahandle();
 
-    syncable::MutableEntry child(&trans, syncable::CREATE,
-                                 BOOKMARKS, folder_a.GetId(),
-                                 "child");
+    syncable::MutableEntry child(&trans, syncable::CREATE, BOOKMARKS,
+                                 folder_a.GetId(), "child");
     ASSERT_TRUE(child.good());
     SetNodeProperties(&child);
     child_id = child.GetMetahandle();
   }
 
   // Close that transaction.  The above was to setup the initial scenario.  The
   // real test starts now.
 
   // Move the child from folder A to folder B.
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
 
     syncable::Entry folder_b(&trans, syncable::GET_BY_HANDLE, folder_b_id);
     syncable::MutableEntry child(&trans, syncable::GET_BY_HANDLE, child_id);
 
     child.PutParentId(folder_b.GetId());
   }
 
   EXPECT_EQ(1UL, GetChangeListSize());
 
   // Verify that this was detected as a real change.  An early version of the
   // UniquePosition code had a bug where moves from one folder to another were
   // ignored unless the moved node's UniquePosition value was also changed in
   // some way.
   FindChangeInList(child_id, ChangeRecord::ACTION_UPDATE);
 }
 
 // Test moving a bookmark into a non-empty folder.
 TEST_F(SyncManagerChangeProcessingTest, MoveIntoPopulatedFolder) {
   int64_t type_root = GetIdForDataType(BOOKMARKS);
   int64_t child_a_id = kInvalidId;
   int64_t child_b_id = kInvalidId;
 
   // Create two folders.  Place one child each under folder A and folder B.
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
     syncable::Entry root(&trans, syncable::GET_BY_HANDLE, type_root);
     ASSERT_TRUE(root.good());
 
-    syncable::MutableEntry folder_a(&trans, syncable::CREATE,
-                                    BOOKMARKS, root.GetId(), "folderA");
+    syncable::MutableEntry folder_a(&trans, syncable::CREATE, BOOKMARKS,
+                                    root.GetId(), "folderA");
     ASSERT_TRUE(folder_a.good());
     SetNodeProperties(&folder_a);
     folder_a.PutIsDir(true);
 
-    syncable::MutableEntry folder_b(&trans, syncable::CREATE,
-                                    BOOKMARKS, root.GetId(), "folderB");
+    syncable::MutableEntry folder_b(&trans, syncable::CREATE, BOOKMARKS,
+                                    root.GetId(), "folderB");
     ASSERT_TRUE(folder_b.good());
     SetNodeProperties(&folder_b);
     folder_b.PutIsDir(true);
 
-    syncable::MutableEntry child_a(&trans, syncable::CREATE,
-                                   BOOKMARKS, folder_a.GetId(),
-                                   "childA");
+    syncable::MutableEntry child_a(&trans, syncable::CREATE, BOOKMARKS,
+                                   folder_a.GetId(), "childA");
     ASSERT_TRUE(child_a.good());
     SetNodeProperties(&child_a);
     child_a_id = child_a.GetMetahandle();
 
-    syncable::MutableEntry child_b(&trans, syncable::CREATE,
-                                   BOOKMARKS, folder_b.GetId(),
-                                   "childB");
+    syncable::MutableEntry child_b(&trans, syncable::CREATE, BOOKMARKS,
+                                   folder_b.GetId(), "childB");
     SetNodeProperties(&child_b);
     child_b_id = child_b.GetMetahandle();
   }
 
   // Close that transaction.  The above was to setup the initial scenario.  The
   // real test starts now.
 
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
 
     syncable::MutableEntry child_a(&trans, syncable::GET_BY_HANDLE, child_a_id);
     syncable::MutableEntry child_b(&trans, syncable::GET_BY_HANDLE, child_b_id);
 
     // Move child A from folder A to folder B and update its position.
     child_a.PutParentId(child_b.GetParentId());
     child_a.PutPredecessor(child_b.GetId());
   }
 
   EXPECT_EQ(1UL, GetChangeListSize());
 
   // Verify that only child a is in the change list.
   // (This function will add a failure if the lookup fails.)
   FindChangeInList(child_a_id, ChangeRecord::ACTION_UPDATE);
 }
 
 // Tests the ordering of deletion changes.
 TEST_F(SyncManagerChangeProcessingTest, DeletionsAndChanges) {
   int64_t type_root = GetIdForDataType(BOOKMARKS);
   int64_t folder_a_id = kInvalidId;
   int64_t folder_b_id = kInvalidId;
   int64_t child_id = kInvalidId;
 
   // Create two folders.  Place a child under folder A.
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
     syncable::Entry root(&trans, syncable::GET_BY_HANDLE, type_root);
     ASSERT_TRUE(root.good());
 
-    syncable::MutableEntry folder_a(&trans, syncable::CREATE,
-                                    BOOKMARKS, root.GetId(), "folderA");
+    syncable::MutableEntry folder_a(&trans, syncable::CREATE, BOOKMARKS,
+                                    root.GetId(), "folderA");
     ASSERT_TRUE(folder_a.good());
     SetNodeProperties(&folder_a);
     folder_a.PutIsDir(true);
     folder_a_id = folder_a.GetMetahandle();
 
-    syncable::MutableEntry folder_b(&trans, syncable::CREATE,
-                                    BOOKMARKS, root.GetId(), "folderB");
+    syncable::MutableEntry folder_b(&trans, syncable::CREATE, BOOKMARKS,
+                                    root.GetId(), "folderB");
     ASSERT_TRUE(folder_b.good());
     SetNodeProperties(&folder_b);
     folder_b.PutIsDir(true);
     folder_b_id = folder_b.GetMetahandle();
 
-    syncable::MutableEntry child(&trans, syncable::CREATE,
-                                 BOOKMARKS, folder_a.GetId(),
-                                 "child");
+    syncable::MutableEntry child(&trans, syncable::CREATE, BOOKMARKS,
+                                 folder_a.GetId(), "child");
     ASSERT_TRUE(child.good());
     SetNodeProperties(&child);
     child_id = child.GetMetahandle();
   }
 
   // Close that transaction.  The above was to setup the initial scenario.  The
   // real test starts now.
 
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
 
-    syncable::MutableEntry folder_a(
-        &trans, syncable::GET_BY_HANDLE, folder_a_id);
-    syncable::MutableEntry folder_b(
-        &trans, syncable::GET_BY_HANDLE, folder_b_id);
+    syncable::MutableEntry folder_a(&trans, syncable::GET_BY_HANDLE,
+                                    folder_a_id);
+    syncable::MutableEntry folder_b(&trans, syncable::GET_BY_HANDLE,
+                                    folder_b_id);
     syncable::MutableEntry child(&trans, syncable::GET_BY_HANDLE, child_id);
 
     // Delete folder B and its child.
     child.PutIsDel(true);
     folder_b.PutIsDel(true);
 
     // Make an unrelated change to folder A.
     folder_a.PutNonUniqueName("NewNameA");
   }
 
   EXPECT_EQ(3UL, GetChangeListSize());
 
   size_t folder_a_pos =
       FindChangeInList(folder_a_id, ChangeRecord::ACTION_UPDATE);
   size_t folder_b_pos =
       FindChangeInList(folder_b_id, ChangeRecord::ACTION_DELETE);
   size_t child_pos = FindChangeInList(child_id, ChangeRecord::ACTION_DELETE);
 
   // Deletes should appear before updates.
   EXPECT_LT(child_pos, folder_a_pos);
   EXPECT_LT(folder_b_pos, folder_a_pos);
 }
 
 // See that attachment metadata changes are not filtered out by
 // SyncManagerImpl::VisiblePropertiesDiffer.
 TEST_F(SyncManagerChangeProcessingTest, AttachmentMetadataOnlyChanges) {
   // Create an article with no attachments.  See that a change is generated.
   int64_t article_id = kInvalidId;
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
     int64_t type_root = GetIdForDataType(ARTICLES);
     syncable::Entry root(&trans, syncable::GET_BY_HANDLE, type_root);
     ASSERT_TRUE(root.good());
-    syncable::MutableEntry article(
-        &trans, syncable::CREATE, ARTICLES, root.GetId(), "article");
+    syncable::MutableEntry article(&trans, syncable::CREATE, ARTICLES,
+                                   root.GetId(), "article");
     ASSERT_TRUE(article.good());
     SetNodeProperties(&article);
     article_id = article.GetMetahandle();
   }
   ASSERT_EQ(1UL, GetChangeListSize());
   FindChangeInList(article_id, ChangeRecord::ACTION_ADD);
   ClearChangeList();
 
   // Modify the article by adding one attachment.  Don't touch anything else.
   // See that a change is generated.
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
     syncable::MutableEntry article(&trans, syncable::GET_BY_HANDLE, article_id);
     sync_pb::AttachmentMetadata metadata;
     *metadata.add_record()->mutable_id() = CreateAttachmentIdProto(0, 0);
     article.PutAttachmentMetadata(metadata);
   }
   ASSERT_EQ(1UL, GetChangeListSize());
   FindChangeInList(article_id, ChangeRecord::ACTION_UPDATE);
   ClearChangeList();
 
   // Modify the article by replacing its attachment with a different one.  See
   // that a change is generated.
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
     syncable::MutableEntry article(&trans, syncable::GET_BY_HANDLE, article_id);
     sync_pb::AttachmentMetadata metadata = article.GetAttachmentMetadata();
     *metadata.add_record()->mutable_id() = CreateAttachmentIdProto(0, 0);
     article.PutAttachmentMetadata(metadata);
   }
   ASSERT_EQ(1UL, GetChangeListSize());
   FindChangeInList(article_id, ChangeRecord::ACTION_UPDATE);
   ClearChangeList();
 
   // Modify the article by replacing its attachment metadata with the same
   // attachment metadata.  No change should be generated.
   {
-    syncable::WriteTransaction trans(
-        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER,
+                                     share()->directory.get());
     syncable::MutableEntry article(&trans, syncable::GET_BY_HANDLE, article_id);
     article.PutAttachmentMetadata(article.GetAttachmentMetadata());
   }
   ASSERT_EQ(0UL, GetChangeListSize());
 }
 
 // During initialization SyncManagerImpl loads sqlite database. If it fails to
 // do so it should fail initialization. This test verifies this behavior.
 // Test reuses SyncManagerImpl initialization from SyncManagerTest but overrides
 // InternalComponentsFactory to return DirectoryBackingStore that always fails
 // to load.
 class SyncManagerInitInvalidStorageTest : public SyncManagerTest {
  public:
-  SyncManagerInitInvalidStorageTest() {
-  }
+  SyncManagerInitInvalidStorageTest() {}
 
   InternalComponentsFactory* GetFactory() override {
     return new TestInternalComponentsFactory(
         GetSwitches(), InternalComponentsFactory::STORAGE_INVALID,
         &storage_used_);
   }
 };
 
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer