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

chrome/browser/sync/profile_sync_service_autofill_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.
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 50 matching lines @@
 
 using base::Time;
 using base::TimeDelta;
 using base::WaitableEvent;
 using browser_sync::AutofillDataTypeController;
 using browser_sync::AutofillProfileDataTypeController;
 using browser_sync::DataTypeController;
 using browser_sync::GenericChangeProcessor;
 using browser_sync::SharedChangeProcessor;
 using content::BrowserThread;
-using syncer::syncable::AUTOFILL;
+using syncer::AUTOFILL;
+using syncer::BaseNode;
 using syncer::syncable::BASE_VERSION;
 using syncer::syncable::CREATE;
 using syncer::syncable::GET_BY_SERVER_TAG;
 using syncer::syncable::MutableEntry;
 using syncer::syncable::SERVER_SPECIFICS;
 using syncer::syncable::SPECIFICS;
 using syncer::syncable::UNITTEST;
 using syncer::syncable::WriterTag;
 using syncer::syncable::WriteTransaction;
-using syncer::BaseNode;
 using testing::_;
 using testing::DoAll;
 using testing::ElementsAre;
 using testing::SetArgumentPointee;
 using testing::Return;
 
 namespace syncable {
 class Id;
 }
 
@@ skipping 36 matching lines @@
     return autofill_table_;
   }
 
  private:
   AutofillTable* autofill_table_;
 };
 
 class ProfileSyncServiceAutofillTest;
 
 template<class AutofillProfile>
