[Sync] Remove unneeded 'using syncer::' lines and 'syncer::' scopings

sync/internal_api/syncapi_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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 91 matching lines @@
   EXPECT_TRUE(value.GetString(key, &int64_str));
   int64 val = 0;
   EXPECT_TRUE(base::StringToInt64(int64_str, &val));
   EXPECT_EQ(expected_value, val);
 }
 
 void ExpectTimeValue(const base::Time& expected_value,
                      const DictionaryValue& value, const std::string& key) {
   std::string time_str;
   EXPECT_TRUE(value.GetString(key, &time_str));
-  EXPECT_EQ(syncer::GetTimeDebugString(expected_value), time_str);
+  EXPECT_EQ(GetTimeDebugString(expected_value), time_str);
 }
 
 // Makes a non-folder child of the root node.  Returns the id of the
 // newly-created node.
 int64 MakeNode(UserShare* share,
                ModelType model_type,
                const std::string& client_tag) {
   WriteTransaction trans(FROM_HERE, share);
   ReadNode root_node(&trans);
   root_node.InitByRootLookup();
   WriteNode node(&trans);
-  syncer::WriteNode::InitUniqueByCreationResult result =
+  WriteNode::InitUniqueByCreationResult result =
       node.InitUniqueByCreation(model_type, root_node, client_tag);
-  EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
+  EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
   node.SetIsFolder(false);
   return node.GetId();
 }
 
 // Makes a non-folder child of a non-root node. Returns the id of the
 // newly-created node.
 int64 MakeNodeWithParent(UserShare* share,
                          ModelType model_type,
                          const std::string& client_tag,
                          int64 parent_id) {
   WriteTransaction trans(FROM_HERE, share);
   ReadNode parent_node(&trans);
   EXPECT_EQ(BaseNode::INIT_OK, parent_node.InitByIdLookup(parent_id));
   WriteNode node(&trans);
-  syncer::WriteNode::InitUniqueByCreationResult result =
+  WriteNode::InitUniqueByCreationResult result =
       node.InitUniqueByCreation(model_type, parent_node, client_tag);
-  EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
+  EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
   node.SetIsFolder(false);
   return node.GetId();
 }
 
 // Makes a folder child of a non-root node. Returns the id of the
 // newly-created node.
 int64 MakeFolderWithParent(UserShare* share,
                            ModelType model_type,
                            int64 parent_id,
                            BaseNode* predecessor) {
   WriteTransaction trans(FROM_HERE, share);
   ReadNode parent_node(&trans);
   EXPECT_EQ(BaseNode::INIT_OK, parent_node.InitByIdLookup(parent_id));
   WriteNode node(&trans);
   EXPECT_TRUE(node.InitByCreation(model_type, parent_node, predecessor));
   node.SetIsFolder(true);
   return node.GetId();
 }
 
 // Creates the "synced" root node for a particular datatype. We use the syncable
 // methods here so that the syncer treats these nodes as if they were already
 // received from the server.
 int64 MakeServerNodeForType(UserShare* share,
                             ModelType model_type) {
   sync_pb::EntitySpecifics specifics;
-  syncer::AddDefaultFieldValue(model_type, &specifics);
+  AddDefaultFieldValue(model_type, &specifics);
   syncable::WriteTransaction trans(
       FROM_HERE, syncable::UNITTEST, share->directory.get());
   // Attempt to lookup by nigori tag.
-  std::string type_tag = syncer::ModelTypeToRootTag(model_type);
+  std::string type_tag = ModelTypeToRootTag(model_type);
   syncable::Id node_id = syncable::Id::CreateFromServerId(type_tag);
   syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
                                node_id);
   EXPECT_TRUE(entry.good());
   entry.Put(syncable::BASE_VERSION, 1);
   entry.Put(syncable::SERVER_VERSION, 1);
   entry.Put(syncable::IS_UNAPPLIED_UPDATE, false);
   entry.Put(syncable::SERVER_PARENT_ID, syncable::GetNullId());
   entry.Put(syncable::SERVER_IS_DIR, true);
   entry.Put(syncable::IS_DIR, true);
   entry.Put(syncable::SERVER_SPECIFICS, specifics);
   entry.Put(syncable::UNIQUE_SERVER_TAG, type_tag);
   entry.Put(syncable::NON_UNIQUE_NAME, type_tag);
   entry.Put(syncable::IS_DEL, false);
   entry.Put(syncable::SPECIFICS, specifics);
   return entry.Get(syncable::META_HANDLE);
 }
 
 // Simulates creating a "synced" node as a child of the root datatype node.
 int64 MakeServerNode(UserShare* share, ModelType model_type,
                      const std::string& client_tag,
                      const std::string& hashed_tag,
                      const sync_pb::EntitySpecifics& specifics) {
   syncable::WriteTransaction trans(
       FROM_HERE, syncable::UNITTEST, share->directory.get());
   syncable::Entry root_entry(&trans, syncable::GET_BY_SERVER_TAG,
-                             syncer::ModelTypeToRootTag(model_type));
+                             ModelTypeToRootTag(model_type));
   EXPECT_TRUE(root_entry.good());
   syncable::Id root_id = root_entry.Get(syncable::ID);
   syncable::Id node_id = syncable::Id::CreateFromServerId(client_tag);
   syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
                                node_id);
   EXPECT_TRUE(entry.good());
   entry.Put(syncable::BASE_VERSION, 1);
   entry.Put(syncable::SERVER_VERSION, 1);
   entry.Put(syncable::IS_UNAPPLIED_UPDATE, false);
   entry.Put(syncable::SERVER_PARENT_ID, root_id);
@@ skipping 15 matching lines @@
   virtual void SetUp() {
     test_user_share_.SetUp();
   }
 
   virtual void TearDown() {
     test_user_share_.TearDown();
   }
 
  protected:
   MessageLoop message_loop_;
