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

components/sync/engine_impl/syncer_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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
-#include "sync/engine/syncer.h"
+#include "components/sync/engine_impl/syncer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
-#include "sync/engine/backoff_delay_provider.h"
-#include "sync/engine/get_commit_ids.h"
-#include "sync/engine/net/server_connection_manager.h"
-#include "sync/engine/sync_scheduler_impl.h"
-#include "sync/engine/syncer_proto_util.h"
-#include "sync/internal_api/public/base/cancelation_signal.h"
-#include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/engine/model_safe_worker.h"
-#include "sync/internal_api/public/sessions/commit_counters.h"
-#include "sync/internal_api/public/sessions/status_counters.h"
-#include "sync/internal_api/public/sessions/update_counters.h"
-#include "sync/protocol/bookmark_specifics.pb.h"
-#include "sync/protocol/nigori_specifics.pb.h"
-#include "sync/protocol/preference_specifics.pb.h"
-#include "sync/protocol/sync.pb.h"
-#include "sync/sessions/sync_session_context.h"
-#include "sync/syncable/mutable_entry.h"
-#include "sync/syncable/nigori_util.h"
-#include "sync/syncable/syncable_delete_journal.h"
-#include "sync/syncable/syncable_read_transaction.h"
-#include "sync/syncable/syncable_util.h"
-#include "sync/syncable/syncable_write_transaction.h"
-#include "sync/test/engine/fake_model_worker.h"
-#include "sync/test/engine/mock_connection_manager.h"
-#include "sync/test/engine/mock_nudge_handler.h"
-#include "sync/test/engine/test_directory_setter_upper.h"
-#include "sync/test/engine/test_id_factory.h"
-#include "sync/test/engine/test_syncable_utils.h"
-#include "sync/test/fake_encryptor.h"
-#include "sync/test/fake_sync_encryption_handler.h"
-#include "sync/test/sessions/mock_debug_info_getter.h"
-#include "sync/util/cryptographer.h"
-#include "sync/util/extensions_activity.h"
-#include "sync/util/time.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/model_type.h"
+#include "components/sync/base/time.h"
+#include "components/sync/engine/model_safe_worker.h"
+#include "components/sync/engine_impl/backoff_delay_provider.h"
+#include "components/sync/engine_impl/get_commit_ids.h"
+#include "components/sync/engine_impl/net/server_connection_manager.h"
+#include "components/sync/engine_impl/sync_scheduler_impl.h"
+#include "components/sync/engine_impl/syncer_proto_util.h"
+#include "components/sync/protocol/bookmark_specifics.pb.h"
+#include "components/sync/protocol/nigori_specifics.pb.h"
+#include "components/sync/protocol/preference_specifics.pb.h"
+#include "components/sync/protocol/sync.pb.h"
+#include "components/sync/sessions/commit_counters.h"
+#include "components/sync/sessions/status_counters.h"
+#include "components/sync/sessions/update_counters.h"
+#include "components/sync/sessions_impl/sync_session_context.h"
+#include "components/sync/syncable/mutable_entry.h"
+#include "components/sync/syncable/nigori_util.h"
+#include "components/sync/syncable/syncable_delete_journal.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/engine/fake_model_worker.h"
+#include "components/sync/test/engine/mock_connection_manager.h"
+#include "components/sync/test/engine/mock_nudge_handler.h"
+#include "components/sync/test/engine/test_directory_setter_upper.h"
+#include "components/sync/test/engine/test_id_factory.h"
+#include "components/sync/test/engine/test_syncable_utils.h"
+#include "components/sync/test/fake_encryptor.h"
+#include "components/sync/test/fake_sync_encryption_handler.h"
+#include "components/sync/test/sessions/mock_debug_info_getter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 using std::count;
 using std::map;
 using std::multimap;
 using std::set;
 using std::string;
@@ skipping 108 matching lines @@
 
 }  // namespace
 
 class SyncerTest : public testing::Test,
                    public SyncSession::Delegate,
                    public SyncEngineEventListener {
  protected:
   SyncerTest()
       : extensions_activity_(new ExtensionsActivity),
         syncer_(NULL),
-        last_client_invalidation_hint_buffer_size_(10) {
-}
+        last_client_invalidation_hint_buffer_size_(10) {}
 
   // SyncSession::Delegate implementation.
   void OnThrottled(const base::TimeDelta& throttle_duration) override {
     FAIL() << "Should not get silenced.";
   }
   void OnTypesThrottled(ModelTypeSet types,
                         const base::TimeDelta& throttle_duration) override {
     scheduler_->OnTypesThrottled(types, throttle_duration);
   }
   bool IsCurrentlyThrottled() override { return false; }
@@ skipping 19 matching lines @@
     last_client_invalidation_hint_buffer_size_ = size;
   }
   void OnReceivedGuRetryDelay(const base::TimeDelta& delay) override {}
   void OnReceivedMigrationRequest(ModelTypeSet types) override {}
   void OnProtocolEvent(const ProtocolEvent& event) override {}
   void OnSyncProtocolError(const SyncProtocolError& error) override {}
 
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
     // We're just testing the sync engine here, so we shunt everything to
     // the SyncerThread.  Datatypes which aren't enabled aren't in the map.
-    for (ModelTypeSet::Iterator it = enabled_datatypes_.First();
-         it.Good(); it.Inc()) {
+    for (ModelTypeSet::Iterator it = enabled_datatypes_.First(); it.Good();
+         it.Inc()) {
       (*out)[it.Get()] = GROUP_PASSIVE;
     }
   }
 
   void OnSyncCycleEvent(const SyncCycleEvent& event) override {
     DVLOG(1) << "HandleSyncEngineEvent in unittest " << event.what_happened;
     // we only test for entry-specific events, not status changed ones.
     switch (event.what_happened) {
       case SyncCycleEvent::SYNC_CYCLE_BEGIN:  // Fall through.
       case SyncCycleEvent::STATUS_CHANGED:
@@ skipping 13 matching lines @@
     session_.reset(SyncSession::Build(context_.get(), this));
   }
 
   bool SyncShareNudge() {
     ResetSession();
 
     // Pretend we've seen a local change, to make the nudge_tracker look normal.
     nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
 
     return syncer_->NormalSyncShare(context_->GetEnabledTypes(),
-                                         &nudge_tracker_, session_.get());
+                                    &nudge_tracker_, session_.get());
   }
 
   bool SyncShareConfigure() {
     ResetSession();
     return syncer_->ConfigureSyncShare(
-            context_->GetEnabledTypes(),
-            sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
-            session_.get());
+        context_->GetEnabledTypes(),
+        sync_pb::GetUpdatesCallerInfo::RECONFIGURATION, session_.get());
   }
 
   void SetUp() override {
     dir_maker_.SetUp();
-    mock_server_.reset(new MockConnectionManager(directory(),
-                                                 &cancelation_signal_));
+    mock_server_.reset(
+        new MockConnectionManager(directory(), &cancelation_signal_));
     debug_info_getter_.reset(new MockDebugInfoGetter);
     EnableDatatype(BOOKMARKS);
     EnableDatatype(EXTENSIONS);
     EnableDatatype(NIGORI);
     EnableDatatype(PREFERENCES);
     EnableDatatype(NIGORI);
-    workers_.push_back(scoped_refptr<ModelSafeWorker>(
-        new FakeModelWorker(GROUP_PASSIVE)));
+    workers_.push_back(
+        scoped_refptr<ModelSafeWorker>(new FakeModelWorker(GROUP_PASSIVE)));
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(this);
 
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
     model_type_registry_.reset(
         new ModelTypeRegistry(workers_, directory(), &mock_nudge_handler_));
     model_type_registry_->RegisterDirectoryTypeDebugInfoObserver(
         &debug_info_cache_);
 
     context_.reset(new SyncSessionContext(
-        mock_server_.get(),
-        directory(),
-        extensions_activity_.get(),
-        listeners,
-        debug_info_getter_.get(),
-        model_type_registry_.get(),
+        mock_server_.get(), directory(), extensions_activity_.get(), listeners,
+        debug_info_getter_.get(), model_type_registry_.get(),
         true,   // enable keystore encryption
         false,  // force enable pre-commit GU avoidance experiment
         "fake_invalidator_client_id"));
     context_->SetRoutingInfo(routing_info);
     syncer_ = new Syncer(&cancelation_signal_);
     scheduler_.reset(new SyncSchedulerImpl(
-        "TestSyncScheduler",
-        BackoffDelayProvider::FromDefaults(),
+        "TestSyncScheduler", BackoffDelayProvider::FromDefaults(),
         context_.get(),
         // scheduler_ owned syncer_ now and will manage the memory of syncer_
         syncer_));
 
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Directory::Metahandles children;
     directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
     ASSERT_EQ(0u, children.size());
     root_id_ = TestIdFactory::root();
     parent_id_ = ids_.MakeServer("parent id");
@@ skipping 61 matching lines @@
   }
 
   sync_pb::EntitySpecifics DefaultPreferencesSpecifics() {
     sync_pb::EntitySpecifics result;
     AddDefaultFieldValue(PREFERENCES, &result);
     return result;
   }
   // Enumeration of alterations to entries for commit ordering tests.
   enum EntryFeature {
     LIST_END = 0,  // Denotes the end of the list of features from below.
-    SYNCED,  // Items are unsynced by default
+    SYNCED,        // Items are unsynced by default
     DELETED,
     OLD_MTIME,
     MOVED_FROM_ROOT,
   };
 
   struct CommitOrderingTest {
     // expected commit index.
     int commit_index;
     // Details about the item
     syncable::Id id;
@@ skipping 32 matching lines @@
         entry.PutIsDir(true);
         entry.PutIsUnsynced(true);
         entry.PutSpecifics(DefaultBookmarkSpecifics());
         // Set the time to 30 seconds in the future to reduce the chance of
         // flaky tests.
         const base::Time& now_plus_30s =
             base::Time::Now() + base::TimeDelta::FromSeconds(30);
         const base::Time& now_minus_2h =
             base::Time::Now() - base::TimeDelta::FromHours(2);
         entry.PutMtime(now_plus_30s);
-        for (size_t i = 0 ; i < arraysize(test->features) ; ++i) {
+        for (size_t i = 0; i < arraysize(test->features); ++i) {
           switch (test->features[i]) {
             case LIST_END:
               break;
             case SYNCED:
               entry.PutIsUnsynced(false);
               break;
             case DELETED:
               entry.PutIsDel(true);
               break;
             case OLD_MTIME:
@@ skipping 25 matching lines @@
   }
 
   UpdateCounters GetUpdateCounters(ModelType type) {
     return debug_info_cache_.GetLatestUpdateCounters(type);
   }
 
   StatusCounters GetStatusCounters(ModelType type) {
     return debug_info_cache_.GetLatestStatusCounters(type);
   }
 
-  Directory* directory() {
-    return dir_maker_.directory();
-  }
+  Directory* directory() { return dir_maker_.directory(); }
 
-  const std::string local_cache_guid() {
-    return directory()->cache_guid();
-  }
+  const std::string local_cache_guid() { return directory()->cache_guid(); }
 
-  const std::string foreign_cache_guid() {
-    return "kqyg7097kro6GSUod+GSg==";
-  }
+  const std::string foreign_cache_guid() { return "kqyg7097kro6GSUod+GSg=="; }
 
   int64_t CreateUnsyncedDirectory(const string& entry_name,
                                   const string& idstring) {
     return CreateUnsyncedDirectory(entry_name,
-        syncable::Id::CreateFromServerId(idstring));
+                                   syncable::Id::CreateFromServerId(idstring));
   }
 
   int64_t CreateUnsyncedDirectory(const string& entry_name,
                                   const syncable::Id& id) {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(
-        &wtrans, CREATE, BOOKMARKS, wtrans.root_id(), entry_name);
+    MutableEntry entry(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
+                       entry_name);
     EXPECT_TRUE(entry.good());
     entry.PutIsUnsynced(true);
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutBaseVersion(id.ServerKnows() ? 1 : 0);
     entry.PutId(id);
     return entry.GetMetahandle();
   }
 
   void EnableDatatype(ModelType model_type) {
@@ skipping 62 matching lines @@
   TypeDebugInfoCache debug_info_cache_;
   MockNudgeHandler mock_nudge_handler_;
   std::unique_ptr<ModelTypeRegistry> model_type_registry_;
   std::unique_ptr<SyncSchedulerImpl> scheduler_;
   std::unique_ptr<SyncSessionContext> context_;
   base::TimeDelta last_short_poll_interval_received_;
   base::TimeDelta last_long_poll_interval_received_;
   base::TimeDelta last_sessions_commit_delay_;
   base::TimeDelta last_bookmarks_commit_delay_;
   int last_client_invalidation_hint_buffer_size_;
-  std::vector<scoped_refptr<ModelSafeWorker> > workers_;
+  std::vector<scoped_refptr<ModelSafeWorker>> workers_;
 
   ModelTypeSet enabled_datatypes_;
   sessions::NudgeTracker nudge_tracker_;
   std::unique_ptr<MockDebugInfoGetter> debug_info_getter_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SyncerTest);
 };
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   {
     Syncer::UnsyncedMetaHandles handles;
     {
       syncable::ReadTransaction trans(FROM_HERE, directory());
       GetUnsyncedEntries(&trans, &handles);
     }
     ASSERT_EQ(0u, handles.size());
   }
   // TODO(sync): When we can dynamically connect and disconnect the mock
   // ServerConnectionManager test disconnected GetUnsyncedEntries here. It's a
   // regression for a very old bug.
 }
 
 TEST_F(SyncerTest, GetCommitIdsFiltersThrottledEntries) {
   const ModelTypeSet throttled_types(BOOKMARKS);
   sync_pb::EntitySpecifics bookmark_data;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_data);
 
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
+                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutSpecifics(bookmark_data);
     A.PutNonUniqueName("bookmark");
   }
