No protected data members in ProfileSyncService tests

components/browser_sync/browser/profile_sync_service_autofill_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 84 matching lines @@
   registry->RegisterBooleanPref(autofill::prefs::kAutofillEnabled, true);
   registry->RegisterBooleanPref(autofill::prefs::kAutofillWalletImportEnabled,
                                 true);
 }
 
 void RunAndSignal(const base::Closure& cb, WaitableEvent* event) {
   cb.Run();
   event->Signal();
 }
 
+AutofillEntry MakeAutofillEntry(const char* name,
+                                const char* value,
+                                int time_shift0,
+                                int time_shift1) {
+  // Time deep in the past would cause Autocomplete sync to discard the
+  // entries.
+  static Time base_time = Time::Now().LocalMidnight();
+
+  Time date_created = base_time + TimeDelta::FromSeconds(time_shift0);
+  Time date_last_used = date_created;
+  if (time_shift1 >= 0)
+    date_last_used = base_time + TimeDelta::FromSeconds(time_shift1);
+  return AutofillEntry(
+      AutofillKey(base::ASCIIToUTF16(name), base::ASCIIToUTF16(value)),
+      date_created, date_last_used);
+}
+
+AutofillEntry MakeAutofillEntry(const char* name,
+                                const char* value,
+                                int time_shift) {
+  return MakeAutofillEntry(name, value, time_shift, -1);
+}
+
 }  // namespace
 
 class AutofillTableMock : public AutofillTable {
  public:
   AutofillTableMock() {}
   MOCK_METHOD2(RemoveFormElement,
                bool(const base::string16& name,
                     const base::string16& value));  // NOLINT
   MOCK_METHOD1(GetAllAutofillEntries,
                bool(std::vector<AutofillEntry>* entries));  // NOLINT
@@ skipping 233 matching lines @@
   void OnDataTypeConfigureComplete(const std::vector<
       syncer::DataTypeConfigurationStats>& configuration_stats) override {
     ASSERT_EQ(1u, configuration_stats.size());
     association_stats_ = configuration_stats[0].association_stats;
   }
 
  protected:
   ProfileSyncServiceAutofillTest() : debug_ptr_factory_(this) {
     autofill::CountryNames::SetLocaleString("en-US");
     RegisterAutofillPrefs(
-        profile_sync_service_bundle_.pref_service()->registry());
+        profile_sync_service_bundle()->pref_service()->registry());
 
-    data_type_thread_.Start();
-    profile_sync_service_bundle_.set_db_thread(data_type_thread_.task_runner());
+    data_type_thread()->Start();
+    profile_sync_service_bundle()->set_db_thread(
+        data_type_thread()->task_runner());
 
     web_database_.reset(new WebDatabaseFake(&autofill_table_));
     web_data_wrapper_ = make_scoped_ptr(new MockWebDataServiceWrapper(
         new WebDataServiceFake(base::ThreadTaskRunnerHandle::Get(),
-                               data_type_thread_.task_runner()),
+                               data_type_thread()->task_runner()),
         new TokenWebDataServiceFake(base::ThreadTaskRunnerHandle::Get(),
-                                    data_type_thread_.task_runner())));
+                                    data_type_thread()->task_runner())));
     web_data_service_ = static_cast<WebDataServiceFake*>(
         web_data_wrapper_->GetAutofillWebData().get());
     web_data_service_->SetDatabase(web_database_.get());
 
     personal_data_manager_ = make_scoped_ptr(new MockPersonalDataManager());
 