-  syncer::TestUserShare test_user_share_;
+  TestUserShare test_user_share_;
 };
 
 TEST_F(SyncApiTest, SanityCheckTest) {
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     EXPECT_TRUE(trans.GetWrappedTrans() != NULL);
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     EXPECT_TRUE(trans.GetWrappedTrans() != NULL);
   }
   {
     // No entries but root should exist
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
     // Metahandle 1 can be root, sanity check 2
     EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD, node.InitByIdLookup(2));
   }
 }
 
 TEST_F(SyncApiTest, BasicTagWrite) {
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
     EXPECT_EQ(root_node.GetFirstChildId(), 0);
   }
 
   ignore_result(MakeNode(test_user_share_.user_share(),
-                         syncer::BOOKMARKS, "testtag"));
+                         BOOKMARKS, "testtag"));
 
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, "testtag"));
+              node.InitByClientTagLookup(BOOKMARKS, "testtag"));
 
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
     EXPECT_NE(node.GetId(), 0);
     EXPECT_EQ(node.GetId(), root_node.GetFirstChildId());
   }
 }
 
 TEST_F(SyncApiTest, GenerateSyncableHash) {
   EXPECT_EQ("OyaXV5mEzrPS4wbogmtKvRfekAI=",
-      BaseNode::GenerateSyncableHash(syncer::BOOKMARKS, "tag1"));
+      BaseNode::GenerateSyncableHash(BOOKMARKS, "tag1"));
   EXPECT_EQ("iNFQtRFQb+IZcn1kKUJEZDDkLs4=",
-      BaseNode::GenerateSyncableHash(syncer::PREFERENCES, "tag1"));
+      BaseNode::GenerateSyncableHash(PREFERENCES, "tag1"));
   EXPECT_EQ("gO1cPZQXaM73sHOvSA+tKCKFs58=",
-      BaseNode::GenerateSyncableHash(syncer::AUTOFILL, "tag1"));
+      BaseNode::GenerateSyncableHash(AUTOFILL, "tag1"));
 
   EXPECT_EQ("A0eYIHXM1/jVwKDDp12Up20IkKY=",
-      BaseNode::GenerateSyncableHash(syncer::BOOKMARKS, "tag2"));
+      BaseNode::GenerateSyncableHash(BOOKMARKS, "tag2"));
   EXPECT_EQ("XYxkF7bhS4eItStFgiOIAU23swI=",
-      BaseNode::GenerateSyncableHash(syncer::PREFERENCES, "tag2"));
+      BaseNode::GenerateSyncableHash(PREFERENCES, "tag2"));
   EXPECT_EQ("GFiWzo5NGhjLlN+OyCfhy28DJTQ=",
-      BaseNode::GenerateSyncableHash(syncer::AUTOFILL, "tag2"));
+      BaseNode::GenerateSyncableHash(AUTOFILL, "tag2"));
 }
 
 TEST_F(SyncApiTest, ModelTypesSiloed) {
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
     EXPECT_EQ(root_node.GetFirstChildId(), 0);
   }
 
   ignore_result(MakeNode(test_user_share_.user_share(),
-                         syncer::BOOKMARKS, "collideme"));
+                         BOOKMARKS, "collideme"));
   ignore_result(MakeNode(test_user_share_.user_share(),
-                         syncer::PREFERENCES, "collideme"));
+                         PREFERENCES, "collideme"));
   ignore_result(MakeNode(test_user_share_.user_share(),
-                         syncer::AUTOFILL, "collideme"));
+                         AUTOFILL, "collideme"));
 
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
 
     ReadNode bookmarknode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              bookmarknode.InitByClientTagLookup(syncer::BOOKMARKS,
+              bookmarknode.InitByClientTagLookup(BOOKMARKS,
                   "collideme"));
 
     ReadNode prefnode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              prefnode.InitByClientTagLookup(syncer::PREFERENCES,
+              prefnode.InitByClientTagLookup(PREFERENCES,
                   "collideme"));
 
     ReadNode autofillnode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              autofillnode.InitByClientTagLookup(syncer::AUTOFILL,
+              autofillnode.InitByClientTagLookup(AUTOFILL,
                   "collideme"));
 
     EXPECT_NE(bookmarknode.GetId(), prefnode.GetId());
     EXPECT_NE(autofillnode.GetId(), prefnode.GetId());
     EXPECT_NE(bookmarknode.GetId(), autofillnode.GetId());
   }
 }
 
 TEST_F(SyncApiTest, ReadMissingTagsFails) {
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
-              node.InitByClientTagLookup(syncer::BOOKMARKS,
+              node.InitByClientTagLookup(BOOKMARKS,
                   "testtag"));
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
-              node.InitByClientTagLookup(syncer::BOOKMARKS,
+              node.InitByClientTagLookup(BOOKMARKS,
                   "testtag"));
   }
 }
 
 // TODO(chron): Hook this all up to the server and write full integration tests
 //              for update->undelete behavior.
 TEST_F(SyncApiTest, TestDeleteBehavior) {
   int64 node_id;
   int64 folder_id;
   std::string test_title("test1");
 
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     // we'll use this spare folder later
     WriteNode folder_node(&trans);
-    EXPECT_TRUE(folder_node.InitByCreation(syncer::BOOKMARKS,
+    EXPECT_TRUE(folder_node.InitByCreation(BOOKMARKS,
         root_node, NULL));
     folder_id = folder_node.GetId();
 
     WriteNode wnode(&trans);
-    syncer::WriteNode::InitUniqueByCreationResult result =
-        wnode.InitUniqueByCreation(syncer::BOOKMARKS, root_node, "testtag");
-    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
+    WriteNode::InitUniqueByCreationResult result =
+        wnode.InitUniqueByCreation(BOOKMARKS, root_node, "testtag");
+    EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     wnode.SetIsFolder(false);
     wnode.SetTitle(UTF8ToWide(test_title));
 
     node_id = wnode.GetId();
   }
 
   // Ensure we can delete something with a tag.
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     WriteNode wnode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              wnode.InitByClientTagLookup(syncer::BOOKMARKS,
+              wnode.InitByClientTagLookup(BOOKMARKS,
                   "testtag"));
     EXPECT_FALSE(wnode.GetIsFolder());
     EXPECT_EQ(wnode.GetTitle(), test_title);
 
     wnode.Remove();
   }
 
   // Lookup of a node which was deleted should return failure,
   // but have found some data about the node.
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_IS_DEL,
-              node.InitByClientTagLookup(syncer::BOOKMARKS,
+              node.InitByClientTagLookup(BOOKMARKS,
                   "testtag"));
     // Note that for proper function of this API this doesn't need to be
     // filled, we're checking just to make sure the DB worked in this test.
     EXPECT_EQ(node.GetTitle(), test_title);
   }
 
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode folder_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, folder_node.InitByIdLookup(folder_id));
 
     WriteNode wnode(&trans);
     // This will undelete the tag.
-    syncer::WriteNode::InitUniqueByCreationResult result =
-        wnode.InitUniqueByCreation(syncer::BOOKMARKS, folder_node, "testtag");
-    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
+    WriteNode::InitUniqueByCreationResult result =
+        wnode.InitUniqueByCreation(BOOKMARKS, folder_node, "testtag");
+    EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     EXPECT_EQ(wnode.GetIsFolder(), false);
     EXPECT_EQ(wnode.GetParentId(), folder_node.GetId());
     EXPECT_EQ(wnode.GetId(), node_id);
     EXPECT_NE(wnode.GetTitle(), test_title);  // Title should be cleared
     wnode.SetTitle(UTF8ToWide(test_title));
   }
 
   // Now look up should work.
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS,
+              node.InitByClientTagLookup(BOOKMARKS,
                     "testtag"));
     EXPECT_EQ(node.GetTitle(), test_title);
