[Sync] Move ModelType and related classes to 'syncer' namespace

sync/engine/syncer_unittest.cc

 // Copyright (c) 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 <algorithm>
 #include <limits>
 #include <list>
@@ skipping 135 matching lines @@
       const sessions::SyncSessionSnapshot& snapshot) OVERRIDE {
   }
 
   void GetWorkers(std::vector<ModelSafeWorker*>* out) {
     out->push_back(worker_.get());
   }
 
   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 (syncable::ModelTypeSet::Iterator it = enabled_datatypes_.First();
+    for (syncer::ModelTypeSet::Iterator it = enabled_datatypes_.First();
          it.Good(); it.Inc()) {
       (*out)[it.Get()] = GROUP_PASSIVE;
     }
   }
 
   virtual void OnSyncEngineEvent(const SyncEngineEvent& 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 SyncEngineEvent::SYNC_CYCLE_BEGIN: // Fall through.
       case SyncEngineEvent::STATUS_CHANGED:
       case SyncEngineEvent::SYNC_CYCLE_ENDED:
         return;
       default:
         CHECK(false) << "Handling unknown error type in unit tests!!";
     }
     saw_syncer_event_ = true;
   }
 
   SyncSession* MakeSession() {
     ModelSafeRoutingInfo info;
     std::vector<ModelSafeWorker*> workers;
     GetModelSafeRoutingInfo(&info);
     GetWorkers(&workers);
-    syncable::ModelTypePayloadMap types =
+    syncer::ModelTypePayloadMap types =
         ModelSafeRoutingInfoToPayloadMap(info, std::string());
     return new SyncSession(context_.get(), this,
         sessions::SyncSourceInfo(sync_pb::GetUpdatesCallerInfo::UNKNOWN, types),
         info, workers);
   }
 
   bool SyncShareAsDelegate(
       SyncScheduler::SyncSessionJob::SyncSessionJobPurpose purpose) {
     SyncerStep start;
     SyncerStep end;
@@ skipping 19 matching lines @@
     int loop_iterations = 0;
     do {
       ASSERT_LT(++loop_iterations, 100) << "infinite loop detected. please fix";
       should_loop = SyncShareNudge();
     } while (should_loop);
   }
 
   virtual void SetUp() {
     dir_maker_.SetUp();
     mock_server_.reset(new MockConnectionManager(directory()));
-    EnableDatatype(syncable::BOOKMARKS);
-    EnableDatatype(syncable::NIGORI);
-    EnableDatatype(syncable::PREFERENCES);
-    EnableDatatype(syncable::NIGORI);
+    EnableDatatype(syncer::BOOKMARKS);
+    EnableDatatype(syncer::NIGORI);
+    EnableDatatype(syncer::PREFERENCES);
+    EnableDatatype(syncer::NIGORI);
     worker_ = new FakeModelWorker(GROUP_PASSIVE);
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(this);
 
     ModelSafeRoutingInfo routing_info;
     std::vector<ModelSafeWorker*> workers;
 
     GetModelSafeRoutingInfo(&routing_info);
     GetWorkers(&workers);
 
@@ skipping 38 matching lines @@
     EXPECT_FALSE(entry->Get(IS_DEL));
     VerifyTestBookmarkDataInEntry(entry);
   }
   void VerifyTestBookmarkDataInEntry(Entry* entry) {
     const sync_pb::EntitySpecifics& specifics = entry->Get(syncable::SPECIFICS);
     EXPECT_TRUE(specifics.has_bookmark());
     EXPECT_EQ("PNG", specifics.bookmark().favicon());
     EXPECT_EQ("http://demo/", specifics.bookmark().url());
   }
 