-    EXPECT_CALL(*personal_data_manager_, LoadProfiles());
-    EXPECT_CALL(*personal_data_manager_, LoadCreditCards());
+    EXPECT_CALL(personal_data_manager(), LoadProfiles());
+    EXPECT_CALL(personal_data_manager(), LoadCreditCards());
 
     personal_data_manager_->Init(
-        web_data_service_, profile_sync_service_bundle_.pref_service(),
-        profile_sync_service_bundle_.account_tracker(),
-        profile_sync_service_bundle_.signin_manager(), false);
+        web_data_service_, profile_sync_service_bundle()->pref_service(),
+        profile_sync_service_bundle()->account_tracker(),
+        profile_sync_service_bundle()->signin_manager(), false);
 
     web_data_service_->StartSyncableService();
 
     browser_sync::ProfileSyncServiceBundle::SyncClientBuilder builder(
-        &profile_sync_service_bundle_);
+        profile_sync_service_bundle());
     builder.SetPersonalDataManager(personal_data_manager_.get());
-    builder.SetSyncServiceCallback(
-        base::Bind(&ProfileSyncServiceAutofillTest::GetSyncService,
-                   base::Unretained(this)));
+    builder.SetSyncServiceCallback(GetSyncServiceCallback());
     builder.SetSyncableServiceCallback(
         base::Bind(&ProfileSyncServiceAutofillTest::GetSyncableServiceForType,
                    base::Unretained(this)));
     builder.set_activate_model_creation();
     sync_client_owned_ = builder.Build();
     sync_client_ = sync_client_owned_.get();
 
     // When UpdateAutofillEntries() is called with an empty list, the return
     // value should be |true|, rather than the default of |false|.
     std::vector<AutofillEntry> empty;
     EXPECT_CALL(autofill_table_, UpdateAutofillEntries(empty))
         .WillRepeatedly(Return(true));
   }
 
   ~ProfileSyncServiceAutofillTest() override {
     web_data_service_->ShutdownOnUIThread();
     web_data_service_->ShutdownSyncableService();
     web_data_wrapper_->Shutdown();
     web_data_service_ = nullptr;
     web_data_wrapper_.reset();
     web_database_.reset();
     // Shut down the service explicitly before some data members from this
     // test it needs will be deleted.
-    sync_service_->Shutdown();
+    sync_service()->Shutdown();
   }
 
   int GetSyncCount(syncer::ModelType type) {
-    syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::ReadTransaction trans(FROM_HERE, sync_service()->GetUserShare());
     syncer::ReadNode node(&trans);
     if (node.InitTypeRoot(type) != BaseNode::INIT_OK)
       return 0;
     return node.GetTotalNodeCount() - 1;
   }
 
   void StartSyncService(const base::Closure& callback,
                         bool will_fail_association,
                         syncer::ModelType type) {
-    SigninManagerBase* signin = profile_sync_service_bundle_.signin_manager();
+    SigninManagerBase* signin = profile_sync_service_bundle()->signin_manager();
     signin->SetAuthenticatedAccountInfo("12345", "test_user@gmail.com");
-    sync_service_ = CreateSyncService(std::move(sync_client_owned_), callback);
+    CreateSyncService(std::move(sync_client_owned_), callback);
 
-    EXPECT_CALL(*profile_sync_service_bundle_.component_factory(),
+    EXPECT_CALL(*profile_sync_service_bundle()->component_factory(),
                 CreateDataTypeManager(_, _, _, _, _))
         .WillOnce(ReturnNewDataTypeManagerWithDebugListener(
             syncer::MakeWeakHandle(debug_ptr_factory_.GetWeakPtr())));
 
-    EXPECT_CALL(*personal_data_manager_, IsDataLoaded()).
-        WillRepeatedly(Return(true));
+    EXPECT_CALL(personal_data_manager(), IsDataLoaded())
+        .WillRepeatedly(Return(true));
 
     // We need tokens to get the tests going
-    profile_sync_service_bundle_.auth_service()->UpdateCredentials(
+    profile_sync_service_bundle()->auth_service()->UpdateCredentials(
         signin->GetAuthenticatedAccountId(), "oauth2_login_token");
 
-    sync_service_->RegisterDataTypeController(CreateDataTypeController(type));
-    sync_service_->Initialize();
+    sync_service()->RegisterDataTypeController(CreateDataTypeController(type));
+    sync_service()->Initialize();
     base::RunLoop().Run();
 
     // It's possible this test triggered an unrecoverable error, in which case
     // we can't get the sync count.
-    if (sync_service_->IsSyncActive()) {
+    if (sync_service()->IsSyncActive()) {
       EXPECT_EQ(GetSyncCount(type),
                 association_stats_.num_sync_items_after_association);
     }
     EXPECT_EQ(association_stats_.num_sync_items_after_association,
               association_stats_.num_sync_items_before_association +
               association_stats_.num_sync_items_added -
               association_stats_.num_sync_items_deleted);
   }
 
   bool AddAutofillSyncNode(const AutofillEntry& entry) {
-    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::WriteTransaction trans(FROM_HERE, sync_service()->GetUserShare());
     syncer::WriteNode node(&trans);
     std::string tag = AutocompleteSyncableService::KeyToTag(
         base::UTF16ToUTF8(entry.key().name()),
         base::UTF16ToUTF8(entry.key().value()));
     syncer::WriteNode::InitUniqueByCreationResult result =
         node.InitUniqueByCreation(AUTOFILL, tag);
     if (result != syncer::WriteNode::INIT_SUCCESS)
       return false;
 
     sync_pb::EntitySpecifics specifics;
     AutocompleteSyncableService::WriteAutofillEntry(entry, &specifics);
     node.SetEntitySpecifics(specifics);
     return true;
   }
 
   bool AddAutofillSyncNode(const AutofillProfile& profile) {
-    syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::WriteTransaction trans(FROM_HERE, sync_service()->GetUserShare());
     syncer::WriteNode node(&trans);
     std::string tag = profile.guid();
     syncer::WriteNode::InitUniqueByCreationResult result =
         node.InitUniqueByCreation(AUTOFILL_PROFILE, tag);
     if (result != syncer::WriteNode::INIT_SUCCESS)
       return false;
 
     sync_pb::EntitySpecifics specifics;
     AutofillProfileSyncableService::WriteAutofillProfile(profile, &specifics);
     node.SetEntitySpecifics(specifics);
     return true;
   }
 
   bool GetAutofillEntriesFromSyncDB(std::vector<AutofillEntry>* entries,
                                     std::vector<AutofillProfile>* profiles) {
-    syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::ReadTransaction trans(FROM_HERE, sync_service()->GetUserShare());
     syncer::ReadNode autofill_root(&trans);
     if (autofill_root.InitTypeRoot(AUTOFILL) != BaseNode::INIT_OK) {
       return false;
     }
 
     int64_t 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 18 matching lines @@
             autofill.profile(), &p);
         profiles->push_back(p);
       }
       child_id = child_node.GetSuccessorId();
     }
     return true;
   }
 
   bool GetAutofillProfilesFromSyncDBUnderProfileNode(
       std::vector<AutofillProfile>* profiles) {
-    syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
+    syncer::ReadTransaction trans(FROM_HERE, sync_service()->GetUserShare());
     syncer::ReadNode autofill_root(&trans);
     if (autofill_root.InitTypeRoot(AUTOFILL_PROFILE) != BaseNode::INIT_OK) {
       return false;
     }
 
     int64_t 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 12 matching lines @@
 
   void SetIdleChangeProcessorExpectations() {
     EXPECT_CALL(autofill_table_, RemoveFormElement(_, _)).Times(0);
     EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _, _)).Times(0);
 
     // Only permit UpdateAutofillEntries() to be called with an empty list.
     std::vector<AutofillEntry> empty;
     EXPECT_CALL(autofill_table_, UpdateAutofillEntries(Not(empty))).Times(0);
   }
 