-syncable::ModelType GetModelType() {
-  return syncable::UNSPECIFIED;
+syncer::ModelType GetModelType() {
+  return syncer::UNSPECIFIED;
 }
 
 template<>
-syncable::ModelType GetModelType<AutofillEntry>() {
-  return syncable::AUTOFILL;
+syncer::ModelType GetModelType<AutofillEntry>() {
+  return syncer::AUTOFILL;
 }
 
 template<>
-syncable::ModelType GetModelType<AutofillProfile>() {
-  return syncable::AUTOFILL_PROFILE;
+syncer::ModelType GetModelType<AutofillProfile>() {
+  return syncer::AUTOFILL_PROFILE;
 }
 
 class WebDataServiceFake : public WebDataService {
  public:
   WebDataServiceFake()
       : web_database_(NULL),
         syncable_service_created_or_destroyed_(false, false) {
   }
 
   static scoped_refptr<RefcountedProfileKeyedService> Build(Profile* profile) {
@@ skipping 134 matching lines @@
   }
 
   virtual void SetExpectation(ProfileSyncComponentsFactoryMock* factory,
                               ProfileSyncService* service,
                               WebDataService* wds,
                               DataTypeController* dtc) OVERRIDE {
     EXPECT_CALL(*factory, CreateGenericChangeProcessor(_,_,_)).
         WillOnce(MakeGenericChangeProcessor());
     EXPECT_CALL(*factory, CreateSharedChangeProcessor()).
         WillOnce(MakeSharedChangeProcessor());
-    EXPECT_CALL(*factory, GetSyncableServiceForType(syncable::AUTOFILL)).
+    EXPECT_CALL(*factory, GetSyncableServiceForType(syncer::AUTOFILL)).
         WillOnce(MakeAutocompleteSyncComponents(wds));
   }
 };
 
 class AutofillProfileFactory : public AbstractAutofillFactory {
  public:
   virtual browser_sync::DataTypeController* CreateDataTypeController(
       ProfileSyncComponentsFactory* factory,
       ProfileMock* profile,
       ProfileSyncService* service) OVERRIDE {
     return new AutofillProfileDataTypeController(factory, profile, service);
   }
 
   virtual void SetExpectation(ProfileSyncComponentsFactoryMock* factory,
                               ProfileSyncService* service,
                               WebDataService* wds,
                               DataTypeController* dtc) OVERRIDE {
     EXPECT_CALL(*factory, CreateGenericChangeProcessor(_,_,_)).
         WillOnce(MakeGenericChangeProcessor());
     EXPECT_CALL(*factory, CreateSharedChangeProcessor()).
         WillOnce(MakeSharedChangeProcessor());
     EXPECT_CALL(*factory,
-        GetSyncableServiceForType(syncable::AUTOFILL_PROFILE)).
+        GetSyncableServiceForType(syncer::AUTOFILL_PROFILE)).
         WillOnce(MakeAutofillProfileSyncComponents(wds));
   }
 };
 
 class PersonalDataManagerMock: public PersonalDataManager {
  public:
   static ProfileKeyedService* Build(Profile* profile) {
     return new PersonalDataManagerMock;
   }
 
   MOCK_CONST_METHOD0(IsDataLoaded, bool());
   MOCK_METHOD0(LoadProfiles, void());
   MOCK_METHOD0(LoadCreditCards, void());
   MOCK_METHOD0(Refresh, void());
 };
 template <class T> class AddAutofillHelper;
 
 class ProfileSyncServiceAutofillTest : public AbstractProfileSyncServiceTest {
  protected:
   ProfileSyncServiceAutofillTest() {
   }
   virtual ~ProfileSyncServiceAutofillTest() {
   }
 
   AutofillProfileFactory profile_factory_;
   AutofillEntryFactory entry_factory_;
 
-  AbstractAutofillFactory* GetFactory(syncable::ModelType type) {
-    if (type == syncable::AUTOFILL) {
+  AbstractAutofillFactory* GetFactory(syncer::ModelType type) {
+    if (type == syncer::AUTOFILL) {
       return &entry_factory_;
-    } else if (type == syncable::AUTOFILL_PROFILE) {
+    } else if (type == syncer::AUTOFILL_PROFILE) {
       return &profile_factory_;
     } else {
       NOTREACHED();
       return NULL;
     }
   }
 
   virtual void SetUp() OVERRIDE {
     AbstractProfileSyncServiceTest::SetUp();
     profile_.reset(new ProfileMock());
@@ skipping 28 matching lines @@
     web_data_service_->ShutdownSyncableService();
     profile_->ResetRequestContext();
     // To prevent a leak, fully release TestURLRequestContext to ensure its
     // destruction on the IO message loop.
     profile_.reset();
     AbstractProfileSyncServiceTest::TearDown();
   }
 
   void StartSyncService(const base::Closure& callback,
                         bool will_fail_association,
-                        syncable::ModelType type) {
+                        syncer::ModelType type) {
     AbstractAutofillFactory* factory = GetFactory(type);
     SigninManager* signin = SigninManagerFactory::GetForProfile(profile_.get());
     signin->SetAuthenticatedUsername("test_user");
     ProfileSyncComponentsFactoryMock* components_factory =
         new ProfileSyncComponentsFactoryMock();
     service_.reset(
         new TestProfileSyncService(components_factory,
                                    profile_.get(),
                                    signin,
                                    ProfileSyncService::AUTO_START,
@@ skipping 20 matching lines @@
 
     service_->RegisterDataTypeController(data_type_controller);
     service_->Initialize();
     MessageLoop::current()->Run();
   }
 
   bool AddAutofillSyncNode(const AutofillEntry& entry) {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     syncer::ReadNode autofill_root(&trans);
     if (autofill_root.InitByTagLookup(
-            syncable::ModelTypeToRootTag(syncable::AUTOFILL)) !=
+            syncer::ModelTypeToRootTag(syncer::AUTOFILL)) !=
                 BaseNode::INIT_OK) {
       return false;
     }
 
     syncer::WriteNode node(&trans);
     std::string tag = AutocompleteSyncableService::KeyToTag(
         UTF16ToUTF8(entry.key().name()), UTF16ToUTF8(entry.key().value()));
     syncer::WriteNode::InitUniqueByCreationResult result =
-        node.InitUniqueByCreation(syncable::AUTOFILL, autofill_root, tag);
+        node.InitUniqueByCreation(syncer::AUTOFILL, autofill_root, tag);
     if (result != syncer::WriteNode::INIT_SUCCESS)
       return false;
 
     sync_pb::EntitySpecifics specifics;
     AutocompleteSyncableService::WriteAutofillEntry(entry, &specifics);
     sync_pb::AutofillSpecifics* autofill_specifics =
         specifics.mutable_autofill();
     node.SetAutofillSpecifics(*autofill_specifics);
     return true;
   }
 
   bool AddAutofillSyncNode(const AutofillProfile& profile) {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     syncer::ReadNode autofill_root(&trans);
     if (autofill_root.InitByTagLookup(kAutofillProfileTag) !=
             BaseNode::INIT_OK) {
       return false;
     }
     syncer::WriteNode node(&trans);
     std::string tag = profile.guid();
     syncer::WriteNode::InitUniqueByCreationResult result =
-        node.InitUniqueByCreation(syncable::AUTOFILL_PROFILE,
+        node.InitUniqueByCreation(syncer::AUTOFILL_PROFILE,
                                   autofill_root, tag);
     if (result != syncer::WriteNode::INIT_SUCCESS)
       return false;
 
     sync_pb::EntitySpecifics specifics;
     AutofillProfileSyncableService::WriteAutofillProfile(profile, &specifics);
     sync_pb::AutofillProfileSpecifics* profile_specifics =
         specifics.mutable_autofill_profile();
     node.SetAutofillProfileSpecifics(*profile_specifics);
     return true;
   }
 
   bool GetAutofillEntriesFromSyncDB(std::vector<AutofillEntry>* entries,
                                     std::vector<AutofillProfile>* profiles) {
     syncer::ReadTransaction trans(FROM_HERE, service_->GetUserShare());
     syncer::ReadNode autofill_root(&trans);
     if (autofill_root.InitByTagLookup(
-            syncable::ModelTypeToRootTag(syncable::AUTOFILL)) !=
+            syncer::ModelTypeToRootTag(syncer::AUTOFILL)) !=
                 BaseNode::INIT_OK) {
       return false;
     }
 
     int64 child_id = autofill_root.GetFirstChildId();
     while (child_id != syncer::kInvalidId) {
       syncer::ReadNode child_node(&trans);
       if (child_node.InitByIdLookup(child_id) != BaseNode::INIT_OK)
         return false;
 
@@ skipping 123 matching lines @@
 class WriteTransactionTest: public WriteTransaction {
  public:
   WriteTransactionTest(const tracked_objects::Location& from_here,
                        WriterTag writer,
                        syncer::syncable::Directory* directory,
                        scoped_ptr<WaitableEvent>* wait_for_syncapi)
       : WriteTransaction(from_here, writer, directory),
         wait_for_syncapi_(wait_for_syncapi) { }
 
   virtual void NotifyTransactionComplete(
-      syncable::ModelTypeSet types) OVERRIDE {
+      syncer::ModelTypeSet types) OVERRIDE {
     // This is where we differ. Force a thread change here, giving another
     // thread a chance to create a WriteTransaction
     (*wait_for_syncapi_)->Wait();
 
     WriteTransaction::NotifyTransactionComplete(types);
   }
 
  private:
   scoped_ptr<WaitableEvent>* wait_for_syncapi_;
 };
@@ skipping 37 matching lines @@
       // Tell main thread we've started
       (*wait_for_start_)->Signal();
 
       // Create write transaction.
       WriteTransactionTest trans(FROM_HERE, UNITTEST, directory,
                                  wait_for_syncapi_);
 
       // Create actual entry based on autofill protobuf information.
       // Simulates effects of UpdateLocalDataFromServerData
       MutableEntry parent(&trans, GET_BY_SERVER_TAG,
-                          syncable::ModelTypeToRootTag(syncable::AUTOFILL));
+                          syncer::ModelTypeToRootTag(syncer::AUTOFILL));
       MutableEntry item(&trans, CREATE, parent.Get(syncer::syncable::ID), tag);
       ASSERT_TRUE(item.good());
       item.Put(SPECIFICS, entity_specifics);
       item.Put(SERVER_SPECIFICS, entity_specifics);
       item.Put(BASE_VERSION, 1);
       syncer::syncable::Id server_item_id =
           service_->id_factory()->NewServerId();
       item.Put(syncer::syncable::ID, server_item_id);
       syncer::syncable::Id new_predecessor;
       ASSERT_TRUE(item.PutPredecessor(new_predecessor));
@@ skipping 59 matching lines @@
 }
 
 };
 
 // TODO(skrul): Test abort startup.
 // TODO(skrul): Test processing of cloud changes.
 // TODO(tim): Add autofill data type controller test, and a case to cover
 //            waiting for the PersonalDataManager.
 TEST_F(ProfileSyncServiceAutofillTest, FailModelAssociation) {
   // Don't create the root autofill node so startup fails.
-  StartSyncService(base::Closure(), true, syncable::AUTOFILL);
+  StartSyncService(base::Closure(), true, syncer::AUTOFILL);
   EXPECT_TRUE(service_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, EmptyNativeEmptySync) {
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncable::AUTOFILL);
+  CreateRootHelper create_root(this, syncer::AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(create_root.callback(), false, syncable::AUTOFILL);
+  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   EXPECT_TRUE(create_root.success());
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(0U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeEntriesEmptySync) {
   std::vector<AutofillEntry> entries;
   entries.push_back(MakeAutofillEntry("foo", "bar", 1));
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncable::AUTOFILL);
+  CreateRootHelper create_root(this, syncer::AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(create_root.callback(), false, syncable::AUTOFILL);
+  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(create_root.success());
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   ASSERT_EQ(1U, entries.size());
   EXPECT_TRUE(entries[0] == sync_entries[0]);
   EXPECT_EQ(0U, sync_profiles.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasProfileEmptySync) {
   std::vector<AutofillProfile*> profiles;
   std::vector<AutofillProfile> expected_profiles;
   // Owned by GetAutofillProfiles caller.
   AutofillProfile* profile0 = new AutofillProfile;
   autofill_test::SetProfileInfoWithGuid(profile0,
       "54B3F9AA-335E-4F71-A27D-719C41564230", "Billing",
       "Mitchell", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910");
   profiles.push_back(profile0);
   expected_profiles.push_back(*profile0);
   EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(profiles), Return(true)));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncable::AUTOFILL_PROFILE);
-  StartSyncService(create_root.callback(), false, syncable::AUTOFILL_PROFILE);
+  CreateRootHelper create_root(this, syncer::AUTOFILL_PROFILE);
+  StartSyncService(create_root.callback(), false, syncer::AUTOFILL_PROFILE);
   ASSERT_TRUE(create_root.success());
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(&sync_profiles));
   EXPECT_EQ(1U, sync_profiles.size());
   EXPECT_EQ(0, expected_profiles[0].Compare(sync_profiles[0]));
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeWithDuplicatesEmptySync) {
   // There is buggy autofill code that allows duplicate name/value
   // pairs to exist in the database with separate pair_ids.
   std::vector<AutofillEntry> entries;
   entries.push_back(MakeAutofillEntry("foo", "bar", 1));
   entries.push_back(MakeAutofillEntry("dup", "", 2));
   entries.push_back(MakeAutofillEntry("dup", "", 3));
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncable::AUTOFILL);
+  CreateRootHelper create_root(this, syncer::AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(create_root.callback(), false, syncable::AUTOFILL);
+  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(create_root.success());
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(2U, sync_entries.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncNoMerge) {
   AutofillEntry native_entry(MakeAutofillEntry("native", "entry", 1));
   AutofillEntry sync_entry(MakeAutofillEntry("sync", "entry", 2));
 
   std::vector<AutofillEntry> native_entries;
   native_entries.push_back(native_entry);
 
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
 
   std::vector<AutofillEntry> sync_entries;
   sync_entries.push_back(sync_entry);
 
   AddAutofillHelper<AutofillEntry> add_autofill(this, sync_entries);
 
   EXPECT_CALL(autofill_table_, UpdateAutofillEntries(ElementsAre(sync_entry))).
       WillOnce(Return(true));
 
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncable::AUTOFILL);
+  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(add_autofill.success());
 
   std::set<AutofillEntry> expected_entries;
   expected_entries.insert(native_entry);
   expected_entries.insert(sync_entry);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
                                            &new_sync_profiles));
@@ skipping 13 matching lines @@
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
 
   std::vector<AutofillEntry> sync_entries;
   sync_entries.push_back(sync_entry);
   AddAutofillHelper<AutofillEntry> add_autofill(this, sync_entries);
 
   EXPECT_CALL(autofill_table_,
       UpdateAutofillEntries(ElementsAre(merged_entry))).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncable::AUTOFILL);
+  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
                                            &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(merged_entry == new_sync_entries[0]);
 }
 
@@ skipping 17 matching lines @@
       WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
 
   EXPECT_CALL(autofill_table_,
               UpdateAutofillProfileMulti(MatchProfiles(sync_profile))).
       WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncable::AUTOFILL_PROFILE);
+  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
       &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_profiles.size());
   EXPECT_EQ(0, sync_profile.Compare(new_sync_profiles[0]));
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncMergeProfileCombine) {
@@ skipping 22 matching lines @@
               AddAutofillProfile(MatchProfiles(expected_profile))).
       WillOnce(Return(true));
   EXPECT_CALL(autofill_table_,
               RemoveAutofillProfile("23355099-1170-4B71-8ED4-144470CC9EBF")).
       WillOnce(Return(true));
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
 
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncable::AUTOFILL_PROFILE);
+  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
       &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_profiles.size());
   // Check that key fields are the same.
   EXPECT_TRUE(new_sync_profiles[0].IsSubsetOf(sync_profile));
   // Check that multivalued fields of the synced back data include original
   // data.