-  bool initial_sync_ended_for_type(syncable::ModelType type) {
+  bool initial_sync_ended_for_type(syncer::ModelType type) {
     return directory()->initial_sync_ended_for_type(type);
   }
 
   void SyncRepeatedlyToTriggerConflictResolution(SyncSession* session) {
     // We should trigger after less than 6 syncs, but extra does no harm.
     for (int i = 0 ; i < 6 ; ++i)
       syncer_->SyncShare(session, SYNCER_BEGIN, SYNCER_END);
   }
   void SyncRepeatedlyToTriggerStuckSignal(SyncSession* session) {
     // We should trigger after less than 10 syncs, but we want to avoid brittle
     // tests.
     for (int i = 0 ; i < 12 ; ++i)
       syncer_->SyncShare(session, SYNCER_BEGIN, SYNCER_END);
   }
   sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
     sync_pb::EntitySpecifics result;
-    AddDefaultFieldValue(syncable::BOOKMARKS, &result);
+    AddDefaultFieldValue(syncer::BOOKMARKS, &result);
     return result;
   }
 
   sync_pb::EntitySpecifics DefaultPreferencesSpecifics() {
     sync_pb::EntitySpecifics result;
-    AddDefaultFieldValue(syncable::PREFERENCES, &result);
+    AddDefaultFieldValue(syncer::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
     DELETED,
     OLD_MTIME,
     MOVED_FROM_ROOT,
   };
@@ skipping 82 matching lines @@
                         const vector<syncable::Id>& expected_id_order) {
     for (size_t limit = expected_id_order.size() + 2; limit > 0; --limit) {
       WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
       ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
 
       ModelSafeRoutingInfo routes;
       GetModelSafeRoutingInfo(&routes);
       sessions::OrderedCommitSet output_set(routes);
       GetCommitIdsCommand command(limit, &output_set);
       std::set<int64> ready_unsynced_set;
-      command.FilterUnreadyEntries(&wtrans, syncable::ModelTypeSet(),
-                                   syncable::ModelTypeSet(), false,
+      command.FilterUnreadyEntries(&wtrans, syncer::ModelTypeSet(),
+                                   syncer::ModelTypeSet(), false,
                                    unsynced_handle_view, &ready_unsynced_set);
       command.BuildCommitIds(session_->write_transaction(), routes,
                              ready_unsynced_set);
       size_t truncated_size = std::min(limit, expected_id_order.size());
       ASSERT_EQ(truncated_size, output_set.Size());
       for (size_t i = 0; i < truncated_size; ++i) {
         ASSERT_EQ(expected_id_order[i], output_set.GetCommitIdAt(i))
             << "At index " << i << " with batch size limited to " << limit;
       }
       sessions::OrderedCommitSet::Projection proj;
@@ skipping 30 matching lines @@
                        entry_name);
     EXPECT_TRUE(entry.good());
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::IS_DIR, true);
     entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(syncable::BASE_VERSION, id.ServerKnows() ? 1 : 0);
     entry.Put(syncable::ID, id);
     return entry.Get(META_HANDLE);
   }
 