-    EXPECT_EQ(node.GetModelType(), syncer::BOOKMARKS);
+    EXPECT_EQ(node.GetModelType(), BOOKMARKS);
   }
 }
 
 TEST_F(SyncApiTest, WriteAndReadPassword) {
   KeyParams params = {"localhost", "username", "passphrase"};
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     trans.GetCryptographer()->AddKey(params);
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
-    syncer::WriteNode::InitUniqueByCreationResult result =
-        password_node.InitUniqueByCreation(syncer::PASSWORDS,
+    WriteNode::InitUniqueByCreationResult result =
+        password_node.InitUniqueByCreation(PASSWORDS,
                                            root_node, "foo");
-    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     password_node.SetPasswordSpecifics(data);
   }
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              password_node.InitByClientTagLookup(syncer::PASSWORDS,
-                                                  "foo"));
+              password_node.InitByClientTagLookup(PASSWORDS, "foo"));
     const sync_pb::PasswordSpecificsData& data =
         password_node.GetPasswordSpecifics();
     EXPECT_EQ("secret", data.password_value());
   }
 }
 
 TEST_F(SyncApiTest, WriteEncryptedTitle) {
   KeyParams params = {"localhost", "username", "passphrase"};
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     trans.GetCryptographer()->AddKey(params);
     trans.GetCryptographer()->set_encrypt_everything();
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode bookmark_node(&trans);
-    syncer::WriteNode::InitUniqueByCreationResult result =
-        bookmark_node.InitUniqueByCreation(syncer::BOOKMARKS,
+    WriteNode::InitUniqueByCreationResult result =
+        bookmark_node.InitUniqueByCreation(BOOKMARKS,
                                            root_node, "foo");
-    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     bookmark_node.SetTitle(UTF8ToWide("foo"));
 
     WriteNode pref_node(&trans);
     result =
-        pref_node.InitUniqueByCreation(syncer::PREFERENCES, root_node, "bar");
-    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
+        pref_node.InitUniqueByCreation(PREFERENCES, root_node, "bar");
+    EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     pref_node.SetTitle(UTF8ToWide("bar"));
   }
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     ReadNode bookmark_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              bookmark_node.InitByClientTagLookup(syncer::BOOKMARKS,
+              bookmark_node.InitByClientTagLookup(BOOKMARKS,
                                                   "foo"));
     EXPECT_EQ("foo", bookmark_node.GetTitle());
     EXPECT_EQ(kEncryptedString,
               bookmark_node.GetEntry()->Get(syncable::NON_UNIQUE_NAME));
 
     ReadNode pref_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              pref_node.InitByClientTagLookup(syncer::PREFERENCES,
+              pref_node.InitByClientTagLookup(PREFERENCES,
                                               "bar"));
     EXPECT_EQ(kEncryptedString, pref_node.GetTitle());
   }
 }
 
 TEST_F(SyncApiTest, BaseNodeSetSpecifics) {
   int64 child_id = MakeNode(test_user_share_.user_share(),
-                            syncer::BOOKMARKS, "testtag");
+                            BOOKMARKS, "testtag");
   WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   WriteNode node(&trans);
   EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
 
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("http://www.google.com");
 
   EXPECT_NE(entity_specifics.SerializeAsString(),
             node.GetEntitySpecifics().SerializeAsString());
   node.SetEntitySpecifics(entity_specifics);
   EXPECT_EQ(entity_specifics.SerializeAsString(),
             node.GetEntitySpecifics().SerializeAsString());
 }
 
 TEST_F(SyncApiTest, BaseNodeSetSpecificsPreservesUnknownFields) {
   int64 child_id = MakeNode(test_user_share_.user_share(),
-                            syncer::BOOKMARKS, "testtag");
+                            BOOKMARKS, "testtag");
   WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   WriteNode node(&trans);
   EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
   EXPECT_TRUE(node.GetEntitySpecifics().unknown_fields().empty());
 
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("http://www.google.com");
   entity_specifics.mutable_unknown_fields()->AddFixed32(5, 100);
   node.SetEntitySpecifics(entity_specifics);
   EXPECT_FALSE(node.GetEntitySpecifics().unknown_fields().empty());
@@ skipping 11 matching lines @@
   {
     bool is_folder = false;
     EXPECT_TRUE(value.GetBoolean("isFolder", &is_folder));
     EXPECT_EQ(node.GetIsFolder(), is_folder);
   }
   ExpectDictStringValue(node.GetTitle(), value, "title");
   {
     ModelType expected_model_type = node.GetModelType();
     std::string type_str;
     EXPECT_TRUE(value.GetString("type", &type_str));
-    if (expected_model_type >= syncer::FIRST_REAL_MODEL_TYPE) {
-      ModelType model_type = syncer::ModelTypeFromString(type_str);
+    if (expected_model_type >= FIRST_REAL_MODEL_TYPE) {
+      ModelType model_type = ModelTypeFromString(type_str);
       EXPECT_EQ(expected_model_type, model_type);
-    } else if (expected_model_type == syncer::TOP_LEVEL_FOLDER) {
+    } else if (expected_model_type == TOP_LEVEL_FOLDER) {
       EXPECT_EQ("Top-level folder", type_str);
-    } else if (expected_model_type == syncer::UNSPECIFIED) {
+    } else if (expected_model_type == UNSPECIFIED) {
       EXPECT_EQ("Unspecified", type_str);
     } else {
       ADD_FAILURE();
     }
   }
   if (is_detailed) {
     ExpectInt64Value(node.GetParentId(), value, "parentId");
     ExpectTimeValue(node.GetModificationTime(), value, "modificationTime");
     ExpectInt64Value(node.GetExternalId(), value, "externalId");
     ExpectInt64Value(node.GetPredecessorId(), value, "predecessorId");
@@ skipping 36 matching lines @@
     ADD_FAILURE();
   }
 }
 
 TEST_F(SyncApiTest, EmptyTags) {
   WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   ReadNode root_node(&trans);
   root_node.InitByRootLookup();
   WriteNode node(&trans);
   std::string empty_tag;
-  syncer::WriteNode::InitUniqueByCreationResult result =
-      node.InitUniqueByCreation(syncer::TYPED_URLS, root_node, empty_tag);
-  EXPECT_NE(syncer::WriteNode::INIT_SUCCESS, result);
+  WriteNode::InitUniqueByCreationResult result =
+      node.InitUniqueByCreation(TYPED_URLS, root_node, empty_tag);
+  EXPECT_NE(WriteNode::INIT_SUCCESS, result);
   EXPECT_EQ(BaseNode::INIT_FAILED_PRECONDITION,
             node.InitByTagLookup(empty_tag));
 }
 
 namespace {
 
 class TestHttpPostProviderInterface : public HttpPostProviderInterface {
  public:
   virtual ~TestHttpPostProviderInterface() {}
 
@@ skipping 31 matching lines @@
 };
 
 class SyncManagerObserverMock : public SyncManager::Observer {
  public:
   MOCK_METHOD1(OnSyncCycleCompleted,
                void(const SyncSessionSnapshot&));  // NOLINT
   MOCK_METHOD2(OnInitializationComplete,
                void(const WeakHandle<JsBackend>&, bool));  // NOLINT
   MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus));  // NOLINT
   MOCK_METHOD2(OnPassphraseRequired,
-               void(syncer::PassphraseRequiredReason,
+               void(PassphraseRequiredReason,
                     const sync_pb::EncryptedData&));  // NOLINT
   MOCK_METHOD0(OnPassphraseAccepted, void());  // NOLINT
   MOCK_METHOD1(OnBootstrapTokenUpdated, void(const std::string&));  // NOLINT
   MOCK_METHOD0(OnStopSyncingPermanently, void());  // NOLINT
   MOCK_METHOD1(OnUpdatedToken, void(const std::string&));  // NOLINT
   MOCK_METHOD2(OnEncryptedTypesChanged,
                void(ModelTypeSet, bool));  // NOLINT
   MOCK_METHOD0(OnEncryptionComplete, void());  // NOLINT
   MOCK_METHOD1(OnActionableError,
-               void(const syncer::SyncProtocolError&));  // NOLINT
+               void(const SyncProtocolError&));  // NOLINT
 };
 