@@ skipping 27 matching lines @@
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
 
   EXPECT_CALL(autofill_table_, AddAutofillProfile(_)).
       WillOnce(Return(true));
   EXPECT_CALL(autofill_table_, RemoveAutofillProfile(native_guid)).
       WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncable::AUTOFILL_PROFILE);
+  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
       &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_profiles.size());
   EXPECT_EQ(0, sync_profile.Compare(new_sync_profiles[0]));
   EXPECT_EQ(sync_profile.guid(), new_sync_profiles[0].guid());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeAddEntry) {
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncable::AUTOFILL);
-  StartSyncService(create_root.callback(), false, syncable::AUTOFILL);
+  CreateRootHelper create_root(this, syncer::AUTOFILL);
+  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry added_entry(MakeAutofillEntry("added", "entry", 1));
   std::vector<base::Time> timestamps(added_entry.timestamps());
 
   EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _)).
       WillOnce(DoAll(SetArgumentPointee<2>(timestamps), Return(true)));
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::ADD, added_entry.key()));
   scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(
       db_thread_.DeprecatedGetThreadObject()));
   notifier->Notify(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
                    content::Source<WebDataService>(web_data_service_.get()),
                    content::Details<AutofillChangeList>(&changes));
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
                                            &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(added_entry == new_sync_entries[0]);
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeAddProfile) {
   EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncable::AUTOFILL_PROFILE);