@@ skipping 153 matching lines @@
     EXPECT_EQ(server_version, entryA.GetServerVersion());                     \
   } while (0)
 
 TEST_F(SyncerTest, GetCommitIdsFiltersUnreadyEntries) {
   KeyParams key_params = {"localhost", "dummy", "foobar"};
   KeyParams other_params = {"localhost", "dummy", "foobar2"};
   sync_pb::EntitySpecifics bookmark, encrypted_bookmark;
   bookmark.mutable_bookmark()->set_url("url");
   bookmark.mutable_bookmark()->set_title("title");
   AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark);
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10,
-                                   foreign_cache_guid(), "-2");
-  mock_server_->AddUpdateDirectory(3, 0, "C", 10, 10,
-                                   foreign_cache_guid(), "-3");
-  mock_server_->AddUpdateDirectory(4, 0, "D", 10, 10,
-                                   foreign_cache_guid(), "-4");
+  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
+                                   "-1");
+  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10, foreign_cache_guid(),
+                                   "-2");
+  mock_server_->AddUpdateDirectory(3, 0, "C", 10, 10, foreign_cache_guid(),
+                                   "-3");
+  mock_server_->AddUpdateDirectory(4, 0, "D", 10, 10, foreign_cache_guid(),
+                                   "-4");
   EXPECT_TRUE(SyncShareNudge());
   // Server side change will put A in conflict.
-  mock_server_->AddUpdateDirectory(1, 0, "A", 20, 20,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "A", 20, 20, foreign_cache_guid(),
+                                   "-1");
   {
     // Mark bookmarks as encrypted and set the cryptographer to have pending
     // keys.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     Cryptographer other_cryptographer(&encryptor_);
     other_cryptographer.AddKey(other_params);
     sync_pb::EntitySpecifics specifics;
     sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     other_cryptographer.GetKeys(nigori->mutable_encryption_keybag());
     dir_maker_.encryption_handler()->EnableEncryptEverything();
     // Set up with an old passphrase, but have pending keys
     GetCryptographer(&wtrans)->AddKey(key_params);
     GetCryptographer(&wtrans)->Encrypt(bookmark,
-                                    encrypted_bookmark.mutable_encrypted());
+                                       encrypted_bookmark.mutable_encrypted());
     GetCryptographer(&wtrans)->SetPendingKeys(nigori->encryption_keybag());
 
     // In conflict but properly encrypted.
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutSpecifics(encrypted_bookmark);
     A.PutNonUniqueName(kEncryptedString);
     // Not in conflict and properly encrypted.
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
@@ skipping 214 matching lines @@
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 
     // Create a bookmark tree with one root, two second level, and three third
     // level bookmarks, all folders.
     for (int i = 1; i <= 6; ++i) {
       MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "");
       entry.PutId(ids_.FromNumber(i));
       entry.PutIsDir(true);
       entry.PutBaseVersion(5);
       entry.PutServerVersion(5);
-      entry.PutParentId(ids_.FromNumber(i/2));
-      entry.PutServerParentId(ids_.FromNumber(i/2));
+      entry.PutParentId(ids_.FromNumber(i / 2));
+      entry.PutServerParentId(ids_.FromNumber(i / 2));
       entry.PutServerIsDir(true);
       entry.PutIsUnsynced(true);
       entry.PutSpecifics(DefaultBookmarkSpecifics());
       entry.PutIsDel(true);
     }
   }
 
   {
     // Run GetCommitIds with a limit of 2 entries to commit.
     syncable::Directory::Metahandles result_handles;
@@ skipping 11 matching lines @@
     EXPECT_EQ(ids_.FromNumber(5), entry1.GetId());
   }
 }
 
 TEST_F(SyncerTest, EncryptionAwareConflicts) {
   KeyParams key_params = {"localhost", "dummy", "foobar"};
   Cryptographer other_cryptographer(&encryptor_);
   other_cryptographer.AddKey(key_params);
   sync_pb::EntitySpecifics bookmark, encrypted_bookmark, modified_bookmark;
   bookmark.mutable_bookmark()->set_title("title");
-  other_cryptographer.Encrypt(bookmark,
-                              encrypted_bookmark.mutable_encrypted());
+  other_cryptographer.Encrypt(bookmark, encrypted_bookmark.mutable_encrypted());
   AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark);
   modified_bookmark.mutable_bookmark()->set_title("title2");
   other_cryptographer.Encrypt(modified_bookmark,
                               modified_bookmark.mutable_encrypted());
   sync_pb::EntitySpecifics pref, encrypted_pref, modified_pref;
   pref.mutable_preference()->set_name("name");
   AddDefaultFieldValue(PREFERENCES, &encrypted_pref);
-  other_cryptographer.Encrypt(pref,
-                              encrypted_pref.mutable_encrypted());
+  other_cryptographer.Encrypt(pref, encrypted_pref.mutable_encrypted());
   modified_pref.mutable_preference()->set_name("name2");
-  other_cryptographer.Encrypt(modified_pref,
-                              modified_pref.mutable_encrypted());
+  other_cryptographer.Encrypt(modified_pref, modified_pref.mutable_encrypted());
   {
     // Mark bookmarks and preferences as encrypted and set the cryptographer to
     // have pending keys.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     sync_pb::EntitySpecifics specifics;
     sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     other_cryptographer.GetKeys(nigori->mutable_encryption_keybag());
     dir_maker_.encryption_handler()->EnableEncryptEverything();
     GetCryptographer(&wtrans)->SetPendingKeys(nigori->encryption_keybag());
     EXPECT_TRUE(GetCryptographer(&wtrans)->has_pending_keys());
@@ skipping 15 matching lines @@
   EXPECT_TRUE(SyncShareNudge());
   {
     // Initial state. Everything is normal.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, false, false, 0, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(2, false, false, false, 1, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(3, false, false, false, 1, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(4, false, false, false, 0, 10, 10, ids_, &rtrans);
 
     Entry entry1(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(entry1.GetUniquePosition().Equals(
-        entry1.GetServerUniquePosition()));
+    ASSERT_TRUE(
+        entry1.GetUniquePosition().Equals(entry1.GetServerUniquePosition()));
     pos1 = entry1.GetUniquePosition();
     Entry entry2(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(2));
     pos2 = entry2.GetUniquePosition();
     Entry entry3(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(3));
     pos3 = entry3.GetUniquePosition();
   }
 
   // Server side encryption will not be applied due to undecryptable data.
   // At this point, BASE_SERVER_SPECIFICS should be filled for all four items.
   mock_server_->AddUpdateSpecifics(1, 0, kEncryptedString, 20, 20, true, 0,
-                                   encrypted_bookmark,
-                                   foreign_cache_guid(), "-1");
+                                   encrypted_bookmark, foreign_cache_guid(),
+                                   "-1");
   mock_server_->AddUpdateSpecifics(2, 1, kEncryptedString, 20, 20, false, 2,
-                                   encrypted_bookmark,
-                                   foreign_cache_guid(), "-2");
+                                   encrypted_bookmark, foreign_cache_guid(),
+                                   "-2");
   mock_server_->AddUpdateSpecifics(3, 1, kEncryptedString, 20, 20, false, 1,
-                                   encrypted_bookmark,
-                                   foreign_cache_guid(), "-3");
+                                   encrypted_bookmark, foreign_cache_guid(),
+                                   "-3");
   mock_server_->AddUpdateSpecifics(4, 0, kEncryptedString, 20, 20, false, 0,
-                                   encrypted_pref,
-                                   foreign_cache_guid(), "-4");
+                                   encrypted_pref, foreign_cache_guid(), "-4");
   EXPECT_TRUE(SyncShareNudge());
   {
     // All should be unapplied due to being undecryptable and have a valid
     // BASE_SERVER_SPECIFICS.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, true, false, true, 0, 10, 20, ids_, &rtrans);
     VERIFY_ENTRY(2, true, false, true, 1, 10, 20, ids_, &rtrans);
     VERIFY_ENTRY(3, true, false, true, 1, 10, 20, ids_, &rtrans);
     VERIFY_ENTRY(4, true, false, true, 0, 10, 20, ids_, &rtrans);
   }
 
   // Server side change that don't modify anything should not affect
   // BASE_SERVER_SPECIFICS (such as name changes and mtime changes).
   mock_server_->AddUpdateSpecifics(1, 0, kEncryptedString, 30, 30, true, 0,
-                                   encrypted_bookmark,
-                                   foreign_cache_guid(), "-1");
+                                   encrypted_bookmark, foreign_cache_guid(),
+                                   "-1");
   mock_server_->AddUpdateSpecifics(2, 1, kEncryptedString, 30, 30, false, 2,
-                                   encrypted_bookmark,
-                                   foreign_cache_guid(), "-2");
+                                   encrypted_bookmark, foreign_cache_guid(),
+                                   "-2");
   // Item 3 doesn't change.
   mock_server_->AddUpdateSpecifics(4, 0, kEncryptedString, 30, 30, false, 0,
-                                   encrypted_pref,
-                                   foreign_cache_guid(), "-4");
+                                   encrypted_pref, foreign_cache_guid(), "-4");
   EXPECT_TRUE(SyncShareNudge());
   {
     // Items 1, 2, and 4 should have newer server versions, 3 remains the same.
     // All should remain unapplied due to be undecryptable.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, true, false, true, 0, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(2, true, false, true, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(3, true, false, true, 1, 10, 20, ids_, &rtrans);
     VERIFY_ENTRY(4, true, false, true, 0, 10, 30, ids_, &rtrans);
   }
 
   // Positional changes, parent changes, and specifics changes should reset
   // BASE_SERVER_SPECIFICS.
   // Became unencrypted.
   mock_server_->AddUpdateSpecifics(1, 0, "A", 40, 40, true, 0, bookmark,
                                    foreign_cache_guid(), "-1");
   // Reordered to after item 2.
   mock_server_->AddUpdateSpecifics(3, 1, kEncryptedString, 30, 30, false, 3,
-                                   encrypted_bookmark,
-                                   foreign_cache_guid(), "-3");
+                                   encrypted_bookmark, foreign_cache_guid(),
+                                   "-3");
   EXPECT_TRUE(SyncShareNudge());
   {
     // Items 2 and 4 should be the only ones with BASE_SERVER_SPECIFICS set.
     // Items 1 is now unencrypted, so should have applied normally.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, false, false, 0, 40, 40, ids_, &rtrans);
     VERIFY_ENTRY(2, true, false, true, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(3, true, false, false, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(4, true, false, true, 0, 10, 30, ids_, &rtrans);
   }
@@ skipping 126 matching lines @@
 
     MutableEntry parent2(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Tim");
     ASSERT_TRUE(parent2.good());
     parent2.PutIsUnsynced(true);
     parent2.PutIsDir(true);
     parent2.PutSpecifics(DefaultPreferencesSpecifics());
     parent2.PutBaseVersion(1);
     parent2.PutId(pref_node_id);
   }
 
-  directory()->PurgeEntriesWithTypeIn(ModelTypeSet(PREFERENCES),
-                                      ModelTypeSet(),
+  directory()->PurgeEntriesWithTypeIn(ModelTypeSet(PREFERENCES), ModelTypeSet(),
                                       ModelTypeSet());
 
   EXPECT_TRUE(SyncShareNudge());
   ASSERT_EQ(2U, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_EQ(parent_id_, mock_server_->committed_ids()[0]);
   EXPECT_EQ(child_id_, mock_server_->committed_ids()[1]);
   {
     syncable::ReadTransaction rt(FROM_HERE, directory());
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
@@ skipping 16 matching lines @@
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Pete");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnappliedUpdate(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutBaseVersion(1);
     parent.PutId(parent_id_);
   }
 
-  directory()->PurgeEntriesWithTypeIn(ModelTypeSet(BOOKMARKS),
-                                      ModelTypeSet(),
+  directory()->PurgeEntriesWithTypeIn(ModelTypeSet(BOOKMARKS), ModelTypeSet(),
                                       ModelTypeSet());
 
   EXPECT_TRUE(SyncShareNudge());
   directory()->SaveChanges();
   {
     syncable::ReadTransaction rt(FROM_HERE, directory());
     Entry entry(&rt, syncable::GET_BY_ID, parent_id_);
     ASSERT_FALSE(entry.good());
   }
 }
@@ skipping 20 matching lines @@
     MutableEntry parent2(&wtrans, syncable::CREATE, PREFERENCES,
                          wtrans.root_id(), "Tim");
     ASSERT_TRUE(parent2.good());
     parent2.PutIsDir(true);
     parent2.PutSpecifics(DefaultPreferencesSpecifics());
     parent2.PutBaseVersion(1);
     parent2.PutId(TestIdFactory::MakeServer("Tim"));
   }
 
   directory()->PurgeEntriesWithTypeIn(ModelTypeSet(PREFERENCES, BOOKMARKS),
-                                      ModelTypeSet(BOOKMARKS),
-                                      ModelTypeSet());
+                                      ModelTypeSet(BOOKMARKS), ModelTypeSet());
   {
     // Verify bookmark nodes are saved in delete journal but not preference
     // node.
     syncable::ReadTransaction rt(FROM_HERE, directory());
     syncable::DeleteJournal* delete_journal = directory()->delete_journal();
     EXPECT_EQ(2u, delete_journal->GetDeleteJournalSize(&rt));
     syncable::EntryKernelSet journal_entries;
     directory()->delete_journal()->GetDeleteJournals(&rt, BOOKMARKS,
                                                      &journal_entries);
     EXPECT_EQ(parent_id_, (*journal_entries.begin())->ref(syncable::ID));
@@ skipping 53 matching lines @@
     Entry entry4(&trans, GET_BY_CLIENT_TAG, "tag4");
     EXPECT_EQ(-1, entry4.GetBaseVersion());
     EXPECT_EQ(0, entry4.GetServerVersion());
     EXPECT_TRUE(entry4.GetIsUnsynced());
     EXPECT_FALSE(entry4.GetIsUnappliedUpdate());
   }
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingTwoItemsTall) {
   CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(-1001), ids_.FromNumber(-1000)},
-    {0, ids_.FromNumber(-1000), ids_.FromNumber(0)},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {1, ids_.FromNumber(-1001), ids_.FromNumber(-1000)},
+      {0, ids_.FromNumber(-1000), ids_.FromNumber(0)},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingThreeItemsTall) {
   CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(-2001), ids_.FromNumber(-2000)},