-  void EnableDatatype(syncable::ModelType model_type) {
+  void EnableDatatype(syncer::ModelType model_type) {
     enabled_datatypes_.Put(model_type);
 
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
     if (context_.get()) {
       context_->set_routing_info(routing_info);
     }
 
     mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
   }
 
-  void DisableDatatype(syncable::ModelType model_type) {
+  void DisableDatatype(syncer::ModelType model_type) {
     enabled_datatypes_.Remove(model_type);
 
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
     if (context_.get()) {
       context_->set_routing_info(routing_info);
     }
 
     mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
@@ skipping 67 matching lines @@
   Syncer* syncer_;
 
   scoped_ptr<SyncSession> session_;
   scoped_ptr<SyncSessionContext> context_;
   bool saw_syncer_event_;
   base::TimeDelta last_short_poll_interval_received_;
   base::TimeDelta last_long_poll_interval_received_;
   base::TimeDelta last_sessions_commit_delay_seconds_;
   scoped_refptr<ModelSafeWorker> worker_;
 
-  syncable::ModelTypeSet enabled_datatypes_;
+  syncer::ModelTypeSet enabled_datatypes_;
   syncer::TrafficRecorder traffic_recorder_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerTest);
 };
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   {
     Syncer::UnsyncedMetaHandles handles;
     {
       syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 53 matching lines @@
   // The expected order is "x", "b", "c", "d", "e", truncated appropriately.
   expected_order.push_back(ids_.MakeServer("x"));
   expected_order.push_back(ids_.MakeLocal("b"));
   expected_order.push_back(ids_.MakeLocal("c"));
   expected_order.push_back(ids_.MakeLocal("d"));
   expected_order.push_back(ids_.MakeLocal("e"));
   DoTruncationTest(unsynced_handle_view, expected_order);
 }
 
 TEST_F(SyncerTest, GetCommitIdsFiltersThrottledEntries) {
-  const syncable::ModelTypeSet throttled_types(syncable::BOOKMARKS);
+  const syncer::ModelTypeSet throttled_types(syncer::BOOKMARKS);
   sync_pb::EntitySpecifics bookmark_data;
-  AddDefaultFieldValue(syncable::BOOKMARKS, &bookmark_data);
+  AddDefaultFieldValue(syncer::BOOKMARKS, &bookmark_data);
 
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   SyncShareNudge();
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     A.Put(SPECIFICS, bookmark_data);
@@ skipping 32 matching lines @@
 #define VERIFY_ENTRY(id, is_unapplied, is_unsynced, prev_initialized, \
                      parent_id, version, server_version, id_fac, rtrans) \
   do { \
     Entry entryA(rtrans, syncable::GET_BY_ID, id_fac.FromNumber(id)); \
     ASSERT_TRUE(entryA.good()); \
     /* We don't use EXPECT_EQ here because when the left side param is false,
     gcc 4.6 warns about converting 'false' to pointer type for argument 1. */ \
     EXPECT_TRUE(is_unsynced == entryA.Get(IS_UNSYNCED)); \
     EXPECT_TRUE(is_unapplied == entryA.Get(IS_UNAPPLIED_UPDATE)); \
     EXPECT_TRUE(prev_initialized == \
-              syncable::IsRealDataType(syncable::GetModelTypeFromSpecifics( \
+              syncer::IsRealDataType(syncer::GetModelTypeFromSpecifics( \
                   entryA.Get(BASE_SERVER_SPECIFICS)))); \
     EXPECT_TRUE(parent_id == -1 || \
                 entryA.Get(PARENT_ID) == id_fac.FromNumber(parent_id)); \
     EXPECT_EQ(version, entryA.Get(BASE_VERSION)); \
     EXPECT_EQ(server_version, entryA.Get(SERVER_VERSION)); \
   } 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(syncable::BOOKMARKS, &encrypted_bookmark);
+  AddDefaultFieldValue(syncer::BOOKMARKS, &encrypted_bookmark);
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   mock_server_->AddUpdateDirectory(3, 0, "C", 10, 10);
   mock_server_->AddUpdateDirectory(4, 0, "D", 10, 10);
   SyncShareNudge();
   // Server side change will put A in conflict.
   mock_server_->AddUpdateDirectory(1, 0, "A", 20, 20);
   {
     // Mark bookmarks as encrypted and set the cryptographer to have pending
     // keys.
@@ skipping 90 matching lines @@
 }
 
 TEST_F(SyncerTest, EncryptionAwareConflicts) {
   KeyParams key_params = {"localhost", "dummy", "foobar"};
   syncer::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());
-  AddDefaultFieldValue(syncable::BOOKMARKS, &encrypted_bookmark);
+  AddDefaultFieldValue(syncer::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(syncable::PREFERENCES, &encrypted_pref);
+  AddDefaultFieldValue(syncer::PREFERENCES, &encrypted_pref);
   other_cryptographer.Encrypt(pref,
                               encrypted_pref.mutable_encrypted());
   modified_pref.mutable_preference()->set_name("name2");
   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;
@@ skipping 150 matching lines @@
   // Data for testing encryption/decryption.
   syncer::Cryptographer other_cryptographer(&encryptor_);
   other_cryptographer.AddKey(old_key);
   sync_pb::EntitySpecifics other_encrypted_specifics;
   other_encrypted_specifics.mutable_bookmark()->set_title("title");
   other_cryptographer.Encrypt(
       other_encrypted_specifics,
       other_encrypted_specifics.mutable_encrypted());
   sync_pb::EntitySpecifics our_encrypted_specifics;
   our_encrypted_specifics.mutable_bookmark()->set_title("title2");
-  syncable::ModelTypeSet encrypted_types = syncable::ModelTypeSet::All();
+  syncer::ModelTypeSet encrypted_types = syncer::ModelTypeSet::All();
 
 
   // Receive the initial nigori node.
   sync_pb::EntitySpecifics initial_nigori_specifics;
   initial_nigori_specifics.mutable_nigori();
   mock_server_->SetNigori(1, 10, 10, initial_nigori_specifics);
   SyncShareNudge();
 
   {
     // Set up the current nigori node (containing both keys and encrypt
     // everything).
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     sync_pb::EntitySpecifics specifics;
     sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     cryptographer(&wtrans)->AddKey(old_key);
     cryptographer(&wtrans)->AddKey(current_key);
     cryptographer(&wtrans)->Encrypt(
         our_encrypted_specifics,
         our_encrypted_specifics.mutable_encrypted());
     cryptographer(&wtrans)->GetKeys(
         nigori->mutable_encrypted());
     cryptographer(&wtrans)->set_encrypt_everything();
     cryptographer(&wtrans)->UpdateNigoriFromEncryptedTypes(nigori);
     MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
-                              syncable::ModelTypeToRootTag(syncable::NIGORI));
+                              syncer::ModelTypeToRootTag(syncer::NIGORI));
     ASSERT_TRUE(nigori_entry.good());
     nigori_entry.Put(SPECIFICS, specifics);
     nigori_entry.Put(IS_UNSYNCED, true);
     EXPECT_FALSE(cryptographer(&wtrans)->has_pending_keys());
     EXPECT_TRUE(encrypted_types.Equals(
         cryptographer(&wtrans)->GetEncryptedTypes()));
   }
 
   SyncShareNudge();  // Commit it.
 
   // Now set up the old nigori node and add it as a server update.
   sync_pb::EntitySpecifics old_nigori_specifics;
   sync_pb::NigoriSpecifics *old_nigori = old_nigori_specifics.mutable_nigori();
   other_cryptographer.GetKeys(old_nigori->mutable_encrypted());
   other_cryptographer.UpdateNigoriFromEncryptedTypes(old_nigori);
   mock_server_->SetNigori(1, 30, 30, old_nigori_specifics);
 
   SyncShareNudge();  // Download the old nigori and apply it.
 
   {
     // Ensure everything is committed and stable now. The cryptographer
     // should be able to decrypt both sets of keys and still be encrypting with
     // the newest, and the encrypted types should be the most recent
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry nigori_entry(&trans, GET_BY_SERVER_TAG,
-                       syncable::ModelTypeToRootTag(syncable::NIGORI));
+                       syncer::ModelTypeToRootTag(syncer::NIGORI));
     ASSERT_TRUE(nigori_entry.good());
     EXPECT_FALSE(nigori_entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(nigori_entry.Get(IS_UNSYNCED));
     const sync_pb::NigoriSpecifics& nigori =
         nigori_entry.Get(SPECIFICS).nigori();
     EXPECT_TRUE(cryptographer(&trans)->CanDecryptUsingDefaultKey(
         our_encrypted_specifics.encrypted()));
     EXPECT_TRUE(cryptographer(&trans)->CanDecrypt(
         other_encrypted_specifics.encrypted()));
     EXPECT_TRUE(cryptographer(&trans)->CanDecrypt(
         nigori.encrypted()));
     EXPECT_TRUE(cryptographer(&trans)->encrypt_everything());
   }
 }
 
 // Resolve a confict between two nigori's with different encrypted types,
 // and encryption keys (remote is explicit). Afterwards, the encrypted types
 // should be unioned and the cryptographer should have both keys and be
 // encrypting with the remote encryption key by default.
 TEST_F(SyncerTest, NigoriConflicts) {
   KeyParams local_key_params = {"localhost", "dummy", "blargle"};
   KeyParams other_key_params = {"localhost", "dummy", "foobar"};
   syncer::Cryptographer other_cryptographer(&encryptor_);
   other_cryptographer.AddKey(other_key_params);
-  syncable::ModelTypeSet encrypted_types(syncable::PASSWORDS, syncable::NIGORI);
+  syncer::ModelTypeSet encrypted_types(syncer::PASSWORDS, syncer::NIGORI);
   sync_pb::EntitySpecifics initial_nigori_specifics;
   initial_nigori_specifics.mutable_nigori();
   mock_server_->SetNigori(1, 10, 10, initial_nigori_specifics);
 
   // Data for testing encryption/decryption.
   sync_pb::EntitySpecifics other_encrypted_specifics;
   other_encrypted_specifics.mutable_bookmark()->set_title("title");
   other_cryptographer.Encrypt(
       other_encrypted_specifics,
       other_encrypted_specifics.mutable_encrypted());
   sync_pb::EntitySpecifics our_encrypted_specifics;
   our_encrypted_specifics.mutable_bookmark()->set_title("title2");
 
   // Receive the initial nigori node.
   SyncShareNudge();
-  encrypted_types = syncable::ModelTypeSet::All();
+  encrypted_types = syncer::ModelTypeSet::All();
   {
     // Local changes with different passphrase, different types.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     sync_pb::EntitySpecifics specifics;
     sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     cryptographer(&wtrans)->AddKey(local_key_params);
     cryptographer(&wtrans)->Encrypt(
         our_encrypted_specifics,
         our_encrypted_specifics.mutable_encrypted());
     cryptographer(&wtrans)->GetKeys(
         nigori->mutable_encrypted());
     cryptographer(&wtrans)->UpdateNigoriFromEncryptedTypes(nigori);
     cryptographer(&wtrans)->set_encrypt_everything();
     MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
-                              syncable::ModelTypeToRootTag(syncable::NIGORI));
+                              syncer::ModelTypeToRootTag(syncer::NIGORI));
     ASSERT_TRUE(nigori_entry.good());
     nigori_entry.Put(SPECIFICS, specifics);
     nigori_entry.Put(IS_UNSYNCED, true);
     EXPECT_FALSE(cryptographer(&wtrans)->has_pending_keys());
     EXPECT_TRUE(encrypted_types.Equals(
             cryptographer(&wtrans)->GetEncryptedTypes()));
   }
   {
     sync_pb::EntitySpecifics specifics;
     sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     other_cryptographer.GetKeys(nigori->mutable_encrypted());
     nigori->set_encrypt_bookmarks(true);
     nigori->set_encrypt_preferences(true);
     nigori->set_encrypt_everything(false);
     nigori->set_using_explicit_passphrase(true);
     mock_server_->SetNigori(1, 20, 20, specifics);
   }
 
   // Will result in downloading the server nigori, which puts the local nigori
   // in a state of conflict. This is resolved by merging the local and server
   // data (with priority given to the server's encryption keys if they are
   // undecryptable), which we then commit. The cryptographer should have pending
   // keys and merge the set of encrypted types.
   SyncShareNudge();  // Resolve conflict in this cycle.
   SyncShareNudge();  // Commit local change in this cycle.
   {
     // Ensure the nigori data merged (encrypted types).
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
-                              syncable::ModelTypeToRootTag(syncable::NIGORI));
+                              syncer::ModelTypeToRootTag(syncer::NIGORI));
     ASSERT_TRUE(nigori_entry.good());
     EXPECT_FALSE(nigori_entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(nigori_entry.Get(IS_UNSYNCED));
     sync_pb::EntitySpecifics specifics = nigori_entry.Get(SPECIFICS);
     EXPECT_TRUE(cryptographer(&wtrans)->has_pending_keys());
     EXPECT_TRUE(encrypted_types.Equals(
             cryptographer(&wtrans)->GetEncryptedTypes()));
     EXPECT_TRUE(cryptographer(&wtrans)->encrypt_everything());
     EXPECT_TRUE(specifics.nigori().using_explicit_passphrase());
     // Supply the pending keys. Afterwards, we should be able to decrypt both
@@ skipping 10 matching lines @@
     nigori_entry.Put(IS_UNSYNCED, true);
   }
 
   SyncShareNudge();
   {
     // Ensure everything is committed and stable now. The cryptographer
     // should be able to decrypt both sets of keys, and the encrypted types
     // should have been unioned.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
-                              syncable::ModelTypeToRootTag(syncable::NIGORI));
+                              syncer::ModelTypeToRootTag(syncer::NIGORI));
     ASSERT_TRUE(nigori_entry.good());
     EXPECT_FALSE(nigori_entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(nigori_entry.Get(IS_UNSYNCED));
     EXPECT_TRUE(cryptographer(&wtrans)->CanDecrypt(
         our_encrypted_specifics.encrypted()));
     EXPECT_FALSE(cryptographer(&wtrans)->
         CanDecryptUsingDefaultKey(our_encrypted_specifics.encrypted()));
     EXPECT_TRUE(cryptographer(&wtrans)->CanDecrypt(
         other_encrypted_specifics.encrypted()));
     EXPECT_TRUE(cryptographer(&wtrans)->
@@ skipping 55 matching lines @@
     MutableEntry parent2(&wtrans, syncable::CREATE, wtrans.root_id(), "Tim");
     ASSERT_TRUE(parent2.good());
     parent2.Put(syncable::IS_UNSYNCED, true);
     parent2.Put(syncable::IS_DIR, true);
     parent2.Put(syncable::SPECIFICS, DefaultPreferencesSpecifics());
     parent2.Put(syncable::BASE_VERSION, 1);
     parent2.Put(syncable::ID, pref_node_id);
   }
 
   directory()->PurgeEntriesWithTypeIn(
-      syncable::ModelTypeSet(syncable::PREFERENCES));
+      syncer::ModelTypeSet(syncer::PREFERENCES));
 
   SyncShareNudge();
   ASSERT_EQ(2U, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   {
     syncable::ReadTransaction rt(FROM_HERE, directory());
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
@@ skipping 14 matching lines @@
     MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "Pete");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::BASE_VERSION, 1);
     parent.Put(syncable::ID, parent_id_);
   }
 
   directory()->PurgeEntriesWithTypeIn(
-      syncable::ModelTypeSet(syncable::BOOKMARKS));
+      syncer::ModelTypeSet(syncer::BOOKMARKS));
 
   SyncShareNudge();
   directory()->SaveChanges();
   {
     syncable::ReadTransaction rt(FROM_HERE, directory());
     Entry entry(&rt, syncable::GET_BY_ID, parent_id_);
     ASSERT_FALSE(entry.good());
   }
 }
 