-  static AutofillEntry MakeAutofillEntry(const char* name,
-                                         const char* value,
-                                         int time_shift0,
-                                         int time_shift1) {
-    // Time deep in the past would cause Autocomplete sync to discard the
-    // entries.
-    static Time base_time = Time::Now().LocalMidnight();
-
-    Time date_created = base_time + TimeDelta::FromSeconds(time_shift0);
-    Time date_last_used = date_created;
-    if (time_shift1 >= 0)
-      date_last_used = base_time + TimeDelta::FromSeconds(time_shift1);
-    return AutofillEntry(
-        AutofillKey(base::ASCIIToUTF16(name), base::ASCIIToUTF16(value)),
-        date_created, date_last_used);
-  }
-
-  static AutofillEntry MakeAutofillEntry(const char* name,
-                                         const char* value,
-                                         int time_shift) {
-    return MakeAutofillEntry(name, value, time_shift, -1);
-  }
-
   sync_driver::DataTypeController* CreateDataTypeController(
       syncer::ModelType type) {
     DCHECK(type == AUTOFILL || type == AUTOFILL_PROFILE);
     if (type == AUTOFILL) {
-      return new AutofillDataTypeController(
-          base::ThreadTaskRunnerHandle::Get(), data_type_thread_.task_runner(),
-          base::Bind(&base::DoNothing), sync_client_, web_data_service_);
+      return new AutofillDataTypeController(base::ThreadTaskRunnerHandle::Get(),
+                                            data_type_thread()->task_runner(),
+                                            base::Bind(&base::DoNothing),
+                                            sync_client_, web_data_service_);
     } else {
       return new AutofillProfileDataTypeController(
-          base::ThreadTaskRunnerHandle::Get(), data_type_thread_.task_runner(),
-          base::Bind(&base::DoNothing), sync_client_, web_data_service_);
+          base::ThreadTaskRunnerHandle::Get(),
+          data_type_thread()->task_runner(), base::Bind(&base::DoNothing),
+          sync_client_, web_data_service_);
     }
   }
 