-    {0, ids_.FromNumber(-2000), ids_.FromNumber(0)},
-    {2, ids_.FromNumber(-2002), ids_.FromNumber(-2001)},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {1, ids_.FromNumber(-2001), ids_.FromNumber(-2000)},
+      {0, ids_.FromNumber(-2000), ids_.FromNumber(0)},
+      {2, ids_.FromNumber(-2002), ids_.FromNumber(-2001)},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingFourItemsTall) {
   CommitOrderingTest items[] = {
-    {3, ids_.FromNumber(-2003), ids_.FromNumber(-2002)},
-    {1, ids_.FromNumber(-2001), ids_.FromNumber(-2000)},
-    {0, ids_.FromNumber(-2000), ids_.FromNumber(0)},
-    {2, ids_.FromNumber(-2002), ids_.FromNumber(-2001)},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {3, ids_.FromNumber(-2003), ids_.FromNumber(-2002)},
+      {1, ids_.FromNumber(-2001), ids_.FromNumber(-2000)},
+      {0, ids_.FromNumber(-2000), ids_.FromNumber(0)},
+      {2, ids_.FromNumber(-2002), ids_.FromNumber(-2001)},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingThreeItemsTallLimitedSize) {
   context_->set_max_commit_batch_size(2);
   CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(-2001), ids_.FromNumber(-2000)},
-    {0, ids_.FromNumber(-2000), ids_.FromNumber(0)},
-    {2, ids_.FromNumber(-2002), ids_.FromNumber(-2001)},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {1, ids_.FromNumber(-2001), ids_.FromNumber(-2000)},
+      {0, ids_.FromNumber(-2000), ids_.FromNumber(0)},
+      {2, ids_.FromNumber(-2002), ids_.FromNumber(-2001)},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingSingleDeletedItem) {
   CommitOrderingTest items[] = {
-    {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingSingleUncommittedDeletedItem) {
   CommitOrderingTest items[] = {
-    {-1, ids_.FromNumber(-1000), ids_.FromNumber(0), {DELETED}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {-1, ids_.FromNumber(-1000), ids_.FromNumber(0), {DELETED}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingSingleDeletedItemWithUnroll) {
   CommitOrderingTest items[] = {
-    {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
-TEST_F(SyncerTest,
-       TestCommitListOrderingSingleLongDeletedItemWithUnroll) {
+TEST_F(SyncerTest, TestCommitListOrderingSingleLongDeletedItemWithUnroll) {
   CommitOrderingTest items[] = {
-    {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingTwoLongDeletedItemWithUnroll) {
   CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {0, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED, OLD_MTIME}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {1, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
+      {0, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED, OLD_MTIME}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrdering3LongDeletedItemsWithSizeLimit) {
   context_->set_max_commit_batch_size(2);
   CommitOrderingTest items[] = {
-    {2, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {1, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED, OLD_MTIME}},
-    {0, ids_.FromNumber(1002), ids_.FromNumber(1001), {DELETED, OLD_MTIME}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {2, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
+      {1, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED, OLD_MTIME}},
+      {0, ids_.FromNumber(1002), ids_.FromNumber(1001), {DELETED, OLD_MTIME}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingTwoDeletedItemsWithUnroll) {
   CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED}},
-    {0, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {1, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED}},
+      {0, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingComplexDeletionScenario) {
   CommitOrderingTest items[] = {
-    {2, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {-1, ids_.FromNumber(1001), ids_.FromNumber(0), {SYNCED}},
-    {1, ids_.FromNumber(1002), ids_.FromNumber(1001), {DELETED, OLD_MTIME}},
-    {-1, ids_.FromNumber(1003), ids_.FromNumber(1001), {SYNCED}},
-    {0, ids_.FromNumber(1004), ids_.FromNumber(1003), {DELETED}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {2, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
+      {-1, ids_.FromNumber(1001), ids_.FromNumber(0), {SYNCED}},
+      {1, ids_.FromNumber(1002), ids_.FromNumber(1001), {DELETED, OLD_MTIME}},
+      {-1, ids_.FromNumber(1003), ids_.FromNumber(1001), {SYNCED}},
+      {0, ids_.FromNumber(1004), ids_.FromNumber(1003), {DELETED}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest,
        TestCommitListOrderingComplexDeletionScenarioWith2RecentDeletes) {
   CommitOrderingTest items[] = {
-    {3, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {-1, ids_.FromNumber(1001), ids_.FromNumber(0), {SYNCED}},
-    {2, ids_.FromNumber(1002), ids_.FromNumber(1001), {DELETED, OLD_MTIME}},
-    {-1, ids_.FromNumber(1003), ids_.FromNumber(1001), {SYNCED}},
-    {1, ids_.FromNumber(1004), ids_.FromNumber(1003), {DELETED}},
-    {0, ids_.FromNumber(1005), ids_.FromNumber(1003), {DELETED}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {3, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
+      {-1, ids_.FromNumber(1001), ids_.FromNumber(0), {SYNCED}},
+      {2, ids_.FromNumber(1002), ids_.FromNumber(1001), {DELETED, OLD_MTIME}},
+      {-1, ids_.FromNumber(1003), ids_.FromNumber(1001), {SYNCED}},
+      {1, ids_.FromNumber(1004), ids_.FromNumber(1003), {DELETED}},
+      {0, ids_.FromNumber(1005), ids_.FromNumber(1003), {DELETED}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingDeleteMovedItems) {
   CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {0, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED, OLD_MTIME,
-                                              MOVED_FROM_ROOT}},
-    CommitOrderingTest::MakeLastCommitItem(),
+      {1, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
+      {0,
+       ids_.FromNumber(1001),
+       ids_.FromNumber(1000),
+       {DELETED, OLD_MTIME, MOVED_FROM_ROOT}},
+      CommitOrderingTest::MakeLastCommitItem(),
   };
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingWithNesting) {
   const base::Time& now_minus_2h =
       base::Time::Now() - base::TimeDelta::FromHours(2);
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     {
       MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Bob");
       ASSERT_TRUE(parent.good());
       parent.PutIsUnsynced(true);
       parent.PutIsDir(true);
       parent.PutSpecifics(DefaultBookmarkSpecifics());
       parent.PutId(ids_.FromNumber(100));
       parent.PutBaseVersion(1);
-      MutableEntry child(
-          &wtrans, CREATE, BOOKMARKS, ids_.FromNumber(100), "Bob");
+      MutableEntry child(&wtrans, CREATE, BOOKMARKS, ids_.FromNumber(100),
+                         "Bob");
       ASSERT_TRUE(child.good());
       child.PutIsUnsynced(true);
       child.PutIsDir(true);
       child.PutSpecifics(DefaultBookmarkSpecifics());
       child.PutId(ids_.FromNumber(101));
       child.PutBaseVersion(1);
-      MutableEntry grandchild(
-          &wtrans, CREATE, BOOKMARKS, ids_.FromNumber(101), "Bob");
+      MutableEntry grandchild(&wtrans, CREATE, BOOKMARKS, ids_.FromNumber(101),
+                              "Bob");
       ASSERT_TRUE(grandchild.good());
       grandchild.PutId(ids_.FromNumber(102));
       grandchild.PutIsUnsynced(true);
       grandchild.PutSpecifics(DefaultBookmarkSpecifics());
       grandchild.PutBaseVersion(1);
     }
     {
       // Create three deleted items which deletions we expect to be sent to the
       // server.
       MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Pete");
       ASSERT_TRUE(parent.good());
       parent.PutId(ids_.FromNumber(103));
       parent.PutIsUnsynced(true);
       parent.PutIsDir(true);
       parent.PutSpecifics(DefaultBookmarkSpecifics());
       parent.PutIsDel(true);
       parent.PutBaseVersion(1);
       parent.PutMtime(now_minus_2h);
-      MutableEntry child(
-          &wtrans, CREATE, BOOKMARKS, ids_.FromNumber(103), "Pete");
+      MutableEntry child(&wtrans, CREATE, BOOKMARKS, ids_.FromNumber(103),
+                         "Pete");
       ASSERT_TRUE(child.good());
       child.PutId(ids_.FromNumber(104));
       child.PutIsUnsynced(true);
       child.PutIsDir(true);
       child.PutSpecifics(DefaultBookmarkSpecifics());
       child.PutIsDel(true);
       child.PutBaseVersion(1);
       child.PutMtime(now_minus_2h);
-      MutableEntry grandchild(
-          &wtrans, CREATE, BOOKMARKS, ids_.FromNumber(104), "Pete");
+      MutableEntry grandchild(&wtrans, CREATE, BOOKMARKS, ids_.FromNumber(104),
+                              "Pete");
       ASSERT_TRUE(grandchild.good());
       grandchild.PutId(ids_.FromNumber(105));
       grandchild.PutIsUnsynced(true);
       grandchild.PutIsDel(true);
       grandchild.PutIsDir(false);
       grandchild.PutSpecifics(DefaultBookmarkSpecifics());
       grandchild.PutBaseVersion(1);
       grandchild.PutMtime(now_minus_2h);
     }
   }
@@ skipping 149 matching lines @@
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutId(parent_id_);
     parent.PutBaseVersion(1);
   }
 
   syncable::Id parent2_id = ids_.NewLocalId();
   syncable::Id child_id = ids_.NewServerId();
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent2(
-        &wtrans, CREATE, BOOKMARKS, parent_id_, parent2_name);
+    MutableEntry parent2(&wtrans, CREATE, BOOKMARKS, parent_id_, parent2_name);
     ASSERT_TRUE(parent2.good());
     parent2.PutIsUnsynced(true);
     parent2.PutIsDir(true);
     parent2.PutSpecifics(DefaultBookmarkSpecifics());
     parent2.PutId(parent2_id);
 
-    MutableEntry child(
-        &wtrans, CREATE, BOOKMARKS, parent2_id, child_name);
+    MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent2_id, child_name);
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
     child.PutIsDir(true);
     child.PutSpecifics(DefaultBookmarkSpecifics());
     child.PutId(child_id);
     child.PutBaseVersion(1);
   }
 
   EXPECT_TRUE(SyncShareNudge());
   ASSERT_EQ(3u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_EQ(parent_id_, mock_server_->committed_ids()[0]);
   EXPECT_EQ(parent2_id, mock_server_->committed_ids()[1]);
   EXPECT_EQ(child_id, mock_server_->committed_ids()[2]);
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     // Check that things committed correctly.
     Entry entry_1(&rtrans, syncable::GET_BY_ID, parent_id_);
     EXPECT_EQ(parent1_name, entry_1.GetNonUniqueName());
     // Check that parent2 is a subfolder of parent1.
-    EXPECT_EQ(1, CountEntriesWithName(&rtrans,
-                                      parent_id_,
-                                      parent2_name));
+    EXPECT_EQ(1, CountEntriesWithName(&rtrans, parent_id_, parent2_name));
 
     // Parent2 was a local ID and thus should have changed on commit!
     Entry pre_commit_entry_parent2(&rtrans, syncable::GET_BY_ID, parent2_id);
     ASSERT_FALSE(pre_commit_entry_parent2.good());
 
     // Look up the new ID.
     Id parent2_committed_id =
         GetOnlyEntryWithName(&rtrans, parent_id_, parent2_name);
     EXPECT_TRUE(parent2_committed_id.ServerKnows());
 
     Entry child(&rtrans, syncable::GET_BY_ID, child_id);
     EXPECT_EQ(parent2_committed_id, child.GetParentId());
   }
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingAndNewParentAndChild) {
   string parent_name = "1";
   string parent2_name = "A";
   string child_name = "B";
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans,
-                        CREATE, BOOKMARKS,
-                        wtrans.root_id(),
+    MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
                         parent_name);
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutId(parent_id_);
     parent.PutBaseVersion(1);
   }
 
   int64_t meta_handle_b;
   const Id parent2_local_id = ids_.NewLocalId();
   const Id child_local_id = ids_.NewLocalId();
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent2(&wtrans, CREATE, BOOKMARKS, parent_id_, parent2_name);
     ASSERT_TRUE(parent2.good());
     parent2.PutIsUnsynced(true);
     parent2.PutIsDir(true);
     parent2.PutSpecifics(DefaultBookmarkSpecifics());
 
     parent2.PutId(parent2_local_id);
-    MutableEntry child(
-        &wtrans, CREATE, BOOKMARKS, parent2_local_id, child_name);
+    MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent2_local_id,
+                       child_name);
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
     child.PutIsDir(true);
     child.PutSpecifics(DefaultBookmarkSpecifics());
     child.PutId(child_local_id);
     meta_handle_b = child.GetMetahandle();
   }
 
   EXPECT_TRUE(SyncShareNudge());
   ASSERT_EQ(3u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_EQ(parent_id_, mock_server_->committed_ids()[0]);
   EXPECT_EQ(parent2_local_id, mock_server_->committed_ids()[1]);
   EXPECT_EQ(child_local_id, mock_server_->committed_ids()[2]);
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
 
     Entry parent(&rtrans, syncable::GET_BY_ID,
                  GetOnlyEntryWithName(&rtrans, rtrans.root_id(), parent_name));
     ASSERT_TRUE(parent.good());
     EXPECT_TRUE(parent.GetId().ServerKnows());
 
     Entry parent2(&rtrans, syncable::GET_BY_ID,
                   GetOnlyEntryWithName(&rtrans, parent.GetId(), parent2_name));
     ASSERT_TRUE(parent2.good());
     EXPECT_TRUE(parent2.GetId().ServerKnows());
 
     // Id changed on commit, so this should fail.
-    Entry local_parent2_id_entry(&rtrans,
-                                 syncable::GET_BY_ID,
+    Entry local_parent2_id_entry(&rtrans, syncable::GET_BY_ID,
                                  parent2_local_id);
     ASSERT_FALSE(local_parent2_id_entry.good());
 
     Entry entry_b(&rtrans, syncable::GET_BY_HANDLE, meta_handle_b);
     EXPECT_TRUE(entry_b.GetId().ServerKnows());
     EXPECT_TRUE(parent2.GetId() == entry_b.GetParentId());
   }
 }
 
 TEST_F(SyncerTest, UpdateWithZeroLengthName) {
   // One illegal update
-  mock_server_->AddUpdateDirectory(
-      1, 0, std::string(), 1, 10, foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, std::string(), 1, 10,
+                                   foreign_cache_guid(), "-1");
   // And one legal one that we're going to delete.
-  mock_server_->AddUpdateDirectory(2, 0, "FOO", 1, 10,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(2, 0, "FOO", 1, 10, foreign_cache_guid(),
+                                   "-2");
   EXPECT_TRUE(SyncShareNudge());
   // Delete the legal one. The new update has a null name.
-  mock_server_->AddUpdateDirectory(
-      2, 0, std::string(), 2, 20, foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(2, 0, std::string(), 2, 20,
+                                   foreign_cache_guid(), "-2");
   mock_server_->SetLastUpdateDeleted();
   EXPECT_TRUE(SyncShareNudge());
 }
 
 TEST_F(SyncerTest, TestBasicUpdate) {
   string id = "some_id";
   string parent_id = "0";
   string name = "in_root";
   int64_t version = 10;
   int64_t timestamp = 10;
   mock_server_->AddUpdateDirectory(id, parent_id, name, version, timestamp,
                                    foreign_cache_guid(), "-1");
 
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    Entry entry(&trans, GET_BY_ID,
-               syncable::Id::CreateFromServerId("some_id"));
+    Entry entry(&trans, GET_BY_ID, syncable::Id::CreateFromServerId("some_id"));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetIsDir());
     EXPECT_EQ(version, entry.GetServerVersion());
     EXPECT_EQ(version, entry.GetBaseVersion());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetServerIsDel());
     EXPECT_FALSE(entry.GetIsDel());
   }
 }
@@ skipping 146 matching lines @@
       GetUpdateCounters(BOOKMARKS).num_hierarchy_conflict_application_failures);
 }
 
 // A commit with a lost response produces an update that has to be reunited with
 // its parent.
 TEST_F(SyncerTest, CommitReuniteUpdateAdjustsChildren) {
   // Create a folder in the root.
   int64_t metahandle_folder;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(
-        &trans, CREATE, BOOKMARKS, trans.root_id(), "new_folder");
+    MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(),
+                       "new_folder");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsUnsynced(true);
     metahandle_folder = entry.GetMetahandle();
   }
 
   // Verify it and pull the ID out of the folder.
   syncable::Id folder_id;
   int64_t metahandle_entry;
@@ skipping 28 matching lines @@
   }
 
   // Now, to emulate a commit response failure, we just don't commit it.
   int64_t new_version = 150;  // any larger value.
   int64_t timestamp = 20;     // arbitrary value.
   syncable::Id new_folder_id =
       syncable::Id::CreateFromServerId("folder_server_id");
 
   // The following update should cause the folder to both apply the update, as
   // well as reassociate the id.
-  mock_server_->AddUpdateDirectory(new_folder_id, root_id_,
-      "new_folder", new_version, timestamp,
-      local_cache_guid(), folder_id.GetServerId());
+  mock_server_->AddUpdateDirectory(new_folder_id, root_id_, "new_folder",
+                                   new_version, timestamp, local_cache_guid(),
+                                   folder_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Alright! Apply that update!
   EXPECT_FALSE(SyncShareNudge());
   {
     // The folder's ID should have been updated.
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry folder(&trans, GET_BY_HANDLE, metahandle_folder);
@@ skipping 42 matching lines @@
     EXPECT_TRUE(!entry_id.ServerKnows());
     VerifyTestDataInEntry(&trans, &entry);
   }
 
   // Now, to emulate a commit response failure, we just don't commit it.
   int64_t new_version = 150;  // any larger value.
   int64_t timestamp = 20;     // arbitrary value.
   syncable::Id new_entry_id = syncable::Id::CreateFromServerId("server_id");
 
   // Generate an update from the server with a relevant ID reassignment.
-  mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
-      "new_entry", new_version, timestamp,
-      local_cache_guid(), entry_id.GetServerId());
+  mock_server_->AddUpdateBookmark(new_entry_id, root_id_, "new_entry",
+                                  new_version, timestamp, local_cache_guid(),
+                                  entry_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Alright! Apply that update!
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
@@ skipping 28 matching lines @@
     EXPECT_TRUE(!entry_id.ServerKnows());
     VerifyTestDataInEntry(&trans, &entry);
   }
 
   // Now, to emulate a commit response failure, we just don't commit it.
   int64_t new_version = 150;  // any larger value.
   int64_t timestamp = 20;     // arbitrary value.
   syncable::Id new_entry_id = syncable::Id::CreateFromServerId("server_id");
 
   // Generate an update from the server with a relevant ID reassignment.
-  mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
-      "new_entry", new_version, timestamp,
-      local_cache_guid(), entry_id.GetServerId());
+  mock_server_->AddUpdateBookmark(new_entry_id, root_id_, "new_entry",
+                                  new_version, timestamp, local_cache_guid(),
+                                  entry_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Purposefully delete the entry now before the update application finishes.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    Id new_entry_id = GetOnlyEntryWithName(
-        &trans, trans.root_id(), "new_entry");
+    Id new_entry_id =
+        GetOnlyEntryWithName(&trans, trans.root_id(), "new_entry");
     MutableEntry entry(&trans, GET_BY_ID, new_entry_id);
     ASSERT_TRUE(entry.good());
     entry.PutIsDel(true);
   }
 
   // Just don't CHECK fail in sync, have the update split.
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
-    Id new_entry_id = GetOnlyEntryWithName(
-        &trans, trans.root_id(), "new_entry");
+    Id new_entry_id =
+        GetOnlyEntryWithName(&trans, trans.root_id(), "new_entry");
     Entry entry(&trans, GET_BY_ID, new_entry_id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsDel());
 
     Entry old_entry(&trans, GET_BY_ID, entry_id);
     ASSERT_TRUE(old_entry.good());
     EXPECT_TRUE(old_entry.GetIsDel());
   }
 }
 
 // TODO(chron): Add more unsanitized name tests.
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesUnsanitizedNames) {
-  mock_server_->AddUpdateDirectory(1, 0, "A/A", 10, 10,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateDirectory(2, 0, "B/B", 10, 10,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(1, 0, "A/A", 10, 10, foreign_cache_guid(),
+                                   "-1");
+  mock_server_->AddUpdateDirectory(2, 0, "B/B", 10, 10, foreign_cache_guid(),
+                                   "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutIsUnappliedUpdate(true);
     A.PutServerVersion(20);
@@ skipping 17 matching lines @@
 
     Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_FALSE(B.GetIsUnsynced());
     EXPECT_FALSE(B.GetIsUnappliedUpdate());
     EXPECT_EQ(20, B.GetServerVersion());
   }
 }
 
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesNormalNames) {
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
+                                   "-1");
+  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10, foreign_cache_guid(),
+                                   "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutIsUnappliedUpdate(true);
     A.PutServerVersion(20);
@@ skipping 19 matching lines @@
     ASSERT_TRUE(B.good());
     EXPECT_FALSE(B.GetIsUnsynced());
     EXPECT_FALSE(B.GetIsUnappliedUpdate());
     EXPECT_EQ(20, B.GetServerVersion());
   }
 }
 
 TEST_F(SyncerTest, ReverseFolderOrderingTest) {
   mock_server_->AddUpdateDirectory(4, 3, "ggchild", 10, 10,
                                    foreign_cache_guid(), "-4");
-  mock_server_->AddUpdateDirectory(3, 2, "gchild", 10, 10,
-                                   foreign_cache_guid(), "-3");
+  mock_server_->AddUpdateDirectory(3, 2, "gchild", 10, 10, foreign_cache_guid(),
+                                   "-3");
   mock_server_->AddUpdateDirectory(5, 4, "gggchild", 10, 10,
                                    foreign_cache_guid(), "-5");
-  mock_server_->AddUpdateDirectory(2, 1, "child", 10, 10,
-                                   foreign_cache_guid(), "-2");
-  mock_server_->AddUpdateDirectory(1, 0, "parent", 10, 10,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(2, 1, "child", 10, 10, foreign_cache_guid(),
+                                   "-2");
+  mock_server_->AddUpdateDirectory(1, 0, "parent", 10, 10, foreign_cache_guid(),
+                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   syncable::ReadTransaction trans(FROM_HERE, directory());
 
-  Id child_id = GetOnlyEntryWithName(
-        &trans, ids_.FromNumber(4), "gggchild");
+  Id child_id = GetOnlyEntryWithName(&trans, ids_.FromNumber(4), "gggchild");
   Entry child(&trans, GET_BY_ID, child_id);
   ASSERT_TRUE(child.good());
 }
 
 class EntryCreatedInNewFolderTest : public SyncerTest {
  public:
   void CreateFolderInBob() {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry bob(&trans,
-                     syncable::GET_BY_ID,
-                     GetOnlyEntryWithName(&trans,
-                                          TestIdFactory::root(),
-                                          "bob"));
+    MutableEntry bob(
+        &trans, syncable::GET_BY_ID,
+        GetOnlyEntryWithName(&trans, TestIdFactory::root(), "bob"));
     ASSERT_TRUE(bob.good());
 
-    MutableEntry entry2(
-        &trans, CREATE, BOOKMARKS, bob.GetId(), "bob");
+    MutableEntry entry2(&trans, CREATE, BOOKMARKS, bob.GetId(), "bob");
     ASSERT_TRUE(entry2.good());
     entry2.PutIsDir(true);
     entry2.PutIsUnsynced(true);
     entry2.PutSpecifics(DefaultBookmarkSpecifics());
   }
 };
 
 TEST_F(EntryCreatedInNewFolderTest, EntryCreatedInNewFolderMidSync) {
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "bob");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(true);
     entry.PutIsUnsynced(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
   }
 
-  mock_server_->SetMidCommitCallback(
-      base::Bind(&EntryCreatedInNewFolderTest::CreateFolderInBob,
-                 base::Unretained(this)));
+  mock_server_->SetMidCommitCallback(base::Bind(
+      &EntryCreatedInNewFolderTest::CreateFolderInBob, base::Unretained(this)));
   EXPECT_TRUE(SyncShareNudge());
   // We loop until no unsynced handles remain, so we will commit both ids.
   EXPECT_EQ(2u, mock_server_->committed_ids().size());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
-    Entry parent_entry(&trans, syncable::GET_BY_ID,
+    Entry parent_entry(
+        &trans, syncable::GET_BY_ID,
         GetOnlyEntryWithName(&trans, TestIdFactory::root(), "bob"));
     ASSERT_TRUE(parent_entry.good());
 
-    Id child_id =
-        GetOnlyEntryWithName(&trans, parent_entry.GetId(), "bob");
+    Id child_id = GetOnlyEntryWithName(&trans, parent_entry.GetId(), "bob");
     Entry child(&trans, syncable::GET_BY_ID, child_id);
     ASSERT_TRUE(child.good());
     EXPECT_EQ(parent_entry.GetId(), child.GetParentId());
   }
 }
 
 TEST_F(SyncerTest, NegativeIDInUpdate) {
-  mock_server_->AddUpdateBookmark(-10, 0, "bad", 40, 40,
-                                  foreign_cache_guid(), "-100");
+  mock_server_->AddUpdateBookmark(-10, 0, "bad", 40, 40, foreign_cache_guid(),
+                                  "-100");
   EXPECT_TRUE(SyncShareNudge());
   // The negative id would make us CHECK!
 }
 
 TEST_F(SyncerTest, UnappliedUpdateOnCreatedItemItemDoesNotCrash) {
   int64_t metahandle_fred;
   syncable::Id orig_id;
   {
     // Create an item.
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
@@ skipping 10 matching lines @@
   mock_server_->set_conflict_all_commits(true);
   syncable::Id fred_match_id;
   {
     // Now receive a change from outside.
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry fred_match(&trans, GET_BY_HANDLE, metahandle_fred);
     ASSERT_TRUE(fred_match.good());
     EXPECT_TRUE(fred_match.GetId().ServerKnows());
     fred_match_id = fred_match.GetId();
     mock_server_->AddUpdateBookmark(fred_match_id, trans.root_id(),
-        "fred_match", 40, 40, local_cache_guid(), orig_id.GetServerId());
+                                    "fred_match", 40, 40, local_cache_guid(),
+                                    orig_id.GetServerId());
   }
   // Run the syncer.
-  for (int i = 0 ; i < 30 ; ++i) {
+  for (int i = 0; i < 30; ++i) {
     EXPECT_TRUE(SyncShareNudge());
   }
 }
 
 /**
  * In the event that we have a double changed entry, that is changed on both
  * the client and the server, the conflict resolver should just drop one of
  * them and accept the other.
  */
 
@@ skipping 432 matching lines @@
   EXPECT_TRUE(SyncShareNudge());
   // Since the hierarchy isn't really changed (the type has flat hierarchy)
   // this conflict must be discarded.
   EXPECT_EQ(0, session_->status_controller().num_local_overwrites());
   EXPECT_EQ(0, session_->status_controller().num_server_overwrites());
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   int64_t newfolder_metahandle;
 
-  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10, foreign_cache_guid(),
+                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry newfolder(
-        &trans, CREATE, BOOKMARKS, ids_.FromNumber(1), "local");
+    MutableEntry newfolder(&trans, CREATE, BOOKMARKS, ids_.FromNumber(1),
+                           "local");
     ASSERT_TRUE(newfolder.good());
     newfolder.PutIsUnsynced(true);
     newfolder.PutIsDir(true);
     newfolder.PutSpecifics(DefaultBookmarkSpecifics());
     newfolder_metahandle = newfolder.GetMetahandle();
   }
-  mock_server_->AddUpdateDirectory(1, 0, "bob", 2, 20,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "bob", 2, 20, foreign_cache_guid(),
+                                   "-1");
   mock_server_->SetLastUpdateDeleted();
   SyncShareConfigure();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, syncable::GET_BY_HANDLE, newfolder_metahandle);
     ASSERT_TRUE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, FolderSwapUpdate) {
-  mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10,
-                                   foreign_cache_guid(), "-7801");
-  mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10,
-                                   foreign_cache_guid(), "-1024");
+  mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10, foreign_cache_guid(),
+                                   "-7801");
+  mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10, foreign_cache_guid(),
+                                   "-1024");
   EXPECT_TRUE(SyncShareNudge());
-  mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20,
-                                   foreign_cache_guid(), "-1024");
-  mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20,
-                                   foreign_cache_guid(), "-7801");
+  mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20, foreign_cache_guid(),
+                                   "-1024");
+  mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20, foreign_cache_guid(),
+                                   "-7801");
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_EQ("fred", id1.GetNonUniqueName());
     EXPECT_EQ(root_id_, id1.GetParentId());
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_EQ("bob", id2.GetNonUniqueName());
     EXPECT_EQ(root_id_, id2.GetParentId());
   }
 }
 
 TEST_F(SyncerTest, NameCollidingFolderSwapWorksFine) {
-  mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10,
-                                   foreign_cache_guid(), "-7801");
-  mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10,
-                                   foreign_cache_guid(), "-1024");
+  mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10, foreign_cache_guid(),
+                                   "-7801");
+  mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10, foreign_cache_guid(),
+                                   "-1024");
   mock_server_->AddUpdateDirectory(4096, 0, "alice", 1, 10,
                                    foreign_cache_guid(), "-4096");
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_EQ("bob", id1.GetNonUniqueName());
     EXPECT_EQ(root_id_, id1.GetParentId());
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_EQ("fred", id2.GetNonUniqueName());
     EXPECT_EQ(root_id_, id2.GetParentId());
     Entry id3(&trans, GET_BY_ID, ids_.FromNumber(4096));
     ASSERT_TRUE(id3.good());
     EXPECT_EQ("alice", id3.GetNonUniqueName());
     EXPECT_EQ(root_id_, id3.GetParentId());
   }