-  StartSyncService(create_root.callback(), false, syncable::AUTOFILL_PROFILE);
+  CreateRootHelper create_root(this, syncer::AUTOFILL_PROFILE);
+  StartSyncService(create_root.callback(), false, syncer::AUTOFILL_PROFILE);
   ASSERT_TRUE(create_root.success());
 
   AutofillProfile added_profile;
   autofill_test::SetProfileInfoWithGuid(&added_profile,
       "D6ADA912-D374-4C0A-917D-F5C8EBE43011", "Josephine", "Alicia", "Saenz",
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "19482937549");
 
   AutofillProfileChange change(AutofillProfileChange::ADD,
       added_profile.guid(), &added_profile);
@@ skipping 11 matching lines @@
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeUpdateEntry) {
   AutofillEntry original_entry(MakeAutofillEntry("my", "entry", 1));
   std::vector<AutofillEntry> original_entries;
   original_entries.push_back(original_entry);
 
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  CreateRootHelper create_root(this, syncable::AUTOFILL);
-  StartSyncService(create_root.callback(), false, syncable::AUTOFILL);
+  CreateRootHelper create_root(this, syncer::AUTOFILL);
+  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry updated_entry(MakeAutofillEntry("my", "entry", 1, 2));
   std::vector<base::Time> timestamps(updated_entry.timestamps());
 
   EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _)).
       WillOnce(DoAll(SetArgumentPointee<2>(timestamps), Return(true)));
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::UPDATE,
@@ skipping 14 matching lines @@
 
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeRemoveEntry) {
   AutofillEntry original_entry(MakeAutofillEntry("my", "entry", 1));
   std::vector<AutofillEntry> original_entries;
   original_entries.push_back(original_entry);
 
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  CreateRootHelper create_root(this, syncable::AUTOFILL);
-  StartSyncService(create_root.callback(), false, syncable::AUTOFILL);
+  CreateRootHelper create_root(this, syncer::AUTOFILL);
+  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::REMOVE,
                                    original_entry.key()));
   scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(
       db_thread_.DeprecatedGetThreadObject()));
   notifier->Notify(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
                    content::Source<WebDataService>(web_data_service_.get()),
                    content::Details<AutofillChangeList>(&changes));
@@ skipping 19 matching lines @@
 
   std::vector<AutofillProfile*> native_profiles;
   native_profiles.push_back(native_profile);
   EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncable::AUTOFILL_PROFILE);
+  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   AutofillProfileChange change(AutofillProfileChange::REMOVE,
                                sync_profile.guid(), NULL);
   scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(
       db_thread_.DeprecatedGetThreadObject()));
   notifier->Notify(chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
                    content::Source<WebDataService>(web_data_service_.get()),
                    content::Details<AutofillProfileChange>(&change));
 
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
       &new_sync_profiles));
   ASSERT_EQ(0U, new_sync_profiles.size());
 }
 
 // http://crbug.com/57884
 TEST_F(ProfileSyncServiceAutofillTest, DISABLED_ServerChangeRace) {
   // Once for MergeDataAndStartSyncing() and twice for ProcessSyncChanges(), via
   // LoadAutofillData().
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       Times(3).WillRepeatedly(Return(true));
   // On the other hand Autofill and Autocomplete are separated now, so
   // GetAutofillProfiles() should not be called.
   EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).Times(0);
   EXPECT_CALL(autofill_table_, UpdateAutofillEntries(_)).
       WillRepeatedly(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh()).Times(3);
-  CreateRootHelper create_root(this, syncable::AUTOFILL);
-  StartSyncService(create_root.callback(), false, syncable::AUTOFILL);
+  CreateRootHelper create_root(this, syncer::AUTOFILL);
+  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   // (true, false) means we have to reset after |Signal|, init to unsignaled.
   scoped_ptr<WaitableEvent> wait_for_start(new WaitableEvent(true, false));
   scoped_ptr<WaitableEvent> wait_for_syncapi(new WaitableEvent(true, false));
   scoped_refptr<FakeServerUpdater> updater(new FakeServerUpdater(
       service_.get(), &wait_for_start, &wait_for_syncapi));
 
   // This server side update will stall waiting for CommitWaiter.
   updater->CreateNewEntry(MakeAutofillEntry("server", "entry", 1));
@@ skipping 14 matching lines @@
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
              << ", " << sync_entries[i].key().value();
   }
 }