-class SyncNotifierMock : public syncer::SyncNotifier {
+class SyncNotifierMock : public SyncNotifier {
  public:
-  MOCK_METHOD1(AddObserver, void(syncer::SyncNotifierObserver*));
-  MOCK_METHOD1(RemoveObserver, void(syncer::SyncNotifierObserver*));
+  MOCK_METHOD1(AddObserver, void(SyncNotifierObserver*));
+  MOCK_METHOD1(RemoveObserver, void(SyncNotifierObserver*));
   MOCK_METHOD1(SetUniqueId, void(const std::string&));
   MOCK_METHOD1(SetStateDeprecated, void(const std::string&));
   MOCK_METHOD2(UpdateCredentials,
                void(const std::string&, const std::string&));
   MOCK_METHOD1(UpdateEnabledTypes,
-               void(syncer::ModelTypeSet));
-  MOCK_METHOD1(SendNotification, void(syncer::ModelTypeSet));
+               void(ModelTypeSet));
+  MOCK_METHOD1(SendNotification, void(ModelTypeSet));
 };
 
 }  // namespace
 
 class SyncManagerTest : public testing::Test,
                         public SyncManager::ChangeDelegate {
  protected:
   enum NigoriStatus {
     DONT_WRITE_NIGORI,
     WRITE_TO_NIGORI
@@ skipping 79 matching lines @@
 
   void TearDown() {
     sync_manager_.RemoveObserver(&observer_);
     sync_manager_.ShutdownOnSyncThread();
     sync_notifier_mock_ = NULL;
     EXPECT_FALSE(sync_notifier_observer_);
     PumpLoop();
   }
 
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
-    (*out)[syncer::NIGORI] = syncer::GROUP_PASSIVE;
-    (*out)[syncer::BOOKMARKS] = syncer::GROUP_PASSIVE;
-    (*out)[syncer::THEMES] = syncer::GROUP_PASSIVE;
-    (*out)[syncer::SESSIONS] = syncer::GROUP_PASSIVE;
-    (*out)[syncer::PASSWORDS] = syncer::GROUP_PASSIVE;
-    (*out)[syncer::PREFERENCES] = syncer::GROUP_PASSIVE;
+    (*out)[NIGORI] = GROUP_PASSIVE;
+    (*out)[BOOKMARKS] = GROUP_PASSIVE;
+    (*out)[THEMES] = GROUP_PASSIVE;
+    (*out)[SESSIONS] = GROUP_PASSIVE;
+    (*out)[PASSWORDS] = GROUP_PASSIVE;
+    (*out)[PREFERENCES] = GROUP_PASSIVE;
   }
 
   virtual void OnChangesApplied(
-      syncer::ModelType model_type,
+      ModelType model_type,
       const BaseTransaction* trans,
       const ImmutableChangeRecordList& changes) OVERRIDE {}
 
-  virtual void OnChangesComplete(syncer::ModelType model_type) OVERRIDE {}
+  virtual void OnChangesComplete(ModelType model_type) OVERRIDE {}
 
   // Helper methods.
   bool SetUpEncryption(NigoriStatus nigori_status,
                        EncryptionStatus encryption_status) {
     UserShare* share = sync_manager_.GetUserShare();
-    share->directory->set_initial_sync_ended_for_type(syncer::NIGORI, true);
+    share->directory->set_initial_sync_ended_for_type(NIGORI, true);
 
     // We need to create the nigori node as if it were an applied server update.
-    int64 nigori_id = GetIdForDataType(syncer::NIGORI);
+    int64 nigori_id = GetIdForDataType(NIGORI);
     if (nigori_id == kInvalidId)
       return false;
 
     // Set the nigori cryptographer information.
     WriteTransaction trans(FROM_HERE, share);
     Cryptographer* cryptographer = trans.GetCryptographer();
     if (!cryptographer)
       return false;
     if (encryption_status != UNINITIALIZED) {
       KeyParams params = {"localhost", "dummy", "foobar"};
@@ skipping 14 matching lines @@
     return cryptographer->is_ready();
   }
 
   int64 GetIdForDataType(ModelType type) {
     if (type_roots_.count(type) == 0)
       return 0;
     return type_roots_[type];
   }
 
   void SyncNotifierAddObserver(
-      syncer::SyncNotifierObserver* sync_notifier_observer) {
+      SyncNotifierObserver* sync_notifier_observer) {
     EXPECT_EQ(NULL, sync_notifier_observer_);
     sync_notifier_observer_ = sync_notifier_observer;
   }
 
   void SyncNotifierRemoveObserver(
-      syncer::SyncNotifierObserver* sync_notifier_observer) {
+      SyncNotifierObserver* sync_notifier_observer) {
     EXPECT_EQ(sync_notifier_observer_, sync_notifier_observer);
     sync_notifier_observer_ = NULL;
   }
 
-  void SyncNotifierUpdateEnabledTypes(syncer::ModelTypeSet types) {
+  void SyncNotifierUpdateEnabledTypes(ModelTypeSet types) {
     ModelSafeRoutingInfo routes;
     GetModelSafeRoutingInfo(&routes);
-    const syncer::ModelTypeSet expected_types = GetRoutingInfoTypes(routes);
+    const ModelTypeSet expected_types = GetRoutingInfoTypes(routes);
     EXPECT_TRUE(types.Equals(expected_types));
     ++update_enabled_types_call_count_;
   }
 
   void PumpLoop() {
     message_loop_.RunAllPending();
   }
 
   void SendJsMessage(const std::string& name, const JsArgList& args,
                      const WeakHandle<JsReplyHandler>& reply_handler) {
     js_backend_.Call(FROM_HERE, &JsBackend::ProcessJsMessage,
                      name, args, reply_handler);
     PumpLoop();
   }
 
   void SetJsEventHandler(const WeakHandle<JsEventHandler>& event_handler) {
     js_backend_.Call(FROM_HERE, &JsBackend::SetJsEventHandler,
                      event_handler);
     PumpLoop();
   }
 
   // Looks up an entry by client tag and resets IS_UNSYNCED value to false.
   // Returns true if entry was previously unsynced, false if IS_UNSYNCED was
   // already false.
-  bool ResetUnsyncedEntry(syncer::ModelType type,
+  bool ResetUnsyncedEntry(ModelType type,
                           const std::string& client_tag) {
     UserShare* share = sync_manager_.GetUserShare();
     syncable::WriteTransaction trans(
         FROM_HERE, syncable::UNITTEST, share->directory.get());
     const std::string hash = BaseNode::GenerateSyncableHash(type, client_tag);
     syncable::MutableEntry entry(&trans, syncable::GET_BY_CLIENT_TAG,
                                  hash);
     EXPECT_TRUE(entry.good());
     if (!entry.Get(IS_UNSYNCED))
       return false;
@@ skipping 15 matching lines @@
   std::map<ModelType, int64> type_roots_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
   StrictMock<SyncNotifierMock>* sync_notifier_mock_;
 
  protected:
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
   SyncManagerImpl sync_manager_;
   WeakHandle<JsBackend> js_backend_;
   StrictMock<SyncManagerObserverMock> observer_;
-  syncer::SyncNotifierObserver* sync_notifier_observer_;
+  SyncNotifierObserver* sync_notifier_observer_;
   int update_enabled_types_call_count_;
 };
 
 TEST_F(SyncManagerTest, UpdateEnabledTypes) {
   EXPECT_EQ(0, update_enabled_types_call_count_);
 
   ModelSafeRoutingInfo routes;
   GetModelSafeRoutingInfo(&routes);
-  const syncer::ModelTypeSet enabled_types = GetRoutingInfoTypes(routes);
+  const ModelTypeSet enabled_types = GetRoutingInfoTypes(routes);
 
   sync_manager_.UpdateEnabledTypes(enabled_types);
   EXPECT_EQ(1, update_enabled_types_call_count_);
 }
 
 TEST_F(SyncManagerTest, ProcessJsMessage) {
   const JsArgList kNoArgs;
 
   StrictMock<MockJsReplyHandler> reply_handler;
 
@@ skipping 61 matching lines @@
   void RunGetNodesByIdTest(const char* message_name, bool is_detailed) {
     int64 root_id = kInvalidId;
     {
       ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
       ReadNode root_node(&trans);
       root_node.InitByRootLookup();
       root_id = root_node.GetId();
     }
 
     int64 child_id =
-        MakeNode(sync_manager_.GetUserShare(), syncer::BOOKMARKS, "testtag");
+        MakeNode(sync_manager_.GetUserShare(), BOOKMARKS, "testtag");
 
     StrictMock<MockJsReplyHandler> reply_handler;
 
     JsArgList return_args;
 
     const int64 ids[] = { root_id, child_id };
 
     EXPECT_CALL(reply_handler,
                 HandleJsReply(message_name, _))
         .Times(arraysize(ids)).WillRepeatedly(SaveArg<1>(&return_args));
@@ skipping 210 matching lines @@
 
   EXPECT_CALL(event_handler,
               HandleJsEvent("onNotificationStateChange",
                             HasDetailsAsDictionary(true_details)));
   EXPECT_CALL(event_handler,
               HandleJsEvent("onNotificationStateChange",
                             HasDetailsAsDictionary(false_details)));
 
   sync_manager_.SimulateEnableNotificationsForTest();
   sync_manager_.SimulateDisableNotificationsForTest(
-      syncer::TRANSIENT_NOTIFICATION_ERROR);
+      TRANSIENT_NOTIFICATION_ERROR);
 
   SetJsEventHandler(event_handler.AsWeakHandle());
   sync_manager_.SimulateEnableNotificationsForTest();
   sync_manager_.SimulateDisableNotificationsForTest(
-      syncer::TRANSIENT_NOTIFICATION_ERROR);
+      TRANSIENT_NOTIFICATION_ERROR);
   SetJsEventHandler(WeakHandle<JsEventHandler>());
 
   sync_manager_.SimulateEnableNotificationsForTest();
   sync_manager_.SimulateDisableNotificationsForTest(
-      syncer::TRANSIENT_NOTIFICATION_ERROR);
+      TRANSIENT_NOTIFICATION_ERROR);
 
   // Should trigger the replies.
   PumpLoop();
 }
 
 TEST_F(SyncManagerTest, OnIncomingNotification) {
   StrictMock<MockJsEventHandler> event_handler;
 
-  const syncer::ModelTypeSet empty_model_types;
-  const syncer::ModelTypeSet model_types(
-      syncer::BOOKMARKS, syncer::THEMES);
+  const ModelTypeSet empty_model_types;
+  const ModelTypeSet model_types(
+      BOOKMARKS, THEMES);
 
   // Build expected_args to have a single argument with the string
   // equivalents of model_types.
   DictionaryValue expected_details;
   {
     ListValue* model_type_list = new ListValue();
     expected_details.SetString("source", "REMOTE_NOTIFICATION");
     expected_details.Set("changedTypes", model_type_list);
-    for (syncer::ModelTypeSet::Iterator it = model_types.First();
+    for (ModelTypeSet::Iterator it = model_types.First();
          it.Good(); it.Inc()) {
       model_type_list->Append(
-          Value::CreateStringValue(syncer::ModelTypeToString(it.Get())));
+          Value::CreateStringValue(ModelTypeToString(it.Get())));
     }
   }
 
   EXPECT_CALL(event_handler,
               HandleJsEvent("onIncomingNotification",
                             HasDetailsAsDictionary(expected_details)));
 
   sync_manager_.TriggerOnIncomingNotificationForTest(empty_model_types);
   sync_manager_.TriggerOnIncomingNotificationForTest(model_types);
 
   SetJsEventHandler(event_handler.AsWeakHandle());
   sync_manager_.TriggerOnIncomingNotificationForTest(model_types);
   SetJsEventHandler(WeakHandle<JsEventHandler>());
 
   sync_manager_.TriggerOnIncomingNotificationForTest(empty_model_types);
   sync_manager_.TriggerOnIncomingNotificationForTest(model_types);
 
   // Should trigger the replies.
   PumpLoop();
 }
 
 TEST_F(SyncManagerTest, RefreshEncryptionReady) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
 
-  const syncer::ModelTypeSet encrypted_types =
+  const ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
-  EXPECT_TRUE(encrypted_types.Has(syncer::PASSWORDS));
+  EXPECT_TRUE(encrypted_types.Has(PASSWORDS));
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByIdLookup(GetIdForDataType(syncer::NIGORI)));
+              node.InitByIdLookup(GetIdForDataType(NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encrypted());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
 // Attempt to refresh encryption when nigori not downloaded.
 TEST_F(SyncManagerTest, RefreshEncryptionNotReady) {
   // Don't set up encryption (no nigori node created).
 
   // Should fail.
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
 
-  const syncer::ModelTypeSet encrypted_types =
+  const ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
-  EXPECT_TRUE(encrypted_types.Has(syncer::PASSWORDS));  // Hardcoded.
+  EXPECT_TRUE(encrypted_types.Has(PASSWORDS));  // Hardcoded.
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
 }
 
 // Attempt to refresh encryption when nigori is empty.
 TEST_F(SyncManagerTest, RefreshEncryptionEmptyNigori) {
   EXPECT_TRUE(SetUpEncryption(DONT_WRITE_NIGORI, DEFAULT_ENCRYPTION));
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
   // Should write to nigori.
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
 
-  const syncer::ModelTypeSet encrypted_types =
+  const ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
-  EXPECT_TRUE(encrypted_types.Has(syncer::PASSWORDS));  // Hardcoded.
+  EXPECT_TRUE(encrypted_types.Has(PASSWORDS));  // Hardcoded.
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByIdLookup(GetIdForDataType(syncer::NIGORI)));
+              node.InitByIdLookup(GetIdForDataType(NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encrypted());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithNoData) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()), true));
+                  HasModelTypes(ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
   EXPECT_TRUE(sync_manager_.EncryptEverythingEnabledForTest());
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithData) {
   size_t batch_size = 5;
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
 
   // Create some unencrypted unsynced data.
   int64 folder = MakeFolderWithParent(sync_manager_.GetUserShare(),
-                                      syncer::BOOKMARKS,
-                                      GetIdForDataType(syncer::BOOKMARKS),
+                                      BOOKMARKS,
+                                      GetIdForDataType(BOOKMARKS),
                                       NULL);
   // First batch_size nodes are children of folder.
   size_t i;
   for (i = 0; i < batch_size; ++i) {
-    MakeNodeWithParent(sync_manager_.GetUserShare(), syncer::BOOKMARKS,
+    MakeNodeWithParent(sync_manager_.GetUserShare(), BOOKMARKS,
                        base::StringPrintf("%"PRIuS"", i), folder);
   }
   // Next batch_size nodes are a different type and on their own.
   for (; i < 2*batch_size; ++i) {
-    MakeNodeWithParent(sync_manager_.GetUserShare(), syncer::SESSIONS,
+    MakeNodeWithParent(sync_manager_.GetUserShare(), SESSIONS,
                        base::StringPrintf("%"PRIuS"", i),
-                       GetIdForDataType(syncer::SESSIONS));
+                       GetIdForDataType(SESSIONS));
   }
   // Last batch_size nodes are a third type that will not need encryption.
   for (; i < 3*batch_size; ++i) {
-    MakeNodeWithParent(sync_manager_.GetUserShare(), syncer::THEMES,
+    MakeNodeWithParent(sync_manager_.GetUserShare(), THEMES,
                        base::StringPrintf("%"PRIuS"", i),
-                       GetIdForDataType(syncer::THEMES));
+                       GetIdForDataType(THEMES));
   }
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(
         Cryptographer::SensitiveTypes()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::BOOKMARKS,
+        BOOKMARKS,
         false /* not encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::SESSIONS,
+        SESSIONS,
         false /* not encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::THEMES,
+        THEMES,
         false /* not encrypted */));
   }
 
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()), true));
+                  HasModelTypes(ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
   EXPECT_TRUE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(
-        syncer::ModelTypeSet::All()));
+        ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::BOOKMARKS,
+        BOOKMARKS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::SESSIONS,
+        SESSIONS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::THEMES,
+        THEMES,
         true /* is encrypted */));
   }
 
   // Trigger's a ReEncryptEverything with new passphrase.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   EXPECT_TRUE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