-  mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20,
-                                   foreign_cache_guid(), "-1024");
-  mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20,
-                                   foreign_cache_guid(), "-7801");
-  mock_server_->AddUpdateDirectory(4096, 0, "bob", 2, 20,
-                                   foreign_cache_guid(), "-4096");
+  mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20, foreign_cache_guid(),
+                                   "-1024");
+  mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20, foreign_cache_guid(),
+                                   "-7801");
+  mock_server_->AddUpdateDirectory(4096, 0, "bob", 2, 20, foreign_cache_guid(),
+                                   "-4096");
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_EQ("fred", id1.GetNonUniqueName());
     EXPECT_EQ(root_id_, id1.GetParentId());
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_EQ("bob", id2.GetNonUniqueName());
@@ skipping 235 matching lines @@
   int item_count = 300;  // We should be able to do 300 or 3000 w/o issue.
 
   syncable::Id parent_id = ids_.NewServerId();
   syncable::Id last_id = parent_id;
   vector<syncable::Id> tree_ids;
 
   // Create a lot of updates for which the parent does not exist yet.
   // Generate a huge deep tree which should all fail to apply at first.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    for (int i = 0; i < item_count ; i++) {
+    for (int i = 0; i < item_count; i++) {
       syncable::Id next_id = ids_.NewServerId();
       syncable::Id local_id = ids_.NewLocalId();
       tree_ids.push_back(next_id);
       mock_server_->AddUpdateDirectory(next_id, last_id, "BOB", 2, 20,
                                        foreign_cache_guid(),
                                        local_id.GetServerId());
       last_id = next_id;
     }
   }
   EXPECT_TRUE(SyncShareNudge());
 
   // Check they're in the expected conflict state.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     for (int i = 0; i < item_count; i++) {
       Entry e(&trans, GET_BY_ID, tree_ids[i]);
       // They should all exist but none should be applied.
       ASSERT_TRUE(e.good());
       EXPECT_TRUE(e.GetIsDel());
       EXPECT_TRUE(e.GetIsUnappliedUpdate());
     }
   }
 
   // Add the missing parent directory.