@@ skipping 1174 matching lines @@
   SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, syncable::GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(MTIME) == test_time);
   }
 }
 
 TEST_F(SyncerTest, ParentAndChildBothMatch) {
-  const syncable::FullModelTypeSet all_types =
-      syncable::FullModelTypeSet::All();
+  const syncer::FullModelTypeSet all_types = syncer::FullModelTypeSet::All();
   syncable::Id parent_id = ids_.NewServerId();
   syncable::Id child_id = ids_.NewServerId();
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent.Put(IS_DIR, true);
     parent.Put(IS_UNSYNCED, true);
     parent.Put(ID, parent_id);
@@ skipping 1533 matching lines @@
     ASSERT_TRUE(!hurdle.Get(IS_DEL));
     ASSERT_TRUE(hurdle.Get(UNIQUE_SERVER_TAG).empty());
     ASSERT_TRUE(hurdle.Get(NON_UNIQUE_NAME) == "bob");
   }
 }
 
 TEST_F(SyncerTest, GetUpdatesSetsRequestedTypes) {
   // The expectations of this test happen in the MockConnectionManager's
   // GetUpdates handler.  EnableDatatype sets the expectation value from our
   // set of enabled/disabled datatypes.
-  EnableDatatype(syncable::BOOKMARKS);
+  EnableDatatype(syncer::BOOKMARKS);
   SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
-  EnableDatatype(syncable::AUTOFILL);
+  EnableDatatype(syncer::AUTOFILL);
   SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
-  EnableDatatype(syncable::PREFERENCES);
+  EnableDatatype(syncer::PREFERENCES);
   SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
-  DisableDatatype(syncable::BOOKMARKS);
+  DisableDatatype(syncer::BOOKMARKS);
   SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
-  DisableDatatype(syncable::AUTOFILL);
+  DisableDatatype(syncer::AUTOFILL);
   SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
-  DisableDatatype(syncable::PREFERENCES);
-  EnableDatatype(syncable::AUTOFILL);
+  DisableDatatype(syncer::PREFERENCES);
+  EnableDatatype(syncer::AUTOFILL);
   SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 }
 
 // A typical scenario: server and client each have one update for the other.
 // This is the "happy path" alternative to UpdateFailsThenDontCommit.
 TEST_F(SyncerTest, UpdateThenCommit) {
   syncable::Id to_receive = ids_.NewServerId();
   syncable::Id to_commit = ids_.NewLocalId();
 
@@ skipping 38 matching lines @@
   EXPECT_TRUE(committed.Get(IS_UNSYNCED));
   EXPECT_FALSE(committed.Get(IS_UNAPPLIED_UPDATE));
 
   // Inform the Mock we won't be fetching all updates.
   mock_server_->ClearUpdatesQueue();
 }
 
 // Downloads two updates and applies them successfully.
 // This is the "happy path" alternative to ConfigureFailsDontApplyUpdates.
 TEST_F(SyncerTest, ConfigureDownloadsTwoBatchesSuccess) {
-  EXPECT_FALSE(initial_sync_ended_for_type(syncable::BOOKMARKS));
+  EXPECT_FALSE(initial_sync_ended_for_type(syncer::BOOKMARKS));
 
   syncable::Id node1 = ids_.NewServerId();
   syncable::Id node2 = ids_.NewServerId();
 
   // Construct the first GetUpdates response.
   mock_server_->AddUpdateDirectory(node1, ids_.root(), "one", 1, 10);
   mock_server_->SetChangesRemaining(1);
   mock_server_->NextUpdateBatch();
 
   // Construct the second GetUpdates response.
   mock_server_->AddUpdateDirectory(node2, ids_.root(), "two", 1, 20);
 
   SyncShareConfigure();
 
   syncable::ReadTransaction trans(FROM_HERE, directory());
   // Both nodes should be downloaded and applied.
 
   Entry n1(&trans, GET_BY_ID, node1);
   ASSERT_TRUE(n1.good());
   EXPECT_FALSE(n1.Get(IS_UNAPPLIED_UPDATE));
 
   Entry n2(&trans, GET_BY_ID, node2);
   ASSERT_TRUE(n2.good());
   EXPECT_FALSE(n2.Get(IS_UNAPPLIED_UPDATE));
 
-  EXPECT_TRUE(initial_sync_ended_for_type(syncable::BOOKMARKS));
+  EXPECT_TRUE(initial_sync_ended_for_type(syncer::BOOKMARKS));
 }
 
 // Same as the above case, but this time the second batch fails to download.
 TEST_F(SyncerTest, ConfigureFailsDontApplyUpdates) {
-  EXPECT_FALSE(initial_sync_ended_for_type(syncable::BOOKMARKS));
+  EXPECT_FALSE(initial_sync_ended_for_type(syncer::BOOKMARKS));
 
   syncable::Id node1 = ids_.NewServerId();
   syncable::Id node2 = ids_.NewServerId();
 
   // The scenario: we have two batches of updates with one update each.  A
   // normal confgure step would download all the updates one batch at a time and
   // apply them.  This configure will succeed in downloading the first batch
   // then fail when downloading the second.
   mock_server_->FailNthPostBufferToPathCall(2);
 
@@ skipping 14 matching lines @@
   ASSERT_TRUE(n1.good());
   EXPECT_TRUE(n1.Get(IS_UNAPPLIED_UPDATE));
 
   // The second node was not downloaded.
   Entry n2(&trans, GET_BY_ID, node2);
   EXPECT_FALSE(n2.good());
 
   // One update remains undownloaded.
   mock_server_->ClearUpdatesQueue();
 
-  EXPECT_FALSE(initial_sync_ended_for_type(syncable::BOOKMARKS));
+  EXPECT_FALSE(initial_sync_ended_for_type(syncer::BOOKMARKS));
 }
 
 // Test what happens if a client deletes, then recreates, an object very
 // quickly.  It is possible that the deletion gets sent as a commit, and
 // the undelete happens during the commit request.  The principle here
 // is that with a single committing client, conflicts should never
 // be encountered, and a client encountering its past actions during
 // getupdates should never feed back to override later actions.
 //
 // In cases of ordering A-F below, the outcome should be the same.
@@ skipping 646 matching lines @@
 
 TEST_F(SyncerPositionTiebreakingTest, MidLowHigh) {
   Add(mid_id_);
   Add(low_id_);
   Add(high_id_);
   SyncShareNudge();
   ExpectLocalOrderIsByServerId();
 }
 
 }  // namespace syncer