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

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 63 matching lines @@
 using testing::Invoke;
 using testing::SaveArg;
 using testing::StrictMock;
 
 namespace syncer {
 
 using sessions::SyncSessionSnapshot;
 using syncable::IS_DEL;
 using syncable::IS_UNSYNCED;
 using syncable::kEncryptedString;
-using syncable::ModelTypeSet;
-using syncable::ModelType;
 using syncable::NON_UNIQUE_NAME;
 using syncable::SPECIFICS;
 
 namespace {
 
 const char kTestChromeVersion[] = "test chrome version";
 
 void DoNothing() {}
 
 void ExpectInt64Value(int64 expected_value,
@@ skipping 59 matching lines @@
   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;
-  syncable::AddDefaultFieldValue(model_type, &specifics);
+  syncer::AddDefaultFieldValue(model_type, &specifics);
   syncable::WriteTransaction trans(
       FROM_HERE, syncable::UNITTEST, share->directory.get());
   // Attempt to lookup by nigori tag.
-  std::string type_tag = syncable::ModelTypeToRootTag(model_type);
+  std::string type_tag = syncer::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,
-                             syncable::ModelTypeToRootTag(model_type));
+                             syncer::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 45 matching lines @@
 
 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(),
-                         syncable::BOOKMARKS, "testtag"));
+                         syncer::BOOKMARKS, "testtag"));
 
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByClientTagLookup(syncable::BOOKMARKS, "testtag"));
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, "tag1"));
+      BaseNode::GenerateSyncableHash(syncer::BOOKMARKS, "tag1"));
   EXPECT_EQ("iNFQtRFQb+IZcn1kKUJEZDDkLs4=",
-      BaseNode::GenerateSyncableHash(syncable::PREFERENCES, "tag1"));
+      BaseNode::GenerateSyncableHash(syncer::PREFERENCES, "tag1"));
   EXPECT_EQ("gO1cPZQXaM73sHOvSA+tKCKFs58=",
-      BaseNode::GenerateSyncableHash(syncable::AUTOFILL, "tag1"));
+      BaseNode::GenerateSyncableHash(syncer::AUTOFILL, "tag1"));
 
   EXPECT_EQ("A0eYIHXM1/jVwKDDp12Up20IkKY=",
-      BaseNode::GenerateSyncableHash(syncable::BOOKMARKS, "tag2"));
+      BaseNode::GenerateSyncableHash(syncer::BOOKMARKS, "tag2"));
   EXPECT_EQ("XYxkF7bhS4eItStFgiOIAU23swI=",
-      BaseNode::GenerateSyncableHash(syncable::PREFERENCES, "tag2"));
+      BaseNode::GenerateSyncableHash(syncer::PREFERENCES, "tag2"));
   EXPECT_EQ("GFiWzo5NGhjLlN+OyCfhy28DJTQ=",
-      BaseNode::GenerateSyncableHash(syncable::AUTOFILL, "tag2"));
+      BaseNode::GenerateSyncableHash(syncer::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(),
-                         syncable::BOOKMARKS, "collideme"));
+                         syncer::BOOKMARKS, "collideme"));
   ignore_result(MakeNode(test_user_share_.user_share(),
-                         syncable::PREFERENCES, "collideme"));
+                         syncer::PREFERENCES, "collideme"));
   ignore_result(MakeNode(test_user_share_.user_share(),
-                         syncable::AUTOFILL, "collideme"));
+                         syncer::AUTOFILL, "collideme"));
 
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
 
     ReadNode bookmarknode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              bookmarknode.InitByClientTagLookup(syncable::BOOKMARKS,
+              bookmarknode.InitByClientTagLookup(syncer::BOOKMARKS,
                   "collideme"));
 
     ReadNode prefnode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              prefnode.InitByClientTagLookup(syncable::PREFERENCES,
+              prefnode.InitByClientTagLookup(syncer::PREFERENCES,
                   "collideme"));
 
     ReadNode autofillnode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              autofillnode.InitByClientTagLookup(syncable::AUTOFILL,
+              autofillnode.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS,
+              node.InitByClientTagLookup(syncer::BOOKMARKS,
                   "testtag"));
   }
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
-              node.InitByClientTagLookup(syncable::BOOKMARKS,
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS,
+    EXPECT_TRUE(folder_node.InitByCreation(syncer::BOOKMARKS,
         root_node, NULL));
     folder_id = folder_node.GetId();
 
     WriteNode wnode(&trans);
     syncer::WriteNode::InitUniqueByCreationResult result =
-        wnode.InitUniqueByCreation(syncable::BOOKMARKS, root_node, "testtag");
+        wnode.InitUniqueByCreation(syncer::BOOKMARKS, root_node, "testtag");
     EXPECT_EQ(syncer::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(syncable::BOOKMARKS,
+              wnode.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS,
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, folder_node, "testtag");
+        wnode.InitUniqueByCreation(syncer::BOOKMARKS, folder_node, "testtag");
     EXPECT_EQ(syncer::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(syncable::BOOKMARKS,
+              node.InitByClientTagLookup(syncer::BOOKMARKS,
                     "testtag"));
     EXPECT_EQ(node.GetTitle(), test_title);
-    EXPECT_EQ(node.GetModelType(), syncable::BOOKMARKS);
+    EXPECT_EQ(node.GetModelType(), syncer::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(syncable::PASSWORDS,
+        password_node.InitUniqueByCreation(syncer::PASSWORDS,
                                            root_node, "foo");
     EXPECT_EQ(syncer::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(syncable::PASSWORDS,
+              password_node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS,
+        bookmark_node.InitUniqueByCreation(syncer::BOOKMARKS,
                                            root_node, "foo");
     EXPECT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     bookmark_node.SetTitle(UTF8ToWide("foo"));
 
     WriteNode pref_node(&trans);
     result =
-        pref_node.InitUniqueByCreation(syncable::PREFERENCES, root_node, "bar");
+        pref_node.InitUniqueByCreation(syncer::PREFERENCES, root_node, "bar");
     EXPECT_EQ(syncer::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(syncable::BOOKMARKS,
+              bookmark_node.InitByClientTagLookup(syncer::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(syncable::PREFERENCES,
+              pref_node.InitByClientTagLookup(syncer::PREFERENCES,
                                               "bar"));
     EXPECT_EQ(kEncryptedString, pref_node.GetTitle());
   }
 }
 
 TEST_F(SyncApiTest, BaseNodeSetSpecifics) {
   int64 child_id = MakeNode(test_user_share_.user_share(),
-                            syncable::BOOKMARKS, "testtag");
+                            syncer::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(),
-                            syncable::BOOKMARKS, "testtag");
+                            syncer::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 >= syncable::FIRST_REAL_MODEL_TYPE) {
-      ModelType model_type =
-          syncable::ModelTypeFromString(type_str);
+    if (expected_model_type >= syncer::FIRST_REAL_MODEL_TYPE) {
+      ModelType model_type = syncer::ModelTypeFromString(type_str);
       EXPECT_EQ(expected_model_type, model_type);
-    } else if (expected_model_type == syncable::TOP_LEVEL_FOLDER) {
+    } else if (expected_model_type == syncer::TOP_LEVEL_FOLDER) {
       EXPECT_EQ("Top-level folder", type_str);
-    } else if (expected_model_type == syncable::UNSPECIFIED) {
+    } else if (expected_model_type == syncer::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 37 matching lines @@
   }
 }
 
 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(syncable::TYPED_URLS, root_node, empty_tag);
+      node.InitUniqueByCreation(syncer::TYPED_URLS, root_node, empty_tag);
   EXPECT_NE(syncer::WriteNode::INIT_SUCCESS, result);
   EXPECT_EQ(BaseNode::INIT_FAILED_PRECONDITION,
             node.InitByTagLookup(empty_tag));
 }
 
 namespace {
 
 class TestHttpPostProviderInterface : public HttpPostProviderInterface {
  public:
   virtual ~TestHttpPostProviderInterface() {}
@@ skipping 54 matching lines @@
 
 class SyncNotifierMock : public syncer::SyncNotifier {
  public:
   MOCK_METHOD1(AddObserver, void(syncer::SyncNotifierObserver*));
   MOCK_METHOD1(RemoveObserver, void(syncer::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(syncable::ModelTypeSet));
-  MOCK_METHOD1(SendNotification, void(syncable::ModelTypeSet));
+               void(syncer::ModelTypeSet));
+  MOCK_METHOD1(SendNotification, void(syncer::ModelTypeSet));
 };
 
 }  // namespace
 
 class SyncManagerTest : public testing::Test,
                         public SyncManager::ChangeDelegate {
  protected:
   enum NigoriStatus {
     DONT_WRITE_NIGORI,
     WRITE_TO_NIGORI
@@ skipping 76 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)[syncable::NIGORI] = syncer::GROUP_PASSIVE;
-    (*out)[syncable::BOOKMARKS] = syncer::GROUP_PASSIVE;
-    (*out)[syncable::THEMES] = syncer::GROUP_PASSIVE;
-    (*out)[syncable::SESSIONS] = syncer::GROUP_PASSIVE;
-    (*out)[syncable::PASSWORDS] = syncer::GROUP_PASSIVE;
-    (*out)[syncable::PREFERENCES] = syncer::GROUP_PASSIVE;
+    (*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;
   }
 
   virtual void OnChangesApplied(
-      syncable::ModelType model_type,
+      syncer::ModelType model_type,
       const BaseTransaction* trans,
       const ImmutableChangeRecordList& changes) OVERRIDE {}
 
-  virtual void OnChangesComplete(syncable::ModelType model_type) OVERRIDE {}
+  virtual void OnChangesComplete(syncer::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(syncable::NIGORI, true);
+    share->directory->set_initial_sync_ended_for_type(syncer::NIGORI, true);
 
     // We need to create the nigori node as if it were an applied server update.
-    int64 nigori_id = GetIdForDataType(syncable::NIGORI);
+    int64 nigori_id = GetIdForDataType(syncer::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 25 matching lines @@
     EXPECT_EQ(NULL, sync_notifier_observer_);
     sync_notifier_observer_ = sync_notifier_observer;
   }
 
   void SyncNotifierRemoveObserver(
       syncer::SyncNotifierObserver* sync_notifier_observer) {
     EXPECT_EQ(sync_notifier_observer_, sync_notifier_observer);
     sync_notifier_observer_ = NULL;
   }
 
-  void SyncNotifierUpdateEnabledTypes(syncable::ModelTypeSet types) {
+  void SyncNotifierUpdateEnabledTypes(syncer::ModelTypeSet types) {
     ModelSafeRoutingInfo routes;
     GetModelSafeRoutingInfo(&routes);
-    const syncable::ModelTypeSet expected_types =
-        GetRoutingInfoTypes(routes);
+    const syncer::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(syncable::ModelType type,
+  bool ResetUnsyncedEntry(syncer::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 19 matching lines @@
   StrictMock<SyncManagerObserverMock> observer_;
   syncer::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 syncable::ModelTypeSet enabled_types =
-        GetRoutingInfoTypes(routes);
+  const syncer::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(),
-                 syncable::BOOKMARKS, "testtag");
+        MakeNode(sync_manager_.GetUserShare(), syncer::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 229 matching lines @@
   sync_manager_.SimulateDisableNotificationsForTest(
       syncer::TRANSIENT_NOTIFICATION_ERROR);
 
   // Should trigger the replies.
   PumpLoop();
 }
 
 TEST_F(SyncManagerTest, OnIncomingNotification) {
   StrictMock<MockJsEventHandler> event_handler;
 
-  const syncable::ModelTypeSet empty_model_types;
-  const syncable::ModelTypeSet model_types(
-      syncable::BOOKMARKS, syncable::THEMES);
+  const syncer::ModelTypeSet empty_model_types;
+  const syncer::ModelTypeSet model_types(
+      syncer::BOOKMARKS, syncer::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 (syncable::ModelTypeSet::Iterator it = model_types.First();
+    for (syncer::ModelTypeSet::Iterator it = model_types.First();
          it.Good(); it.Inc()) {
       model_type_list->Append(
-          Value::CreateStringValue(
-              syncable::ModelTypeToString(it.Get())));
+          Value::CreateStringValue(syncer::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 syncable::ModelTypeSet encrypted_types =
+  const syncer::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
-  EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));
+  EXPECT_TRUE(encrypted_types.Has(syncer::PASSWORDS));
   EXPECT_FALSE(sync_manager_.EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
-              node.InitByIdLookup(GetIdForDataType(syncable::NIGORI)));
+              node.InitByIdLookup(GetIdForDataType(syncer::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 syncable::ModelTypeSet encrypted_types =
+  const syncer::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
-  EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));  // Hardcoded.
+  EXPECT_TRUE(encrypted_types.Has(syncer::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 syncable::ModelTypeSet encrypted_types =
+  const syncer::ModelTypeSet encrypted_types =
       sync_manager_.GetEncryptedDataTypesForTest();
-  EXPECT_TRUE(encrypted_types.Has(syncable::PASSWORDS));  // Hardcoded.
+  EXPECT_TRUE(encrypted_types.Has(syncer::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(syncable::NIGORI)));
+              node.InitByIdLookup(GetIdForDataType(syncer::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(syncable::ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::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(),
-                                      syncable::BOOKMARKS,
-                                      GetIdForDataType(syncable::BOOKMARKS),
+                                      syncer::BOOKMARKS,
+                                      GetIdForDataType(syncer::BOOKMARKS),
                                       NULL);
   // First batch_size nodes are children of folder.
   size_t i;
   for (i = 0; i < batch_size; ++i) {
-    MakeNodeWithParent(sync_manager_.GetUserShare(), syncable::BOOKMARKS,
+    MakeNodeWithParent(sync_manager_.GetUserShare(), syncer::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(), syncable::SESSIONS,
+    MakeNodeWithParent(sync_manager_.GetUserShare(), syncer::SESSIONS,
                        base::StringPrintf("%"PRIuS"", i),
-                       GetIdForDataType(syncable::SESSIONS));
+                       GetIdForDataType(syncer::SESSIONS));
   }
   // Last batch_size nodes are a third type that will not need encryption.
   for (; i < 3*batch_size; ++i) {
-    MakeNodeWithParent(sync_manager_.GetUserShare(), syncable::THEMES,
+    MakeNodeWithParent(sync_manager_.GetUserShare(), syncer::THEMES,
                        base::StringPrintf("%"PRIuS"", i),
-                       GetIdForDataType(syncable::THEMES));
+                       GetIdForDataType(syncer::THEMES));
   }
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(
         Cryptographer::SensitiveTypes()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::BOOKMARKS,
+        syncer::BOOKMARKS,
         false /* not encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::SESSIONS,
+        syncer::SESSIONS,
         false /* not encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::THEMES,
+        syncer::THEMES,
         false /* not encrypted */));
   }
 
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::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(
-        syncable::ModelTypeSet::All()));
+        syncer::ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::BOOKMARKS,
+        syncer::BOOKMARKS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::SESSIONS,
+        syncer::SESSIONS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::THEMES,
+        syncer::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(
-        syncable::ModelTypeSet::All()));
+    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(syncer::ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::BOOKMARKS,
+        syncer::BOOKMARKS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::SESSIONS,
+        syncer::SESSIONS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::THEMES,
+        syncer::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 61 matching lines @@
     Cryptographer* cryptographer = trans.GetCryptographer();
     std::string bootstrap_token;
     cryptographer->GetBootstrapToken(&bootstrap_token);
     verifier.Bootstrap(bootstrap_token);
 
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode password_node(&trans);
     syncer::WriteNode::InitUniqueByCreationResult result =
-        password_node.InitUniqueByCreation(syncable::PASSWORDS,
+        password_node.InitUniqueByCreation(syncer::PASSWORDS,
                                            root_node, "foo");
     EXPECT_EQ(syncer::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(syncable::PASSWORDS,
+              password_node.InitByClientTagLookup(syncer::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 190 matching lines @@
   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(syncable::PASSWORDS, root_node, tag);
+        password_node.InitUniqueByCreation(syncer::PASSWORDS, root_node, tag);
     EXPECT_EQ(syncer::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(syncable::PASSWORDS,
+              password_node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS),
+  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncer::BOOKMARKS),
       base::TimeDelta::FromMilliseconds(
           SyncManager::kDefaultNudgeDelayMilliseconds));
 
-  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncable::AUTOFILL),
+  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncer::AUTOFILL),
       base::TimeDelta::FromSeconds(
           syncer::kDefaultShortPollIntervalSeconds));
 
-  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncable::PREFERENCES),
+  EXPECT_EQ(sync_manager_.GetNudgeDelayTimeDelta(syncer::PREFERENCES),
       base::TimeDelta::FromMilliseconds(
           SyncManager::kPreferencesNudgeDelayMilliseconds));
 }
 
 // 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(),
-      syncable::BOOKMARKS,
+      syncer::BOOKMARKS,
       "testtag");
   int64 node_id2 = MakeNode(sync_manager_.GetUserShare(),
-      syncable::BOOKMARKS,
+      syncer::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(syncable::BOOKMARKS, node.GetModelType());
+    EXPECT_EQ(syncer::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(syncable::BOOKMARKS, node2.GetModelType());
+    EXPECT_EQ(syncer::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(),
-        syncable::BOOKMARKS,
+        syncer::BOOKMARKS,
         false /* not encrypted */));
   }
 
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::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(
-        syncable::ModelTypeSet::All()));
+    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(syncer::ModelTypeSet::All()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
-        syncable::BOOKMARKS,
+        syncer::BOOKMARKS,
         true /* is encrypted */));
 
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
-    EXPECT_EQ(syncable::BOOKMARKS, node.GetModelType());
+    EXPECT_EQ(syncer::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(syncable::BOOKMARKS, node2.GetModelType());
+    EXPECT_EQ(syncer::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(syncable::BOOKMARKS, root_node, NULL));
+    ASSERT_TRUE(node.InitByCreation(syncer::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(), syncable::BOOKMARKS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
+  MakeServerNode(sync_manager_.GetUserShare(), syncer::BOOKMARKS, client_tag,
+                 BaseNode::GenerateSyncableHash(syncer::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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(), syncable::PASSWORDS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::PASSWORDS,
+  MakeServerNode(sync_manager_.GetUserShare(), syncer::PASSWORDS, client_tag,
+                 BaseNode::GenerateSyncableHash(syncer::PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::PASSWORDS, client_tag));
+              node.InitByClientTagLookup(syncer::PASSWORDS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(), syncable::PASSWORDS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::PASSWORDS,
+  MakeServerNode(sync_manager_.GetUserShare(), syncer::PASSWORDS, client_tag,
+                 BaseNode::GenerateSyncableHash(syncer::PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::PASSWORDS, client_tag));
+              node.InitByClientTagLookup(syncer::PASSWORDS, client_tag));
     node.SetPasswordSpecifics(node.GetPasswordSpecifics());
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::PASSWORDS, client_tag));
+              node.InitByClientTagLookup(syncer::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(), syncable::PASSWORDS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::PASSWORDS,
+  MakeServerNode(sync_manager_.GetUserShare(), syncer::PASSWORDS, client_tag,
+                 BaseNode::GenerateSyncableHash(syncer::PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::PASSWORDS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(syncer::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(), syncable::PASSWORDS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::PASSWORDS,
+  MakeServerNode(sync_manager_.GetUserShare(), syncer::PASSWORDS, client_tag,
+                 BaseNode::GenerateSyncableHash(syncer::PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::PASSWORDS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(), syncable::BOOKMARKS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
+  MakeServerNode(sync_manager_.GetUserShare(), syncer::BOOKMARKS, client_tag,
+                 BaseNode::GenerateSyncableHash(syncer::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
   }
-  EXPECT_TRUE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(syncer::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(), syncable::BOOKMARKS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
+  MakeServerNode(sync_manager_.GetUserShare(), syncer::BOOKMARKS, client_tag,
+                 BaseNode::GenerateSyncableHash(syncer::BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::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(syncable::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(syncer::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(),
-                 syncable::PREFERENCES,
+                 syncer::PREFERENCES,
                  client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::PREFERENCES,
+                 BaseNode::GenerateSyncableHash(syncer::PREFERENCES,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::PREFERENCES, client_tag));
+              node.InitByClientTagLookup(syncer::PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
   }
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::PREFERENCES, client_tag));
+              node.InitByClientTagLookup(syncer::PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide("title2"));
   }
-  EXPECT_TRUE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(syncer::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(),
-                 syncable::PREFERENCES,
+                 syncer::PREFERENCES,
                  client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::PREFERENCES,
+                 BaseNode::GenerateSyncableHash(syncer::PREFERENCES,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
-  EXPECT_FALSE(ResetUnsyncedEntry(syncable::PREFERENCES, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::PREFERENCES, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(syncable::ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::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(syncable::PREFERENCES, client_tag));
+  EXPECT_TRUE(ResetUnsyncedEntry(syncer::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(syncable::PREFERENCES, client_tag));
+              node.InitByClientTagLookup(syncer::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(syncable::PREFERENCES, client_tag));
+  EXPECT_FALSE(ResetUnsyncedEntry(syncer::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(syncable::PREFERENCES, client_tag));
+              node.InitByClientTagLookup(syncer::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();
     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);
-    syncable::AddDefaultFieldValue(syncable::BOOKMARKS, &entity_specifics);
+    syncer::AddDefaultFieldValue(syncer::BOOKMARKS, &entity_specifics);
   }
-  MakeServerNode(sync_manager_.GetUserShare(), syncable::BOOKMARKS, client_tag,
-                 BaseNode::GenerateSyncableHash(syncable::BOOKMARKS,
+  MakeServerNode(sync_manager_.GetUserShare(), syncer::BOOKMARKS, client_tag,
+                 BaseNode::GenerateSyncableHash(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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(syncable::BOOKMARKS, client_tag));
+              node.InitByClientTagLookup(syncer::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());
   }
 }
 
 }  // namespace syncer