-  mock_server_->AddUpdateDirectory(parent_id, TestIdFactory::root(),
-      "BOB", 2, 20, foreign_cache_guid(), "-3500");
+  mock_server_->AddUpdateDirectory(parent_id, TestIdFactory::root(), "BOB", 2,
+                                   20, foreign_cache_guid(), "-3500");
   EXPECT_TRUE(SyncShareNudge());
 
   // Now they should all be OK.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     for (int i = 0; i < item_count; i++) {
       Entry e(&trans, GET_BY_ID, tree_ids[i]);
       ASSERT_TRUE(e.good());
       EXPECT_FALSE(e.GetIsDel());
       EXPECT_FALSE(e.GetIsUnappliedUpdate());
     }
   }
 }
 
 TEST_F(SyncerTest, DontCrashOnCaseChange) {
-  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10, foreign_cache_guid(),
+                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry e(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(e.good());
     e.PutIsUnsynced(true);
   }
   mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateDirectory(1, 0, "BOB", 2, 20,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "BOB", 2, 20, foreign_cache_guid(),
+                                   "-1");
   EXPECT_FALSE(SyncShareNudge());  // USED TO CAUSE AN ASSERT
 }
 
 TEST_F(SyncerTest, UnsyncedItemAndUpdate) {
-  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10, foreign_cache_guid(),
+                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateDirectory(2, 0, "bob", 2, 20,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(2, 0, "bob", 2, 20, foreign_cache_guid(),
+                                   "-2");
   EXPECT_TRUE(SyncShareNudge());  // USED TO CAUSE AN ASSERT
 }
 
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath) {
-  mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10, foreign_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   int64_t local_folder_handle;
   syncable::Id local_folder_id;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry new_entry(
-        &wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Bar.htm");
+    MutableEntry new_entry(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
+                           "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.GetId();
     local_folder_handle = new_entry.GetMetahandle();
     new_entry.PutIsUnsynced(true);
     new_entry.PutSpecifics(DefaultBookmarkSpecifics());
     MutableEntry old(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(old.good());
     WriteTestDataToEntry(&wtrans, &old);
   }
-  mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20, foreign_cache_guid(),
+                                  "-1");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_FALSE(SyncShareNudge());
   {
     // Update #20 should have been dropped in favor of the local version.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_NE(local.GetMetahandle(), server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_TRUE(server.GetIsUnsynced());
     EXPECT_TRUE(local.GetIsUnsynced());
     EXPECT_EQ("Foo.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
   }
   // Allow local changes to commit.
   mock_server_->set_conflict_all_commits(false);
   EXPECT_TRUE(SyncShareNudge());
 
   // Now add a server change to make the two names equal.  There should
   // be no conflict with that, since names are not unique.
-  mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30, foreign_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_NE(local.GetMetahandle(), server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_FALSE(server.GetIsUnsynced());
     EXPECT_FALSE(local.GetIsUnsynced());
     EXPECT_EQ("Bar.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
-        server.GetSpecifics().bookmark().url());
+              server.GetSpecifics().bookmark().url());
   }
 }
 
 // Same as NewEntryAnddServerEntrySharePath, but using the old-style protocol.
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath_OldBookmarksProto) {
   mock_server_->set_use_legacy_bookmarks_protocol(true);
-  mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10, foreign_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   int64_t local_folder_handle;
   syncable::Id local_folder_id;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry new_entry(
-        &wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Bar.htm");
+    MutableEntry new_entry(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
+                           "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.GetId();
     local_folder_handle = new_entry.GetMetahandle();
     new_entry.PutIsUnsynced(true);
     new_entry.PutSpecifics(DefaultBookmarkSpecifics());
     MutableEntry old(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(old.good());
     WriteTestDataToEntry(&wtrans, &old);
   }
-  mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20, foreign_cache_guid(),
+                                  "-1");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_FALSE(SyncShareNudge());
   {
     // Update #20 should have been dropped in favor of the local version.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_NE(local.GetMetahandle(), server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_TRUE(server.GetIsUnsynced());
     EXPECT_TRUE(local.GetIsUnsynced());
     EXPECT_EQ("Foo.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
   }
   // Allow local changes to commit.
   mock_server_->set_conflict_all_commits(false);
   EXPECT_TRUE(SyncShareNudge());
 
   // Now add a server change to make the two names equal.  There should
   // be no conflict with that, since names are not unique.
-  mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30, foreign_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_NE(local.GetMetahandle(), server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_FALSE(server.GetIsUnsynced());
     EXPECT_FALSE(local.GetIsUnsynced());
     EXPECT_EQ("Bar.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
-        server.GetSpecifics().bookmark().url());
+              server.GetSpecifics().bookmark().url());
   }
 }
 
 // Circular links should be resolved by the server.
 TEST_F(SyncerTest, SiblingDirectoriesBecomeCircular) {
   // we don't currently resolve this. This test ensures we don't.
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
+                                   "-1");
+  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10, foreign_cache_guid(),
+                                   "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutParentId(ids_.FromNumber(2));
     A.PutNonUniqueName("B");
   }