+  AutofillTableMock& autofill_table() { return autofill_table_; }
+
+  MockPersonalDataManager& personal_data_manager() {
+    return *personal_data_manager_;
+  }
+
+  WebDataServiceFake* web_data_service() { return web_data_service_.get(); }
+
+ private:
   friend class AddAutofillHelper<AutofillEntry>;
   friend class AddAutofillHelper<AutofillProfile>;
-  friend class FakeServerUpdater;
-
-  AutofillTableMock autofill_table_;
-  scoped_ptr<WebDatabaseFake> web_database_;
-  scoped_ptr<MockWebDataServiceWrapper> web_data_wrapper_;
-  scoped_refptr<WebDataServiceFake> web_data_service_;
-  scoped_ptr<MockPersonalDataManager> personal_data_manager_;
-  syncer::DataTypeAssociationStats association_stats_;
-  base::WeakPtrFactory<DataTypeDebugInfoListener> debug_ptr_factory_;
-  // |sync_client_owned_| keeps the created client until it is passed to the
-  // created ProfileSyncService. |sync_client_| just keeps a weak reference to
-  // the client the whole time.
-  scoped_ptr<sync_driver::FakeSyncClient> sync_client_owned_;
-  sync_driver::FakeSyncClient* sync_client_;
-
- private:
-  sync_driver::SyncService* GetSyncService() { return sync_service_.get(); }
 
   base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
       syncer::ModelType type) {
     DCHECK(type == AUTOFILL || type == AUTOFILL_PROFILE);
     if (type == AUTOFILL) {
       return AutocompleteSyncableService::FromWebDataService(
                  web_data_service_.get())
           ->AsWeakPtr();
     } else {
       return AutofillProfileSyncableService::FromWebDataService(
                  web_data_service_.get())
           ->AsWeakPtr();
     }
   }
 