-    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(syncer::ModelTypeSet::All()));
+    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::BOOKMARKS,
+        BOOKMARKS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::SESSIONS,
+        SESSIONS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::THEMES,
+        THEMES,
         true /* is encrypted */));
   }
   // Calling EncryptDataTypes with an empty encrypted types should not trigger
   // a reencryption and should just notify immediately.
   // TODO(zea): add logic to ensure nothing was written.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_)).Times(0);
   EXPECT_CALL(observer_, OnPassphraseAccepted()).Times(0);
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
@@ skipping 60 matching lines @@
     // Store the default (soon to be old) key.
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     verifier.Bootstrap(bootstrap_token);
 
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
-    syncer::WriteNode::InitUniqueByCreationResult result =
-        password_node.InitUniqueByCreation(syncer::PASSWORDS,
+    WriteNode::InitUniqueByCreationResult result =
+        password_node.InitUniqueByCreation(PASSWORDS,
                                            root_node, "foo");
-    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
+    EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     password_node.SetPasswordSpecifics(data);
   }
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     // Verify the default key has changed.
     sync_pb::EncryptedData encrypted;
     cryptographer->GetKeys(&encrypted);
     EXPECT_FALSE(verifier.CanDecrypt(encrypted));
 
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              password_node.InitByClientTagLookup(syncer::PASSWORDS,
+              password_node.InitByClientTagLookup(PASSWORDS,
                                                   "foo"));
     const sync_pb::PasswordSpecificsData& data =
         password_node.GetPasswordSpecifics();
     EXPECT_EQ("secret", data.password_value());
   }
 }
 
 // Manually set the pending keys in the cryptographer/nigori to reflect the data
 // being encrypted with a new (unprovided) GAIA password, then supply the
 // password.