-  mock_server_->AddUpdateDirectory(2, 1, "A", 20, 20,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(2, 1, "A", 20, 20, foreign_cache_guid(),
+                                   "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_FALSE(SyncShareNudge());
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_EQ("B", A.GetNonUniqueName());
     EXPECT_EQ("B", B.GetNonUniqueName());
   }
 }
 
 TEST_F(SyncerTest, SwapEntryNames) {
   // Simple transaction test.
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
+                                   "-1");
+  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10, foreign_cache_guid(),
+                                   "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.PutIsUnsynced(true);
     A.PutNonUniqueName("C");
     B.PutNonUniqueName("A");
     A.PutNonUniqueName("B");
   }
   EXPECT_FALSE(SyncShareNudge());
 }
 
 TEST_F(SyncerTest, DualDeletionWithNewItemNameClash) {
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateBookmark(2, 0, "B", 10, 10,
-                                  foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
+                                   "-1");
+  mock_server_->AddUpdateBookmark(2, 0, "B", 10, 10, foreign_cache_guid(),
+                                  "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     WriteTestDataToEntry(&trans, &B);
     B.PutIsDel(true);
   }
-  mock_server_->AddUpdateBookmark(2, 0, "A", 11, 11,
-                                  foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateBookmark(2, 0, "A", 11, 11, foreign_cache_guid(),
+                                  "-2");
   mock_server_->SetLastUpdateDeleted();
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_FALSE(B.GetIsUnsynced());
     EXPECT_FALSE(B.GetIsUnappliedUpdate());
   }
 }
 
 // When we undelete an entity as a result of conflict resolution, we reuse the
 // existing server id and preserve the old version, simply updating the server
 // version with the new non-deleted entity.
 TEST_F(SyncerTest, ResolveWeWroteTheyDeleted) {
   int64_t bob_metahandle;
 
-  mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10, foreign_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob_metahandle = bob.GetMetahandle();
     WriteTestDataToEntry(&trans, &bob);
   }
-  mock_server_->AddUpdateBookmark(1, 0, "bob", 2, 10,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "bob", 2, 10, foreign_cache_guid(),
+                                  "-1");
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   EXPECT_FALSE(SyncShareNudge());
   EXPECT_FALSE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry bob(&trans, GET_BY_HANDLE, bob_metahandle);
     ASSERT_TRUE(bob.good());
     EXPECT_TRUE(bob.GetIsUnsynced());
     EXPECT_TRUE(bob.GetId().ServerKnows());
@@ skipping 25 matching lines @@
   mock_server_->set_next_new_id(10000);
   EXPECT_EQ(1u, directory()->unsynced_entity_count());
   // we get back a bad id in here (should never happen).
   EXPECT_FALSE(SyncShareNudge());
   EXPECT_EQ(1u, directory()->unsynced_entity_count());
   EXPECT_TRUE(SyncShareNudge());  // another bad id in here.
   EXPECT_EQ(0u, directory()->unsynced_entity_count());
 }
 
 TEST_F(SyncerTest, DeletedEntryWithBadParentInLoopCalculation) {
-  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10, foreign_cache_guid(),
+                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     // This is valid, because the parent could have gone away a long time ago.
     bob.PutParentId(ids_.FromNumber(54));
     bob.PutIsDel(true);
     bob.PutIsUnsynced(true);
   }
-  mock_server_->AddUpdateDirectory(2, 1, "fred", 1, 10,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(2, 1, "fred", 1, 10, foreign_cache_guid(),
+                                   "-2");
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_TRUE(SyncShareNudge());
 }
 
 TEST_F(SyncerTest, ConflictResolverMergesLocalDeleteAndServerUpdate) {
   syncable::Id local_id;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 
-    MutableEntry local_deleted(
-        &trans, CREATE, BOOKMARKS, trans.root_id(), "name");
+    MutableEntry local_deleted(&trans, CREATE, BOOKMARKS, trans.root_id(),
+                               "name");
     local_id = local_deleted.GetId();
     local_deleted.PutId(ids_.FromNumber(1));
     local_deleted.PutBaseVersion(1);
     local_deleted.PutIsDel(true);
     local_deleted.PutIsDir(false);
     local_deleted.PutIsUnsynced(true);
     local_deleted.PutSpecifics(DefaultBookmarkSpecifics());
   }
 
   mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10,
-                                  local_cache_guid(),
-                                  local_id.GetServerId());
+                                  local_cache_guid(), local_id.GetServerId());
 
   // We don't care about actually committing, just the resolution.
   mock_server_->set_conflict_all_commits(true);
   EXPECT_FALSE(SyncShareNudge());
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry local_deleted(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_EQ(10, local_deleted.GetBaseVersion());
     EXPECT_FALSE(local_deleted.GetIsUnappliedUpdate());
     EXPECT_TRUE(local_deleted.GetIsUnsynced());
     EXPECT_TRUE(local_deleted.GetIsDel());
     EXPECT_FALSE(local_deleted.GetIsDir());
   }
 }
 
 // This ensures that for extensions, we resolve the conflict of local updates
 // and server deletes in favor of the server, to prevent extensions from
 // being reinstalled after uninstall.
 TEST_F(SyncerTest, ConflictResolverAcceptsServerDeleteForExtensions) {
   ASSERT_TRUE(context_->GetEnabledTypes().Has(EXTENSIONS));
 
   // Create an extension entry.
   int64_t metahandle;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry extension(
-        &trans, CREATE, EXTENSIONS, trans.root_id(), "extension_name");
+    MutableEntry extension(&trans, CREATE, EXTENSIONS, trans.root_id(),
+                           "extension_name");
     ASSERT_TRUE(extension.good());
     sync_pb::EntitySpecifics specifics;
     AddDefaultFieldValue(EXTENSIONS, &specifics);
     extension.PutSpecifics(specifics);
     EXPECT_FALSE(extension.GetIsUnappliedUpdate());
     EXPECT_FALSE(extension.GetId().ServerKnows());
     metahandle = extension.GetMetahandle();
     extension.PutIsUnsynced(true);
   }
 
   // Make sure the server has received the new item.
   SyncShareNudge();
   syncable::Id id;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle);
 
     EXPECT_EQ(metahandle, entry.GetMetahandle());
     EXPECT_FALSE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
     EXPECT_GE(entry.GetBaseVersion(), 0);
     EXPECT_EQ(entry.GetBaseVersion(), entry.GetServerVersion());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     id = entry.GetId();
   }
 
-
   // Simulate another client deleting the item.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle);
     mock_server_->AddUpdateTombstone(id, EXTENSIONS);
   }
 
   // Create a local update, which should cause a conflict with the delete that
   // we just pushed to the server.
   {
@@ skipping 23 matching lines @@
   }
 }
 
 // See what happens if the IS_DIR bit gets flipped.  This can cause us
 // all kinds of disasters.
 TEST_F(SyncerTest, UpdateFlipsTheFolderBit) {
   // Local object: a deleted directory (container), revision 1, unsynced.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 
-    MutableEntry local_deleted(
-        &trans, CREATE, BOOKMARKS, trans.root_id(), "name");
+    MutableEntry local_deleted(&trans, CREATE, BOOKMARKS, trans.root_id(),
+                               "name");
     local_deleted.PutId(ids_.FromNumber(1));
     local_deleted.PutBaseVersion(1);
     local_deleted.PutIsDel(true);
     local_deleted.PutIsDir(true);
     local_deleted.PutIsUnsynced(true);
     local_deleted.PutSpecifics(DefaultBookmarkSpecifics());
   }
 
   // Server update: entry-type object (not a container), revision 10.
   mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10,