+  AutofillTableMock autofill_table_;
+  scoped_ptr<WebDatabaseFake> web_database_;
+  scoped_ptr<MockWebDataServiceWrapper> web_data_wrapper_;
+  scoped_refptr<WebDataServiceFake> web_data_service_;
+  scoped_ptr<MockPersonalDataManager> personal_data_manager_;
+  syncer::DataTypeAssociationStats association_stats_;
+  base::WeakPtrFactory<DataTypeDebugInfoListener> debug_ptr_factory_;
+  // |sync_client_owned_| keeps the created client until it is passed to the
+  // created ProfileSyncService. |sync_client_| just keeps a weak reference to
+  // the client the whole time.
+  scoped_ptr<sync_driver::FakeSyncClient> sync_client_owned_;
+  sync_driver::FakeSyncClient* sync_client_;
+
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceAutofillTest);
 };
 
 template <class T>
 class AddAutofillHelper {
  public:
   AddAutofillHelper(ProfileSyncServiceAutofillTest* test,
                     const std::vector<T>& entries)
       : callback_(base::Bind(&AddAutofillHelper::AddAutofillCallback,
                              base::Unretained(this), test, entries)),
@@ skipping 43 matching lines @@
 };
 
 // Our fake server updater. Needs the RefCountedThreadSafe inheritance so we can
 // post tasks with it.
 class FakeServerUpdater : public base::RefCountedThreadSafe<FakeServerUpdater> {
  public:
   FakeServerUpdater(TestProfileSyncService* service,
                     WaitableEvent* wait_for_start,
                     WaitableEvent* wait_for_syncapi,
                     scoped_refptr<base::SequencedTaskRunner> db_thread)
-      : entry_(ProfileSyncServiceAutofillTest::MakeAutofillEntry("0", "0", 0)),
+      : entry_(MakeAutofillEntry("0", "0", 0)),
         service_(service),
         wait_for_start_(wait_for_start),
         wait_for_syncapi_(wait_for_syncapi),
         is_finished_(false, false),
         db_thread_(db_thread) {}
 
   void Update() {
     // This gets called in a modelsafeworker thread.
     ASSERT_TRUE(db_thread_->RunsTasksOnCurrentThread());
 
@@ skipping 71 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FakeServerUpdater);
 };
 
 // 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, AUTOFILL);
-  EXPECT_TRUE(sync_service_->HasUnrecoverableError());
+  EXPECT_TRUE(sync_service()->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, EmptyNativeEmptySync) {
-  EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).WillOnce(Return(true));
+  EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
+      .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL);
-  EXPECT_CALL(*personal_data_manager_, Refresh());
+  EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(create_root.callback(), false, 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)));
+  EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL);
-  EXPECT_CALL(*personal_data_manager_, Refresh());
+  EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(create_root.callback(), false, 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());
+  EXPECT_CALL(autofill_table(), GetAutofillProfiles(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(profiles), Return(true)));
+  EXPECT_CALL(personal_data_manager(), Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL_PROFILE);
   StartSyncService(create_root.callback(), false, 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)));
+  EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL);
-  EXPECT_CALL(*personal_data_manager_, Refresh());
+  EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(create_root.callback(), false, 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)));
+  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(autofill_table(), UpdateAutofillEntries(ElementsAre(sync_entry)))
+      .WillOnce(Return(true));
 
-  EXPECT_CALL(*personal_data_manager_, Refresh());
+  EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, 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));
   std::set<AutofillEntry> new_sync_entries_set(new_sync_entries.begin(),
                                                new_sync_entries.end());
 
   EXPECT_TRUE(expected_entries == new_sync_entries_set);
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncMergeEntry) {
   AutofillEntry native_entry(MakeAutofillEntry("merge", "entry", 1));
   AutofillEntry sync_entry(MakeAutofillEntry("merge", "entry", 2));
   AutofillEntry merged_entry(MakeAutofillEntry("merge", "entry", 1, 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)));