@@ skipping 189 matching lines @@
 TEST_F(SyncManagerTest, SetPassphraseWithEmptyPasswordNode) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   int64 node_id = 0;
   std::string tag = "foo";
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
-    syncer::WriteNode::InitUniqueByCreationResult result =
-        password_node.InitUniqueByCreation(syncer::PASSWORDS, root_node, tag);
-    EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
+    WriteNode::InitUniqueByCreationResult result =
+        password_node.InitUniqueByCreation(PASSWORDS, root_node, tag);
+    EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     node_id = password_node.GetId();
   }
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
-              password_node.InitByClientTagLookup(syncer::PASSWORDS,
+              password_node.InitByClientTagLookup(PASSWORDS,
                                                   tag));
   }
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode password_node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
               password_node.InitByIdLookup(node_id));
   }
 }
 
 TEST_F(SyncManagerTest, NudgeDelayTest) {
-  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncer::BOOKMARKS),
+  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(BOOKMARKS),
       base::TimeDelta::FromMilliseconds(
           SyncManagerImpl::GetDefaultNudgeDelay()));
 
-  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncer::AUTOFILL),
+  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(AUTOFILL),
       base::TimeDelta::FromSeconds(
-          syncer::kDefaultShortPollIntervalSeconds));
+          kDefaultShortPollIntervalSeconds));
 
-  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncer::PREFERENCES),
+  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(PREFERENCES),
       base::TimeDelta::FromMilliseconds(
           SyncManagerImpl::GetPreferencesNudgeDelay()));
 }
 
 // Friended by WriteNode, so can't be in an anonymouse namespace.
 TEST_F(SyncManagerTest, EncryptBookmarksWithLegacyData) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   std::string title;
   SyncAPINameToServerName("Google", &title);
   std::string url = "http://www.google.com";
   std::string raw_title2 = "..";  // An invalid cosmo title.
   std::string title2;
   SyncAPINameToServerName(raw_title2, &title2);
   std::string url2 = "http://www.bla.com";
 
   // Create a bookmark using the legacy format.
   int64 node_id1 = MakeNode(sync_manager_.GetUserShare(),
-      syncer::BOOKMARKS,
+      BOOKMARKS,
       "testtag");
   int64 node_id2 = MakeNode(sync_manager_.GetUserShare(),
-      syncer::BOOKMARKS,
+      BOOKMARKS,
       "testtag2");
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
 
     sync_pb::EntitySpecifics entity_specifics;
     entity_specifics.mutable_bookmark()->set_url(url);
     node.SetEntitySpecifics(entity_specifics);
 
@@ skipping 10 matching lines @@
 
     // Set the old style title.
     syncable::MutableEntry* node_entry2 = node2.entry_;
     node_entry2->Put(syncable::NON_UNIQUE_NAME, title2);
   }
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
-    EXPECT_EQ(syncer::BOOKMARKS, node.GetModelType());
+    EXPECT_EQ(BOOKMARKS, node.GetModelType());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(title, node.GetBookmarkSpecifics().title());
     EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
 
     ReadNode node2(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, node2.InitByIdLookup(node_id2));
-    EXPECT_EQ(syncer::BOOKMARKS, node2.GetModelType());
+    EXPECT_EQ(BOOKMARKS, node2.GetModelType());
     // We should de-canonicalize the title in GetTitle(), but the title in the
     // specifics should be stored in the server legal form.
     EXPECT_EQ(raw_title2, node2.GetTitle());
     EXPECT_EQ(title2, node2.GetBookmarkSpecifics().title());
     EXPECT_EQ(url2, node2.GetBookmarkSpecifics().url());
   }
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::BOOKMARKS,
+        BOOKMARKS,
         false /* not encrypted */));
   }
 
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()), true));
+                  HasModelTypes(ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
   EXPECT_TRUE(sync_manager_.EncryptEverythingEnabledForTest());
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
-    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(syncer::ModelTypeSet::All()));
+    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncer::BOOKMARKS,
+        BOOKMARKS,
         true /* is encrypted */));
 
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
-    EXPECT_EQ(syncer::BOOKMARKS, node.GetModelType());
+    EXPECT_EQ(BOOKMARKS, node.GetModelType());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(title, node.GetBookmarkSpecifics().title());
     EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
 
     ReadNode node2(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, node2.InitByIdLookup(node_id2));
-    EXPECT_EQ(syncer::BOOKMARKS, node2.GetModelType());
+    EXPECT_EQ(BOOKMARKS, node2.GetModelType());
     // We should de-canonicalize the title in GetTitle(), but the title in the
     // specifics should be stored in the server legal form.
     EXPECT_EQ(raw_title2, node2.GetTitle());
     EXPECT_EQ(title2, node2.GetBookmarkSpecifics().title());
     EXPECT_EQ(url2, node2.GetBookmarkSpecifics().url());
   }
 }
 
 // Create a bookmark and set the title/url, then verify the data was properly
 // set. This replicates the unique way bookmarks have of creating sync nodes.
 // See BookmarkChangeProcessor::PlaceSyncNode(..).
 TEST_F(SyncManagerTest, CreateLocalBookmark) {
   std::string title = "title";
   GURL url("url");
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
     WriteNode node(&trans);
-    ASSERT_TRUE(node.InitByCreation(syncer::BOOKMARKS, root_node, NULL));
+    ASSERT_TRUE(node.InitByCreation(BOOKMARKS, root_node, NULL));
     node.SetIsFolder(false);
     node.SetTitle(UTF8ToWide(title));
     node.SetURL(url);
   }
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
     int64 child_id = root_node.GetFirstChildId();
 
     ReadNode node(&trans);
     ASSERT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
     EXPECT_FALSE(node.GetIsFolder());
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(url, node.GetURL());
   }
 }
 
 // Verifies WriteNode::UpdateEntryWithEncryption does not make unnecessary
 // changes.
 TEST_F(SyncManagerTest, UpdateEntryWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("url");
   entity_specifics.mutable_bookmark()->set_title("title");
-  MakeServerNode(sync_manager_.GetUserShare(), syncer::BOOKMARKS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::BOOKMARKS,
+  MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
+                 BaseNode::GenerateSyncableHash(BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
   // Manually change to the same data. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()), true));
+                  HasModelTypes(ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
 
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
-  EXPECT_TRUE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Set a new passphrase. Should set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
-  EXPECT_TRUE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to the same data. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_FALSE(node_entry->Get(IS_UNSYNCED));
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to different data. Should set is_unsynced.
   {
     entity_specifics.mutable_bookmark()->set_url("url2");
     entity_specifics.mutable_bookmark()->set_title("title2");
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_TRUE(node_entry->Get(IS_UNSYNCED));
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
                     specifics.encrypted()));
   }
 }
 
 // Passwords have their own handling for encryption. Verify it does not result
 // in unnecessary writes via SetEntitySpecifics.
 TEST_F(SyncManagerTest, UpdatePasswordSetEntitySpecificsNoChange) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
         data,
         entity_specifics.mutable_password()->
             mutable_encrypted());
   }
-  MakeServerNode(sync_manager_.GetUserShare(), syncer::PASSWORDS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::PASSWORDS,
+  MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
+                 BaseNode::GenerateSyncableHash(PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Manually change to the same data via SetEntitySpecifics. Should not set
   // is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::PASSWORDS, client_tag));
+              node.InitByClientTagLookup(PASSWORDS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 }
 
 // Passwords have their own handling for encryption. Verify it does not result
 // in unnecessary writes via SetPasswordSpecifics.
 TEST_F(SyncManagerTest, UpdatePasswordSetPasswordSpecifics) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
         data,
         entity_specifics.mutable_password()->
             mutable_encrypted());
   }
-  MakeServerNode(sync_manager_.GetUserShare(), syncer::PASSWORDS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::PASSWORDS,
+  MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
+                 BaseNode::GenerateSyncableHash(PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Manually change to the same data via SetPasswordSpecifics. Should not set
   // is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::PASSWORDS, client_tag));
+              node.InitByClientTagLookup(PASSWORDS, client_tag));
     node.SetPasswordSpecifics(node.GetPasswordSpecifics());
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Manually change to different data. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::PASSWORDS, client_tag));
+              node.InitByClientTagLookup(PASSWORDS, client_tag));
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret2");
     cryptographer->Encrypt(
         data,
         entity_specifics.mutable_password()->mutable_encrypted());
     node.SetPasswordSpecifics(data);
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_TRUE(node_entry->Get(IS_UNSYNCED));
   }
 }
 
 // Passwords have their own handling for encryption. Verify setting a new
 // passphrase updates the data.
 TEST_F(SyncManagerTest, UpdatePasswordNewPassphrase) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
         data,
         entity_specifics.mutable_password()->mutable_encrypted());
   }
-  MakeServerNode(sync_manager_.GetUserShare(), syncer::PASSWORDS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::PASSWORDS,
+  MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
+                 BaseNode::GenerateSyncableHash(PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Set a new passphrase. Should set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
-  EXPECT_TRUE(ResetUnsyncedEntry(syncer::PASSWORDS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 }
 
 // Passwords have their own handling for encryption. Verify it does not result
 // in unnecessary writes via ReencryptEverything.
 TEST_F(SyncManagerTest, UpdatePasswordReencryptEverything) {
   std::string client_tag = "title";
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   sync_pb::EntitySpecifics entity_specifics;
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     sync_pb::PasswordSpecificsData data;
     data.set_password_value("secret");
     cryptographer->Encrypt(
         data,
         entity_specifics.mutable_password()->mutable_encrypted());
   }
-  MakeServerNode(sync_manager_.GetUserShare(), syncer::PASSWORDS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::PASSWORDS,
+  MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
+                 BaseNode::GenerateSyncableHash(PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for bookmarks
 // when we write the same data, but does set it when we write new data.
 TEST_F(SyncManagerTest, SetBookmarkTitle) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("url");
   entity_specifics.mutable_bookmark()->set_title("title");
-  MakeServerNode(sync_manager_.GetUserShare(), syncer::BOOKMARKS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::BOOKMARKS,
+  MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
+                 BaseNode::GenerateSyncableHash(BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to new title. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
   }
-  EXPECT_TRUE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // bookmarks when we write the same data, but does set it when we write new
 // data.
 TEST_F(SyncManagerTest, SetBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("url");
   entity_specifics.mutable_bookmark()->set_title("title");
-  MakeServerNode(sync_manager_.GetUserShare(), syncer::BOOKMARKS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::BOOKMARKS,
+  MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
+                 BaseNode::GenerateSyncableHash(BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()), true));
+                  HasModelTypes(ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
-  EXPECT_TRUE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to new title. Should set is_unsynced. NON_UNIQUE_NAME
   // should still be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
   }
-  EXPECT_TRUE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for non-bookmarks
 // when we write the same data, but does set it when we write new data.
 TEST_F(SyncManagerTest, SetNonBookmarkTitle) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_preference()->set_name("name");
   entity_specifics.mutable_preference()->set_value("value");
   MakeServerNode(sync_manager_.GetUserShare(),
-                 syncer::PREFERENCES,
+                 PREFERENCES,
                  client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::PREFERENCES,
+                 BaseNode::GenerateSyncableHash(PREFERENCES,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PREFERENCES, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::PREFERENCES, client_tag));
+              node.InitByClientTagLookup(PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PREFERENCES, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to new title. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::PREFERENCES, client_tag));
+              node.InitByClientTagLookup(PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
   }
-  EXPECT_TRUE(ResetUnsyncedEntry(syncer::PREFERENCES, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // non-bookmarks when we write the same data or when we write new data
 // data (should remained kEncryptedString).
 TEST_F(SyncManagerTest, SetNonBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_preference()->set_name("name");
   entity_specifics.mutable_preference()->set_value("value");
   MakeServerNode(sync_manager_.GetUserShare(),
-                 syncer::PREFERENCES,
+                 PREFERENCES,
                  client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::PREFERENCES,
+                 BaseNode::GenerateSyncableHash(PREFERENCES,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PREFERENCES, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncer::ModelTypeSet::All()), true));
+                  HasModelTypes(ModelTypeSet::All()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
   sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
   PumpLoop();
-  EXPECT_TRUE(ResetUnsyncedEntry(syncer::PREFERENCES, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::PREFERENCES, client_tag));
+              node.InitByClientTagLookup(PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PREFERENCES, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to new title. Should not set is_unsynced because the
   // NON_UNIQUE_NAME should still be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::PREFERENCES, client_tag));
+              node.InitByClientTagLookup(PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     EXPECT_FALSE(node_entry->Get(IS_UNSYNCED));
   }
 }
 
 // Create an encrypted entry when the cryptographer doesn't think the type is
 // marked for encryption. Ensure reads/writes don't break and don't unencrypt
 // the data.
 TEST_F(SyncManagerTest, SetPreviouslyEncryptedSpecifics) {
   std::string client_tag = "tag";
   std::string url = "url";
   std::string url2 = "new_url";
   std::string title = "title";
   sync_pb::EntitySpecifics entity_specifics;
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
-    syncer::Cryptographer* crypto = trans.GetCryptographer();
+    Cryptographer* crypto = trans.GetCryptographer();
     sync_pb::EntitySpecifics bm_specifics;
     bm_specifics.mutable_bookmark()->set_title("title");
     bm_specifics.mutable_bookmark()->set_url("url");
     sync_pb::EncryptedData encrypted;
     crypto->Encrypt(bm_specifics, &encrypted);
     entity_specifics.mutable_encrypted()->CopyFrom(encrypted);
-    syncer::AddDefaultFieldValue(syncer::BOOKMARKS, &entity_specifics);
+    AddDefaultFieldValue(BOOKMARKS, &entity_specifics);
   }
-  MakeServerNode(sync_manager_.GetUserShare(), syncer::BOOKMARKS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncer::BOOKMARKS,
+  MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
+                 BaseNode::GenerateSyncableHash(BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
 
   {
     // Verify the data.
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(GURL(url), node.GetURL());
   }
 
   {
     // Overwrite the url (which overwrites the specifics).
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetURL(GURL(url2));
   }
 
   {
     // Verify it's still encrypted and it has the most recent url.
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(BOOKMARKS, client_tag));
     EXPECT_EQ(title, node.GetTitle());
     EXPECT_EQ(GURL(url2), node.GetURL());
     const syncable::Entry* node_entry = node.GetEntry();
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
   }
 }
 
 class MockSyncScheduler : public FakeSyncScheduler {
@@ skipping 28 matching lines @@
     scheduler_ = new MockSyncScheduler();
     return new ComponentsFactory(scheduler_);
   }
   MockSyncScheduler* scheduler_;
 };
 
 // Test that the configuration params are properly created and sent to
 // ScheduleConfigure. No callback should be invoked.
 TEST_F(SyncManagerTestWithMockScheduler, BasicConfiguration) {
   ConfigureReason reason = CONFIGURE_REASON_RECONFIGURATION;
-  syncer::ModelTypeSet types_to_download(syncer::BOOKMARKS,
-                                         syncer::PREFERENCES);
-  syncer::ModelSafeRoutingInfo new_routing_info;
+  ModelTypeSet types_to_download(BOOKMARKS, PREFERENCES);
+  ModelSafeRoutingInfo new_routing_info;
   GetModelSafeRoutingInfo(&new_routing_info);
 
   ConfigurationParams params;
   EXPECT_CALL(*scheduler_, Start(SyncScheduler::CONFIGURATION_MODE));
   EXPECT_CALL(*scheduler_, ScheduleConfiguration(_)).
       WillOnce(DoAll(SaveArg<0>(&params), Return(true)));
 
   CallbackCounter ready_task_counter, retry_task_counter;
   sync_manager_.ConfigureSyncer(
       reason,
       types_to_download,
       new_routing_info,
       base::Bind(&CallbackCounter::Callback,
                  base::Unretained(&ready_task_counter)),
       base::Bind(&CallbackCounter::Callback,
                  base::Unretained(&retry_task_counter)));
   EXPECT_EQ(0, ready_task_counter.times_called());
   EXPECT_EQ(0, retry_task_counter.times_called());
   EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
             params.source);
   EXPECT_TRUE(types_to_download.Equals(params.types_to_download));
   EXPECT_EQ(new_routing_info, params.routing_info);
 }
 
 // Test that the retry callback is invoked on configuration failure.
 TEST_F(SyncManagerTestWithMockScheduler, ConfigurationRetry) {
   ConfigureReason reason = CONFIGURE_REASON_RECONFIGURATION;
-  syncer::ModelTypeSet types_to_download(syncer::BOOKMARKS,
-                                         syncer::PREFERENCES);
-  syncer::ModelSafeRoutingInfo new_routing_info;
+  ModelTypeSet types_to_download(BOOKMARKS, PREFERENCES);
+  ModelSafeRoutingInfo new_routing_info;
   GetModelSafeRoutingInfo(&new_routing_info);
 
   ConfigurationParams params;
   EXPECT_CALL(*scheduler_, Start(SyncScheduler::CONFIGURATION_MODE));
   EXPECT_CALL(*scheduler_, ScheduleConfiguration(_)).
       WillOnce(DoAll(SaveArg<0>(&params), Return(false)));
 
   CallbackCounter ready_task_counter, retry_task_counter;
   sync_manager_.ConfigureSyncer(
       reason,
@@ skipping 47 matching lines @@
   // Ensure only bookmarks and nigori lost their progress marker. Preferences
   // should still have it.
   partial_types =
       sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All());
   EXPECT_TRUE(partial_types.Has(NIGORI));
   EXPECT_TRUE(partial_types.Has(BOOKMARKS));
   EXPECT_FALSE(partial_types.Has(PREFERENCES));
 }
 
 }  // namespace