@@ skipping 15 matching lines @@
     EXPECT_TRUE(local_deleted.GetIsDel());
     EXPECT_TRUE(local_deleted.GetIsDir());
   }
 }
 
 // Bug Synopsis:
 // Merge conflict resolution will merge a new local entry with another entry
 // that needs updates, resulting in CHECK.
 TEST_F(SyncerTest, MergingExistingItems) {
   mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10,
-                                  local_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10, local_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(
-        &trans, CREATE, BOOKMARKS, trans.root_id(), "Copy of base");
+    MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(),
+                       "Copy of base");
     WriteTestDataToEntry(&trans, &entry);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50,
                                   local_cache_guid(), "-1");
   EXPECT_FALSE(SyncShareNudge());
 }
 
 // In this test a long changelog contains a child at the start of the changelog
 // and a parent at the end. While these updates are in progress the client would
 // appear stuck.
 TEST_F(SyncerTest, LongChangelistWithApplicationConflict) {
   const int depth = 400;
   syncable::Id folder_id = ids_.FromNumber(1);
 
   // First we an item in a folder in the root. However the folder won't come
   // till much later.
   syncable::Id stuck_entry_id = TestIdFactory::FromNumber(99999);
-  mock_server_->AddUpdateDirectory(stuck_entry_id,
-      folder_id, "stuck", 1, 1,
-      foreign_cache_guid(), "-99999");
+  mock_server_->AddUpdateDirectory(stuck_entry_id, folder_id, "stuck", 1, 1,
+                                   foreign_cache_guid(), "-99999");
   mock_server_->SetChangesRemaining(depth - 1);
   EXPECT_TRUE(SyncShareNudge());
 
   // Buffer up a very long series of downloads.
   // We should never be stuck (conflict resolution shouldn't
   // kick in so long as we're making forward progress).
   for (int i = 0; i < depth; i++) {
     mock_server_->NextUpdateBatch();
     mock_server_->SetNewTimestamp(i + 1);
     mock_server_->SetChangesRemaining(depth - i);
   }
 
   EXPECT_TRUE(SyncShareNudge());
 
   // Ensure our folder hasn't somehow applied.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry child(&trans, GET_BY_ID, stuck_entry_id);
     EXPECT_TRUE(child.good());
     EXPECT_TRUE(child.GetIsUnappliedUpdate());
     EXPECT_TRUE(child.GetIsDel());
     EXPECT_FALSE(child.GetIsUnsynced());
   }
 
   // And finally the folder.
-  mock_server_->AddUpdateDirectory(folder_id,
-      TestIdFactory::root(), "folder", 1, 1,
-      foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(folder_id, TestIdFactory::root(), "folder",
+                                   1, 1, foreign_cache_guid(), "-1");
   mock_server_->SetChangesRemaining(0);
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_TRUE(SyncShareNudge());
   // Check that everything is as expected after the commit.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, folder_id);
     ASSERT_TRUE(entry.good());
     Entry child(&trans, GET_BY_ID, stuck_entry_id);
     EXPECT_EQ(entry.GetId(), child.GetParentId());
     EXPECT_EQ("stuck", child.GetNonUniqueName());
     EXPECT_TRUE(child.good());
   }
 }
 
 TEST_F(SyncerTest, DontMergeTwoExistingItems) {
   mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10,
-                                  foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateBookmark(2, 0, "base2", 10, 10,
-                                  foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10, foreign_cache_guid(),
+                                  "-1");
+  mock_server_->AddUpdateBookmark(2, 0, "base2", 10, 10, foreign_cache_guid(),
+                                  "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     entry.PutNonUniqueName("Copy of base");
     entry.PutIsUnsynced(true);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50,
                                   foreign_cache_guid(), "-1");
   EXPECT_FALSE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry1(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_FALSE(entry1.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry1.GetIsUnsynced());
     EXPECT_FALSE(entry1.GetIsDel());
     Entry entry2(&trans, GET_BY_ID, ids_.FromNumber(2));
     EXPECT_FALSE(entry2.GetIsUnappliedUpdate());
     EXPECT_TRUE(entry2.GetIsUnsynced());
     EXPECT_FALSE(entry2.GetIsDel());
     EXPECT_EQ(entry1.GetNonUniqueName(), entry2.GetNonUniqueName());
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteUpdate) {
   mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateDirectory(2, 1, "bar", 1, 2,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1, foreign_cache_guid(),
+                                   "-1");
+  mock_server_->AddUpdateDirectory(2, 1, "bar", 1, 2, foreign_cache_guid(),
+                                   "-2");
   EXPECT_TRUE(SyncShareNudge());
-  mock_server_->AddUpdateDirectory(2, 1, "bar", 2, 3,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(2, 1, "bar", 2, 3, foreign_cache_guid(),
+                                   "-2");
   mock_server_->SetLastUpdateDeleted();
   EXPECT_TRUE(SyncShareNudge());
 
   int64_t metahandle;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetIsDel());
     metahandle = entry.GetMetahandle();
   }
-  mock_server_->AddUpdateDirectory(1, 0, "foo", 2, 4,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "foo", 2, 4, foreign_cache_guid(),
+                                   "-1");
   mock_server_->SetLastUpdateDeleted();
   EXPECT_TRUE(SyncShareNudge());
   // This used to be rejected as it's an undeletion. Now, it results in moving
   // the delete path aside.
-  mock_server_->AddUpdateDirectory(2, 1, "bar", 3, 5,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(2, 1, "bar", 3, 5, foreign_cache_guid(),
+                                   "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
     EXPECT_TRUE(entry.GetIsUnappliedUpdate());
     EXPECT_NE(metahandle, entry.GetMetahandle());
   }
 }
 
 TEST_F(SyncerTest, TestMoveSanitizedNamedFolder) {
-  mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateDirectory(2, 0, ":::", 1, 2,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1, foreign_cache_guid(),
+                                   "-1");
+  mock_server_->AddUpdateDirectory(2, 0, ":::", 1, 2, foreign_cache_guid(),
+                                   "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     entry.PutParentId(ids_.FromNumber(1));
     EXPECT_TRUE(entry.PutIsUnsynced(true));
   }
   EXPECT_TRUE(SyncShareNudge());
   // We use the same sync ts as before so our times match up.
-  mock_server_->AddUpdateDirectory(2, 1, ":::", 2, 2,
-                                   foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateDirectory(2, 1, ":::", 2, 2, foreign_cache_guid(),
+                                   "-2");
   EXPECT_TRUE(SyncShareNudge());
 }
 
 // Don't crash when this occurs.
 TEST_F(SyncerTest, UpdateWhereParentIsNotAFolder) {
-  mock_server_->AddUpdateBookmark(1, 0, "B", 10, 10,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(1, 0, "B", 10, 10, foreign_cache_guid(),
+                                  "-1");
   mock_server_->AddUpdateDirectory(2, 1, "BookmarkParent", 10, 10,
                                    foreign_cache_guid(), "-2");
   // Used to cause a CHECK
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     Entry good_entry(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(good_entry.good());
     EXPECT_FALSE(good_entry.GetIsUnappliedUpdate());
     Entry bad_parent(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(bad_parent.good());
     EXPECT_TRUE(bad_parent.GetIsUnappliedUpdate());
   }
 }
 
 TEST_F(SyncerTest, DirectoryUpdateTest) {
   Id in_root_id = ids_.NewServerId();
   Id in_in_root_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(in_root_id, TestIdFactory::root(),
-                                   "in_root_name", 2, 2,
-                                   foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateDirectory(in_in_root_id, in_root_id,
-                                   "in_in_root_name", 3, 3,
-                                   foreign_cache_guid(), "-2");
+                                   "in_root_name", 2, 2, foreign_cache_guid(),
+                                   "-1");
+  mock_server_->AddUpdateDirectory(in_in_root_id, in_root_id, "in_in_root_name",
+                                   3, 3, foreign_cache_guid(), "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry in_root(&trans, GET_BY_ID, in_root_id);
     ASSERT_TRUE(in_root.good());
     EXPECT_EQ("in_root_name", in_root.GetNonUniqueName());
     EXPECT_EQ(TestIdFactory::root(), in_root.GetParentId());
 
     Entry in_in_root(&trans, GET_BY_ID, in_in_root_id);
     ASSERT_TRUE(in_in_root.good());
@@ skipping 50 matching lines @@
   ClientCommand* command = new ClientCommand();
   command->set_set_sync_poll_interval(8);
   command->set_set_sync_long_poll_interval(800);
   command->set_sessions_commit_delay_seconds(3141);
   sync_pb::CustomNudgeDelay* bookmark_delay =
       command->add_custom_nudge_delays();
   bookmark_delay->set_datatype_id(
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(950);
   command->set_client_invalidation_hint_buffer_size(11);
-  mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1,
-                                   foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1, foreign_cache_guid(),
+                                   "-1");
   mock_server_->SetGUClientCommand(command);
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(TimeDelta::FromSeconds(8), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(800), last_long_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(3141), last_sessions_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(950), last_bookmarks_commit_delay_);
   EXPECT_EQ(11, last_client_invalidation_hint_buffer_size_);
 
   command = new ClientCommand();
   command->set_set_sync_poll_interval(180);
   command->set_set_sync_long_poll_interval(190);
   command->set_sessions_commit_delay_seconds(2718);
   bookmark_delay = command->add_custom_nudge_delays();
   bookmark_delay->set_datatype_id(
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(1050);
   command->set_client_invalidation_hint_buffer_size(9);
-  mock_server_->AddUpdateDirectory(
-      1, 0, "in_root", 1, 1, foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1, foreign_cache_guid(),
+                                   "-1");
   mock_server_->SetGUClientCommand(command);
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(TimeDelta::FromSeconds(180), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(190), last_long_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(2718), last_sessions_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(1050), last_bookmarks_commit_delay_);
   EXPECT_EQ(9, last_client_invalidation_hint_buffer_size_);
 }
 
@@ skipping 38 matching lines @@
   EXPECT_EQ(TimeDelta::FromSeconds(2718), last_sessions_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(1050), last_bookmarks_commit_delay_);
   EXPECT_EQ(9, last_client_invalidation_hint_buffer_size_);
 }
 
 TEST_F(SyncerTest, EnsureWeSendUpOldParent) {
   syncable::Id folder_one_id = ids_.FromNumber(1);
   syncable::Id folder_two_id = ids_.FromNumber(2);
 
   mock_server_->AddUpdateDirectory(folder_one_id, TestIdFactory::root(),
-      "folder_one", 1, 1, foreign_cache_guid(), "-1");
+                                   "folder_one", 1, 1, foreign_cache_guid(),
+                                   "-1");
   mock_server_->AddUpdateDirectory(folder_two_id, TestIdFactory::root(),
-      "folder_two", 1, 1, foreign_cache_guid(), "-2");
+                                   "folder_two", 1, 1, foreign_cache_guid(),
+                                   "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
     // A moved entry should send an "old parent."
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, folder_one_id);
     ASSERT_TRUE(entry.good());
     entry.PutParentId(folder_two_id);
     entry.PutIsUnsynced(true);
     // A new entry should send no "old parent."
-    MutableEntry create(
-        &trans, CREATE, BOOKMARKS, trans.root_id(), "new_folder");
+    MutableEntry create(&trans, CREATE, BOOKMARKS, trans.root_id(),
+                        "new_folder");
     create.PutIsUnsynced(true);
     create.PutSpecifics(DefaultBookmarkSpecifics());
   }
   EXPECT_TRUE(SyncShareNudge());
   const sync_pb::CommitMessage& commit = mock_server_->last_sent_commit();
   ASSERT_EQ(2, commit.entries_size());
   EXPECT_EQ("2", commit.entries(0).parent_id_string());
   EXPECT_EQ("0", commit.entries(0).old_parent_id());
   EXPECT_FALSE(commit.entries(1).has_old_parent_id());
 }
@@ skipping 17 matching lines @@
   syncable::ReadTransaction rtrans(FROM_HERE, directory());
   Entry entry(&rtrans, syncable::GET_BY_HANDLE, item_metahandle);
   ASSERT_TRUE(entry.good());
   EXPECT_EQ(really_big_int, entry.GetBaseVersion());
 }
 
 TEST_F(SyncerTest, TestSimpleUndelete) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   mock_server_->set_conflict_all_commits(true);
   // Let there be an entry from the server.
-  mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10, foreign_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   // Check it out and delete it.
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     // Delete it locally.
     entry.PutIsDel(true);
   }
   EXPECT_TRUE(SyncShareNudge());
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
   }
   EXPECT_TRUE(SyncShareNudge());
   // Update from server confirming deletion.
-  mock_server_->AddUpdateBookmark(id, root, "foo", 2, 11,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(id, root, "foo", 2, 11, foreign_cache_guid(),
+                                  "-1");
   mock_server_->SetLastUpdateDeleted();
   EXPECT_TRUE(SyncShareNudge());
   // IS_DEL AND SERVER_IS_DEL now both true.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_TRUE(entry.GetServerIsDel());
   }
   // Undelete from server.
-  mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12, foreign_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   // IS_DEL and SERVER_IS_DEL now both false.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteWithMissingDeleteUpdate) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   // Let there be a entry, from the server.
   mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10, foreign_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   // Check it out and delete it.
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     // Delete it locally.
     entry.PutIsDel(true);
   }
   EXPECT_TRUE(SyncShareNudge());
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
   }
   EXPECT_TRUE(SyncShareNudge());
   // Say we do not get an update from server confirming deletion. Undelete
   // from server