+  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());
+  EXPECT_CALL(autofill_table(),
+              UpdateAutofillEntries(ElementsAre(merged_entry)))
+      .WillOnce(Return(true));
+  EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, 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]);
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncMergeProfile) {
   AutofillProfile sync_profile;
   autofill::test::SetProfileInfoWithGuid(&sync_profile,
       "23355099-1170-4B71-8ED4-144470CC9EBE", "Billing",
       "Mitchell", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910");
 
   AutofillProfile* native_profile = new AutofillProfile;
   autofill::test::SetProfileInfoWithGuid(native_profile,
       "23355099-1170-4B71-8ED4-144470CC9EBE", "Billing", "Alicia", "Saenz",
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "19482937549");
 
   std::vector<AutofillProfile*> native_profiles;
   native_profiles.push_back(native_profile);
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).
-      WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
+  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(autofill_table_,
-              UpdateAutofillProfile(MatchProfiles(sync_profile))).
-      WillOnce(Return(true));
-  EXPECT_CALL(*personal_data_manager_, Refresh());
+  EXPECT_CALL(autofill_table(),
+              UpdateAutofillProfile(MatchProfiles(sync_profile)))
+      .WillOnce(Return(true));
+  EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, 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]));
 }
 
@@ skipping 10 matching lines @@
   autofill::test::SetProfileInfoWithGuid(native_profile,
       "23355099-1170-4B71-8ED4-144470CC9EBF", "Billing", "Alicia", "Saenz",
       "joewayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "19482937549");
 
   AutofillProfile expected_profile(sync_profile);
   expected_profile.OverwriteWith(*native_profile, "en-US");
 
   std::vector<AutofillProfile*> native_profiles;
   native_profiles.push_back(native_profile);
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).
-      WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
-  EXPECT_CALL(autofill_table_,
-              AddAutofillProfile(MatchProfiles(expected_profile))).
-      WillOnce(Return(true));
-  EXPECT_CALL(autofill_table_,
-              RemoveAutofillProfile("23355099-1170-4B71-8ED4-144470CC9EBF")).
-      WillOnce(Return(true));
+  EXPECT_CALL(autofill_table(), GetAutofillProfiles(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
+  EXPECT_CALL(autofill_table(),
+              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());
+  EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, 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, "en-US"));
 }
@@ skipping 10 matching lines @@
   std::string native_guid = "EDC609ED-7EEE-4F27-B00C-423242A9C44B";
   AutofillProfile* native_profile = new AutofillProfile;
   autofill::test::SetProfileInfoWithGuid(native_profile,
       native_guid.c_str(), "Billing",
       "Mitchell", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910");
 
   std::vector<AutofillProfile*> native_profiles;
   native_profiles.push_back(native_profile);
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).
-      WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
+  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(autofill_table_, AddAutofillProfile(_)).
-      WillOnce(Return(true));
-  EXPECT_CALL(autofill_table_, RemoveAutofillProfile(native_guid)).
-      WillOnce(Return(true));
-  EXPECT_CALL(*personal_data_manager_, Refresh());
+  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, 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());
+  EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
+      .WillOnce(Return(true));
+  EXPECT_CALL(personal_data_manager(), Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL);
   StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry added_entry(MakeAutofillEntry("added", "entry", 1));
 
-  EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _, _)).
-      WillOnce(DoAll(SetArgumentPointee<2>(added_entry.date_created()),
-                     SetArgumentPointee<3>(added_entry.date_last_used()),
-                     Return(true)));
+  EXPECT_CALL(autofill_table(), GetAutofillTimestamps(_, _, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<2>(added_entry.date_created()),
+                      SetArgumentPointee<3>(added_entry.date_last_used()),
+                      Return(true)));
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::ADD, added_entry.key()));
 
-  web_data_service_->OnAutofillEntriesChanged(changes);
+  web_data_service()->OnAutofillEntriesChanged(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());
+  EXPECT_CALL(autofill_table(), GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(personal_data_manager(), Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL_PROFILE);
   StartSyncService(create_root.callback(), false, 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);
-  web_data_service_->OnAutofillProfileChanged(change);
+  web_data_service()->OnAutofillProfileChanged(change);
 
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
       &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_profiles.size());
   EXPECT_EQ(0, added_profile.Compare(new_sync_profiles[0]));
 }
 
 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());
+  EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
+  EXPECT_CALL(personal_data_manager(), Refresh());
   CreateRootHelper create_root(this, AUTOFILL);
   StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry updated_entry(MakeAutofillEntry("my", "entry", 1, 2));
 
-  EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _, _)).
-      WillOnce(DoAll(SetArgumentPointee<2>(updated_entry.date_created()),
-                     SetArgumentPointee<3>(updated_entry.date_last_used()),
-                     Return(true)));
+  EXPECT_CALL(autofill_table(), GetAutofillTimestamps(_, _, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<2>(updated_entry.date_created()),
+                      SetArgumentPointee<3>(updated_entry.date_last_used()),
+                      Return(true)));
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::UPDATE,
                                    updated_entry.key()));
-  web_data_service_->OnAutofillEntriesChanged(changes);
+  web_data_service()->OnAutofillEntriesChanged(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(updated_entry == new_sync_entries[0]);
 }
 
 
 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());
+  EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
+  EXPECT_CALL(personal_data_manager(), Refresh());
   CreateRootHelper create_root(this, AUTOFILL);
   StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::REMOVE,
                                    original_entry.key()));
-  web_data_service_->OnAutofillEntriesChanged(changes);
+  web_data_service()->OnAutofillEntriesChanged(changes);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
                                            &new_sync_profiles));
   ASSERT_EQ(0U, new_sync_entries.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeRemoveProfile) {
   AutofillProfile sync_profile;
   autofill::test::SetProfileInfoWithGuid(&sync_profile,
       "3BA5FA1B-1EC4-4BB3-9B57-EC92BE3C1A09", "Josephine", "Alicia", "Saenz",
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "19482937549");
   AutofillProfile* native_profile = new AutofillProfile;
   autofill::test::SetProfileInfoWithGuid(native_profile,
       "3BA5FA1B-1EC4-4BB3-9B57-EC92BE3C1A09", "Josephine", "Alicia", "Saenz",
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "19482937549");
 
   std::vector<AutofillProfile*> native_profiles;
   native_profiles.push_back(native_profile);
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).
-      WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
+  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());
+  EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   AutofillProfileChange change(
       AutofillProfileChange::REMOVE, sync_profile.guid(), NULL);
-  web_data_service_->OnAutofillProfileChanged(change);
+  web_data_service()->OnAutofillProfileChanged(change);
 
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
       &new_sync_profiles));
   ASSERT_EQ(0U, new_sync_profiles.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ServerChangeRace) {
   // Once for MergeDataAndStartSyncing() and twice for ProcessSyncChanges(), via
   // LoadAutofillData().
-  EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
-      Times(3).WillRepeatedly(Return(true));
+  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);
+  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, AUTOFILL);
   StartSyncService(create_root.callback(), false, 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(
-      sync_service_.get(), wait_for_start.get(), wait_for_syncapi.get(),
-      data_type_thread_.task_runner()));
+      sync_service(), wait_for_start.get(), wait_for_syncapi.get(),
+      data_type_thread()->task_runner()));
 
   // This server side update will stall waiting for CommitWaiter.
   updater->CreateNewEntry(MakeAutofillEntry("server", "entry", 1));
   wait_for_start->Wait();
 
   AutofillEntry syncapi_entry(MakeAutofillEntry("syncapi", "entry", 2));
   ASSERT_TRUE(AddAutofillSyncNode(syncapi_entry));
   DVLOG(1) << "Syncapi update finished.";
 
   // If we reach here, it means syncapi succeeded and we didn't deadlock. Yay!
@@ skipping 12 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();
   }
 }