-  mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12,
-                                  foreign_cache_guid(), "-1");
+  mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12, foreign_cache_guid(),
+                                  "-1");
   EXPECT_TRUE(SyncShareNudge());
   // IS_DEL and SERVER_IS_DEL now both false.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteIgnoreCorrectlyUnappliedUpdate) {
   Id id1 = ids_.MakeServer("first"), id2 = ids_.MakeServer("second");
   Id root = TestIdFactory::root();
   // Duplicate! expect path clashing!
   mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateBookmark(id1, root, "foo", 1, 10,
-                                  foreign_cache_guid(), "-1");
-  mock_server_->AddUpdateBookmark(id2, root, "foo", 1, 10,
-                                  foreign_cache_guid(), "-2");
+  mock_server_->AddUpdateBookmark(id1, root, "foo", 1, 10, foreign_cache_guid(),
+                                  "-1");
+  mock_server_->AddUpdateBookmark(id2, root, "foo", 1, 10, foreign_cache_guid(),
+                                  "-2");
   EXPECT_TRUE(SyncShareNudge());
   mock_server_->AddUpdateBookmark(id2, root, "foo2", 2, 20,
                                   foreign_cache_guid(), "-2");
   EXPECT_TRUE(SyncShareNudge());  // Now just don't explode.
 }
 
 TEST_F(SyncerTest, ClientTagServerCreatedUpdatesWork) {
   mock_server_->AddUpdateDirectory(1, 0, "permitem1", 1, 10,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateClientTag("permfolder");
@@ skipping 67 matching lines @@
     EXPECT_FALSE(perm_folder.GetIsUnsynced());
     EXPECT_EQ("permitem1", perm_folder.GetNonUniqueName());
   }
 }
 
 TEST_F(SyncerTest, ClientTagUncommittedTagMatchesUpdate) {
   int64_t original_metahandle = 0;
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry pref(
-        &trans, CREATE, PREFERENCES, ids_.root(), "name");
+    MutableEntry pref(&trans, CREATE, PREFERENCES, ids_.root(), "name");
     ASSERT_TRUE(pref.good());
     pref.PutUniqueClientTag("tag");
     pref.PutIsUnsynced(true);
     EXPECT_FALSE(pref.GetIsUnappliedUpdate());
     EXPECT_FALSE(pref.GetId().ServerKnows());
     original_metahandle = pref.GetMetahandle();
   }
 
   syncable::Id server_id = TestIdFactory::MakeServer("id");
   mock_server_->AddUpdatePref(server_id.GetServerId(),
-                              ids_.root().GetServerId(),
-                              "tag", 10, 100);
+                              ids_.root().GetServerId(), "tag", 10, 100);
   mock_server_->set_conflict_all_commits(true);
 
   EXPECT_FALSE(SyncShareNudge());
   // This should cause client tag reunion, preserving the metahandle.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry pref(&trans, GET_BY_CLIENT_TAG, "tag");
     ASSERT_TRUE(pref.good());
     EXPECT_FALSE(pref.GetIsDel());
@@ skipping 25 matching lines @@
     EXPECT_EQ(original_metahandle, pref.GetMetahandle());
     EXPECT_EQ("tag", pref.GetUniqueClientTag());
     EXPECT_TRUE(pref.GetId().ServerKnows());
   }
 }
 
 TEST_F(SyncerTest, ClientTagConflictWithDeletedLocalEntry) {
   {
     // Create a deleted local entry with a unique client tag.
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry pref(
-        &trans, CREATE, PREFERENCES, ids_.root(), "name");
+    MutableEntry pref(&trans, CREATE, PREFERENCES, ids_.root(), "name");
     ASSERT_TRUE(pref.good());
     ASSERT_FALSE(pref.GetId().ServerKnows());
     pref.PutUniqueClientTag("tag");
     pref.PutIsUnsynced(true);
 
     // Note: IS_DEL && !ServerKnows() will clear the UNSYNCED bit.
     // (We never attempt to commit server-unknown deleted items, so this
     // helps us clean up those entries).
     pref.PutIsDel(true);
   }
 
   // Prepare an update with the same unique client tag.
   syncable::Id server_id = TestIdFactory::MakeServer("id");
   mock_server_->AddUpdatePref(server_id.GetServerId(),
-                              ids_.root().GetServerId(),
-                              "tag", 10, 100);
+                              ids_.root().GetServerId(), "tag", 10, 100);
 
   EXPECT_TRUE(SyncShareNudge());
   // The local entry will be overwritten.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry pref(&trans, GET_BY_CLIENT_TAG, "tag");
     ASSERT_TRUE(pref.good());
     ASSERT_TRUE(pref.GetId().ServerKnows());
     EXPECT_FALSE(pref.GetIsDel());
@@ skipping 261 matching lines @@
     ASSERT_EQ("bob", hurdle.GetNonUniqueName());
 
     // Try to lookup by the tagname.  These should fail.
     Entry tag_alpha(&trans, GET_BY_SERVER_TAG, "alpha");
     EXPECT_FALSE(tag_alpha.good());
     Entry tag_bob(&trans, GET_BY_SERVER_TAG, "bob");
     EXPECT_FALSE(tag_bob.good());
   }
 
   // Now download some tagged items as updates.
-  mock_server_->AddUpdateDirectory(
-      1, 0, "update1", 1, 10, std::string(), std::string());
+  mock_server_->AddUpdateDirectory(1, 0, "update1", 1, 10, std::string(),
+                                   std::string());
   mock_server_->SetLastUpdateServerTag("alpha");
-  mock_server_->AddUpdateDirectory(
-      2, 0, "update2", 2, 20, std::string(), std::string());
+  mock_server_->AddUpdateDirectory(2, 0, "update2", 2, 20, std::string(),
+                                   std::string());
   mock_server_->SetLastUpdateServerTag("bob");
   EXPECT_TRUE(SyncShareNudge());
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     // The new items should be applied as new entries, and we should be able
     // to look them up by their tag values.
     Entry tag_alpha(&trans, GET_BY_SERVER_TAG, "alpha");
     ASSERT_TRUE(tag_alpha.good());
@@ skipping 223 matching lines @@
   }
 
   EXPECT_TRUE(directory()->InitialSyncEndedForType(PREFERENCES));
 }
 
 // Tests specifically related to bookmark (and therefore no client tags) sync
 // logic. Entities without client tags have custom logic in parts of the code,
 // and hence are not covered by e.g. the Undeletion tests below.
 class SyncerBookmarksTest : public SyncerTest {
  public:
-  SyncerBookmarksTest() : metahandle_(syncable::kInvalidMetaHandle) {
-  }
+  SyncerBookmarksTest() : metahandle_(syncable::kInvalidMetaHandle) {}
 
   void Create() {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry bookmark(
-        &trans, CREATE, BOOKMARKS, ids_.root(), "clientname");
+    MutableEntry bookmark(&trans, CREATE, BOOKMARKS, ids_.root(), "clientname");
     ASSERT_TRUE(bookmark.good());
     bookmark.PutSpecifics(DefaultBookmarkSpecifics());
     EXPECT_FALSE(bookmark.GetIsUnappliedUpdate());
     EXPECT_FALSE(bookmark.GetId().ServerKnows());
     metahandle_ = bookmark.GetMetahandle();
     local_id_ = bookmark.GetId();
     bookmark.PutIsUnsynced(true);
   }
 
   void Update() {
@@ skipping 232 matching lines @@
 //     C. Delete - undelete - commit - commitresponse.
 //     D. Delete - undelete - commit - commitresponse - getupdates.
 //   Exercised by UndeleteAfterCommit:
 //     E. Delete - commit - commitresponse - undelete - commit
 //        - commitresponse.
 //     F. Delete - commit - commitresponse - undelete - commit -
 //        - commitresponse - getupdates.
 class SyncerUndeletionTest : public SyncerTest {
  public:
   SyncerUndeletionTest()
-      : client_tag_("foobar"),
-        metahandle_(syncable::kInvalidMetaHandle) {
-  }
+      : client_tag_("foobar"), metahandle_(syncable::kInvalidMetaHandle) {}
 
   void Create() {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry perm_folder(
-        &trans, CREATE, PREFERENCES, ids_.root(), "clientname");
+    MutableEntry perm_folder(&trans, CREATE, PREFERENCES, ids_.root(),
+                             "clientname");
     ASSERT_TRUE(perm_folder.good());
     perm_folder.PutUniqueClientTag(client_tag_);
     perm_folder.PutIsUnsynced(true);
     if (perm_folder.GetSyncing())
       perm_folder.PutDirtySync(true);
     perm_folder.PutSpecifics(DefaultPreferencesSpecifics());
     EXPECT_FALSE(perm_folder.GetIsUnappliedUpdate());
     EXPECT_FALSE(perm_folder.GetId().ServerKnows());
     metahandle_ = perm_folder.GetMetahandle();
     local_id_ = perm_folder.GetId();
@@ skipping 410 matching lines @@
   mock_server_->AddUpdateFromLastCommit();
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Some other client undeletes the item.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
-    mock_server_->AddUpdatePref(
-        entry.GetId().GetServerId(),
-        entry.GetParentId().GetServerId(),
-        client_tag_, 100, 1000);
+    mock_server_->AddUpdatePref(entry.GetId().GetServerId(),
+                                entry.GetParentId().GetServerId(), client_tag_,
+                                100, 1000);
   }
   mock_server_->SetLastUpdateClientTag(client_tag_);
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, OtherClientUndeletesImmediately) {
   Create();
@@ skipping 25 matching lines @@
   // The update ought to have applied successfully.
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Some other client undeletes before we see the update from our
   // commit.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
-    mock_server_->AddUpdatePref(
-        entry.GetId().GetServerId(),
-        entry.GetParentId().GetServerId(),
-        client_tag_, 100, 1000);
+    mock_server_->AddUpdatePref(entry.GetId().GetServerId(),
+                                entry.GetParentId().GetServerId(), client_tag_,
+                                100, 1000);
   }
   mock_server_->SetLastUpdateClientTag(client_tag_);
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 enum {
   TEST_PARAM_BOOKMARK_ENABLE_BIT,
   TEST_PARAM_AUTOFILL_ENABLE_BIT,
   TEST_PARAM_BIT_COUNT
 };
 
-class MixedResult :
-    public SyncerTest,
-    public ::testing::WithParamInterface<int> {
+class MixedResult : public SyncerTest,
+                    public ::testing::WithParamInterface<int> {
  protected:
   bool ShouldFailBookmarkCommit() {
     return (GetParam() & (1 << TEST_PARAM_BOOKMARK_ENABLE_BIT)) == 0;
   }
   bool ShouldFailAutofillCommit() {
     return (GetParam() & (1 << TEST_PARAM_AUTOFILL_ENABLE_BIT)) == 0;
   }
 };
 
 INSTANTIATE_TEST_CASE_P(ExtensionsActivity,
                         MixedResult,
                         testing::Range(0, 1 << TEST_PARAM_BIT_COUNT));
 
 TEST_P(MixedResult, ExtensionsActivity) {
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry pref(&wtrans, CREATE, PREFERENCES, wtrans.root_id(), "pref");
     ASSERT_TRUE(pref.good());
     pref.PutIsUnsynced(true);
 
-    MutableEntry bookmark(
-        &wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "bookmark");
+    MutableEntry bookmark(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
+                          "bookmark");
     ASSERT_TRUE(bookmark.good());
     bookmark.PutIsUnsynced(true);
 
     if (ShouldFailBookmarkCommit()) {
       mock_server_->SetTransientErrorId(bookmark.GetId());
     }
 
     if (ShouldFailAutofillCommit()) {
       mock_server_->SetTransientErrorId(pref.GetId());
     }
@@ skipping 13 matching lines @@
             SyncShareNudge());
 
   ExtensionsActivity::Records final_monitor_records;
   context_->extensions_activity()->GetAndClearRecords(&final_monitor_records);
   if (ShouldFailBookmarkCommit()) {
     ASSERT_EQ(2U, final_monitor_records.size())
         << "Should restore records after unsuccessful bookmark commit.";
     EXPECT_EQ("ABC", final_monitor_records["ABC"].extension_id);
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
-    EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
+    EXPECT_EQ(4U, final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer