The AutofillProfileSyncableService's lifetime should be managed by the WebDataService

chrome/browser/sync/profile_sync_service_autofill_unittest.cc

 // Copyright (c) 2011 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"
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string16.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 32 matching lines @@
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::Time;
 using base::WaitableEvent;
 using browser_sync::AutofillChangeProcessor;
 using browser_sync::AutofillDataTypeController;
 using browser_sync::AutofillModelAssociator;
 using browser_sync::AutofillProfileDataTypeController;
-using browser_sync::AutofillProfileSyncableService;
 using browser_sync::DataTypeController;
 using browser_sync::GenericChangeProcessor;
 using browser_sync::SyncableServiceAdapter;
 using browser_sync::GROUP_DB;
 using browser_sync::kAutofillTag;
 using browser_sync::SyncBackendHostForProfileSyncTest;
 using browser_sync::UnrecoverableErrorHandler;
 using syncable::CREATE_NEW_UPDATE_ITEM;
 using syncable::AUTOFILL;
 using syncable::BASE_VERSION;
@@ skipping 103 matching lines @@
                                   service->profile(), dtc);
   return ProfileSyncFactory::SyncComponents(model_associator,
                                             change_processor);
 }
 
 ACTION_P3(MakeAutofillProfileSyncComponents, service, wd, dtc) {
   EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
   if (!BrowserThread::CurrentlyOn(BrowserThread::DB))
     return ProfileSyncFactory::SyncComponents(NULL, NULL);
   AutofillProfileSyncableService* sync_service =
-      new AutofillProfileSyncableService(wd, service->profile());
+      wd->GetAutofillTable()->GetSyncableService(wd, service->profile());
   sync_api::UserShare* user_share = service->GetUserShare();
   GenericChangeProcessor* change_processor =
       new GenericChangeProcessor(sync_service, dtc, user_share);
   SyncableServiceAdapter* sync_service_adapter =
       new SyncableServiceAdapter(syncable::AUTOFILL_PROFILE,
                                  sync_service,
                                  change_processor);
   return ProfileSyncFactory::SyncComponents(sync_service_adapter,
                                             change_processor);
 }
@@ skipping 10 matching lines @@
       DataTypeController* dtc) = 0;
   virtual ~AbstractAutofillFactory() {}
 };
 
 class AutofillEntryFactory : public AbstractAutofillFactory {
  public:
   browser_sync::AutofillDataTypeController* CreateDataTypeController(
       ProfileSyncFactory* factory,
       ProfileMock* profile,
       ProfileSyncService* service) {
-    return new AutofillDataTypeController(factory,
-        profile);
+    return new AutofillDataTypeController(factory, profile);
   }
 
   void SetExpectation(ProfileSyncFactoryMock* factory,
-      ProfileSyncService* service,
-      WebDatabase* wd,
-      DataTypeController* dtc) {
+                      ProfileSyncService* service,
+                      WebDatabase* wd,
+                      DataTypeController* dtc) {
     EXPECT_CALL(*factory, CreateAutofillSyncComponents(_,_,_)).
         WillOnce(MakeAutofillSyncComponents(service, wd, dtc));
   }
 };
 
 class AutofillProfileFactory : public AbstractAutofillFactory {
  public:
   browser_sync::AutofillDataTypeController* CreateDataTypeController(
       ProfileSyncFactory* factory,
       ProfileMock* profile,
       ProfileSyncService* service) {
-    return new AutofillProfileDataTypeController(factory,
-        profile);
+    return new AutofillProfileDataTypeController(factory, profile);
   }
 
   void SetExpectation(ProfileSyncFactoryMock* factory,
-      ProfileSyncService* service,
-      WebDatabase* wd,
-      DataTypeController* dtc) {
+                      ProfileSyncService* service,
+                      WebDatabase* wd,
+                      DataTypeController* dtc) {
     EXPECT_CALL(*factory, CreateAutofillProfileSyncComponents(_,_,_)).
         WillOnce(MakeAutofillProfileSyncComponents(service, wd, dtc));
   }
 };
 
 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 AddAutofillTask;
 
 class ProfileSyncServiceAutofillTest : public AbstractProfileSyncServiceTest {
  protected:
-  ProfileSyncServiceAutofillTest() {}
+  ProfileSyncServiceAutofillTest()
+      : autofill_table_created_or_destroyed_(false, false) {
+  }
 
   AutofillProfileFactory profile_factory_;
   AutofillEntryFactory entry_factory_;
 
   AbstractAutofillFactory* GetFactory(syncable::ModelType type) {
     if (type == syncable::AUTOFILL) {
       return &entry_factory_;
     } else if (type == syncable::AUTOFILL_PROFILE) {
       return &profile_factory_;
     } else {
       NOTREACHED();
       return NULL;
     }
   }
 
   virtual void SetUp() {
     AbstractProfileSyncServiceTest::SetUp();
     profile_.CreateRequestContext();
-    web_database_.reset(new WebDatabaseFake(&autofill_table_));
+
+    // The |autofill_table_| must be constructed on the DB thread.
+    BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
+        base::Bind(&ProfileSyncServiceAutofillTest::CreateAutofillTable,
+                   base::Unretained(this)));
+    ASSERT_TRUE(autofill_table_created_or_destroyed_.Wait());
+
+    web_database_.reset(new WebDatabaseFake(autofill_table_.get()));
     web_data_service_ = new WebDataServiceFake(web_database_.get());
     personal_data_manager_ = static_cast<PersonalDataManagerMock*>(
         PersonalDataManagerFactory::GetInstance()->SetTestingFactoryAndUse(
             &profile_, PersonalDataManagerMock::Build));
     EXPECT_CALL(*personal_data_manager_, LoadProfiles()).Times(1);
     EXPECT_CALL(*personal_data_manager_, LoadCreditCards()).Times(1);
     EXPECT_CALL(profile_, GetWebDataService(_)).
         // TokenService::Initialize
         // AutofillDataTypeController::StartModels()
         // In some tests:
         // AutofillProfileSyncableService::AutofillProfileSyncableService()
         WillRepeatedly(Return(web_data_service_.get()));
     personal_data_manager_->Init(&profile_);
 
     notification_service_ = new ThreadNotificationService(&db_thread_);
     notification_service_->Init();
   }
 
   virtual void TearDown() {
     service_.reset();
     notification_service_->TearDown();
+
+    // The |autofill_table_| must be destroyed on the DB thread.
+    BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
+        base::Bind(&ProfileSyncServiceAutofillTest::DestroyAutofillTable,
+                   base::Unretained(this)));
+    ASSERT_TRUE(autofill_table_created_or_destroyed_.Wait());
+
     profile_.ResetRequestContext();
     AbstractProfileSyncServiceTest::TearDown();
   }
 
+  void CreateAutofillTable() {
+    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
+    autofill_table_.reset(new AutofillTableMock);
+    autofill_table_created_or_destroyed_.Signal();
+  }
+
+  void DestroyAutofillTable() {
+    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
+    autofill_table_.reset();
+    autofill_table_created_or_destroyed_.Signal();
+  }
+
   void StartSyncService(Task* task,
                         bool will_fail_association,
                         syncable::ModelType type) {
     AbstractAutofillFactory* factory = GetFactory(type);
     service_.reset(
         new TestProfileSyncService(&factory_, &profile_, "test_user", false,
                                    task));
     EXPECT_CALL(profile_, GetProfileSyncService()).WillRepeatedly(
         Return(service_.get()));
     AutofillDataTypeController* data_type_controller =
         factory->CreateDataTypeController(&factory_,
             &profile_,
             service_.get());
     SyncBackendHostForProfileSyncTest::
         SetDefaultExpectationsForWorkerCreation(&profile_);
 
     factory->SetExpectation(&factory_,
                             service_.get(),
                             web_database_.get(),
                             data_type_controller);
 
     EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
         WillOnce(ReturnNewDataTypeManager());
 
     EXPECT_CALL(*personal_data_manager_, IsDataLoaded()).
         WillRepeatedly(Return(true));
 
      // We need tokens to get the tests going
-    token_service_->IssueAuthTokenForTest(
-        GaiaConstants::kSyncService, "token");
+    token_service_->IssueAuthTokenForTest(GaiaConstants::kSyncService, "token");
 
     EXPECT_CALL(profile_, GetTokenService()).
         WillRepeatedly(Return(token_service_.get()));
 
     service_->RegisterDataTypeController(data_type_controller);
     service_->Initialize();
     MessageLoop::current()->Run();
   }
 
   bool AddAutofillSyncNode(const AutofillEntry& entry) {
     sync_api::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     sync_api::ReadNode autofill_root(&trans);
     if (!autofill_root.InitByTagLookup(browser_sync::kAutofillTag))
       return false;
 
     sync_api::WriteNode node(&trans);
     std::string tag = AutofillModelAssociator::KeyToTag(entry.key().name(),
                                                         entry.key().value());
     if (!node.InitUniqueByCreation(syncable::AUTOFILL, autofill_root, tag))
       return false;
 
     AutofillChangeProcessor::WriteAutofillEntry(entry, &node);
     return true;
   }
 
   bool AddAutofillSyncNode(const AutofillProfile& profile) {
     sync_api::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     sync_api::ReadNode autofill_root(&trans);
-    if (!autofill_root.InitByTagLookup(browser_sync::kAutofillProfileTag))
+    if (!autofill_root.InitByTagLookup(kAutofillProfileTag))
       return false;
     sync_api::WriteNode node(&trans);
     std::string tag = profile.guid();
     if (!node.InitUniqueByCreation(syncable::AUTOFILL_PROFILE,
         autofill_root, tag))
       return false;
     sync_pb::EntitySpecifics specifics;
     AutofillProfileSyncableService::WriteAutofillProfile(profile, &specifics);
     sync_pb::AutofillProfileSpecifics* profile_specifics =
         specifics.MutableExtension(sync_pb::autofill_profile);
@@ skipping 35 matching lines @@
       }
       child_id = child_node.GetSuccessorId();
     }
     return true;
   }
 
   bool GetAutofillProfilesFromSyncDBUnderProfileNode(
       std::vector<AutofillProfile>* profiles) {
     sync_api::ReadTransaction trans(FROM_HERE, service_->GetUserShare());
     sync_api::ReadNode autofill_root(&trans);
-    if (!autofill_root.InitByTagLookup(browser_sync::kAutofillProfileTag))
+    if (!autofill_root.InitByTagLookup(kAutofillProfileTag))
       return false;
 
     int64 child_id = autofill_root.GetFirstChildId();
     while (child_id != sync_api::kInvalidId) {
       sync_api::ReadNode child_node(&trans);
       if (!child_node.InitByIdLookup(child_id))
         return false;
 
       const sync_pb::AutofillProfileSpecifics& autofill(
           child_node.GetAutofillProfileSpecifics());
         AutofillProfile p;
         p.set_guid(autofill.guid());
         AutofillProfileSyncableService::OverwriteProfileWithServerData(
             autofill, &p);
         profiles->push_back(p);
       child_id = child_node.GetSuccessorId();
     }
     return true;
   }
 
   void SetIdleChangeProcessorExpectations() {
-    EXPECT_CALL(autofill_table_, RemoveFormElement(_, _)).Times(0);
-    EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _)).Times(0);
-    EXPECT_CALL(autofill_table_, UpdateAutofillEntries(_)).Times(0);
+    EXPECT_CALL(*autofill_table_, RemoveFormElement(_, _)).Times(0);
+    EXPECT_CALL(*autofill_table_, GetAutofillTimestamps(_, _, _)).Times(0);
+    EXPECT_CALL(*autofill_table_, UpdateAutofillEntries(_)).Times(0);
   }
 
   static AutofillEntry MakeAutofillEntry(const char* name,
                                          const char* value,
                                          time_t timestamp0,
                                          time_t timestamp1) {
     std::vector<Time> timestamps;
     if (timestamp0 > 0)
       timestamps.push_back(Time::FromTimeT(timestamp0));
     if (timestamp1 > 0)
       timestamps.push_back(Time::FromTimeT(timestamp1));
     return AutofillEntry(
         AutofillKey(ASCIIToUTF16(name), ASCIIToUTF16(value)), timestamps);
   }
 
   static AutofillEntry MakeAutofillEntry(const char* name,
                                          const char* value,
                                          time_t timestamp) {
     return MakeAutofillEntry(name, value, timestamp, -1);
   }
 
   friend class AddAutofillTask<AutofillEntry>;
   friend class AddAutofillTask<AutofillProfile>;
   friend class FakeServerUpdater;
 
   scoped_refptr<ThreadNotificationService> notification_service_;
 
   ProfileMock profile_;
-  AutofillTableMock autofill_table_;
+  scoped_ptr<AutofillTableMock> autofill_table_;
+  WaitableEvent autofill_table_created_or_destroyed_;
   scoped_ptr<WebDatabaseFake> web_database_;
   scoped_refptr<WebDataService> web_data_service_;
   PersonalDataManagerMock* personal_data_manager_;
 };
 
 template <class T>
 class AddAutofillTask : public Task {
  public:
   AddAutofillTask(ProfileSyncServiceAutofillTest* test,
-                         const std::vector<T>& entries)
+                  const std::vector<T>& entries)
       : test_(test), entries_(entries), success_(false) {
   }
 
   virtual void Run() {
     if (!test_->CreateRoot(GetModelType<T>()))
       return;
     for (size_t i = 0; i < entries_.size(); ++i) {
       if (!test_->AddAutofillSyncNode(entries_[i]))
         return;
     }
@@ skipping 135 matching lines @@
 // 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(NULL, true, syncable::AUTOFILL);
   EXPECT_TRUE(service_->unrecoverable_error_detected());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, EmptyNativeEmptySync) {
-  EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).WillOnce(Return(true));
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_,
+              GetAllAutofillEntries(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreateRootTask task(this, syncable::AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.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(_)).
+  EXPECT_CALL(*autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreateRootTask task(this, syncable::AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.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(_)).
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(profiles), Return(true)));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootTask task(this, syncable::AUTOFILL_PROFILE);
   StartSyncService(&task, false, syncable::AUTOFILL_PROFILE);
   ASSERT_TRUE(task.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(_)).
+  EXPECT_CALL(*autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreateRootTask task(this, syncable::AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.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(_)).
+  EXPECT_CALL(*autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
 
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
 
   std::vector<AutofillEntry> sync_entries;
   sync_entries.push_back(sync_entry);
 
   AddAutofillTask<AutofillEntry> task(this, sync_entries);
 
-  EXPECT_CALL(autofill_table_, UpdateAutofillEntries(ElementsAre(sync_entry))).
+  EXPECT_CALL(*autofill_table_, UpdateAutofillEntries(ElementsAre(sync_entry))).
       WillOnce(Return(true));
 
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.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(_)).
+  EXPECT_CALL(*autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
 
   std::vector<AutofillEntry> sync_entries;
   sync_entries.push_back(sync_entry);
   AddAutofillTask<AutofillEntry> task(this, sync_entries);
 
-  EXPECT_CALL(autofill_table_,
+  EXPECT_CALL(*autofill_table_,
       UpdateAutofillEntries(ElementsAre(merged_entry))).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.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(_)).
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillTask<AutofillProfile> task(this, sync_profiles);
 
-  EXPECT_CALL(autofill_table_, UpdateAutofillProfile(_)).
+  EXPECT_CALL(*autofill_table_, UpdateAutofillProfile(_)).
       WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(&task, false, syncable::AUTOFILL_PROFILE);
   ASSERT_TRUE(task.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 11 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(_)).
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillTask<AutofillProfile> task(this, sync_profiles);
 
-  EXPECT_CALL(autofill_table_, AddAutofillProfile(_)).
+  EXPECT_CALL(*autofill_table_, AddAutofillProfile(_)).
       WillOnce(Return(true));
-  EXPECT_CALL(autofill_table_, RemoveAutofillProfile(native_guid)).
+  EXPECT_CALL(*autofill_table_, RemoveAutofillProfile(native_guid)).
       WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(&task, false, syncable::AUTOFILL_PROFILE);
   ASSERT_TRUE(task.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(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_,
+              GetAllAutofillEntries(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootTask task(this, syncable::AUTOFILL);
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.success());
 
   AutofillEntry added_entry(MakeAutofillEntry("added", "entry", 1));
   std::vector<base::Time> timestamps(added_entry.timestamps());
 
-  EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _)).
+  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_));
   notifier->Notify(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
                    Source<WebDataService>(web_data_service_.get()),
                    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(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootTask task(this, syncable::AUTOFILL_PROFILE);
   StartSyncService(&task, false, syncable::AUTOFILL_PROFILE);
   ASSERT_TRUE(task.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",
@@ skipping 11 matching lines @@
       &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(_)).
+  EXPECT_CALL(*autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   CreateRootTask task(this, syncable::AUTOFILL);
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.success());
 
   AutofillEntry updated_entry(MakeAutofillEntry("my", "entry", 1, 2));
   std::vector<base::Time> timestamps(updated_entry.timestamps());
 
-  EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _)).
+  EXPECT_CALL(*autofill_table_, GetAutofillTimestamps(_, _, _)).
       WillOnce(DoAll(SetArgumentPointee<2>(timestamps), Return(true)));
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::UPDATE,
                                    updated_entry.key()));
   scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(&db_thread_));
   notifier->Notify(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
                    Source<WebDataService>(web_data_service_.get()),
                    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(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(_)).
+  EXPECT_CALL(*autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   CreateRootTask task(this, syncable::AUTOFILL);
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.success());
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::REMOVE,
                                    original_entry.key()));
   scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(&db_thread_));
   notifier->Notify(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
@@ skipping 14 matching lines @@
       "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(_)).
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillTask<AutofillProfile> task(this, sync_profiles);
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(&task, false, syncable::AUTOFILL_PROFILE);
   ASSERT_TRUE(task.success());
 
   AutofillProfileChange change(AutofillProfileChange::REMOVE,
                                sync_profile.guid(), NULL);
   scoped_refptr<ThreadNotifier> notifier(new ThreadNotifier(&db_thread_));
   notifier->Notify(chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
                    Source<WebDataService>(web_data_service_.get()),
                    Details<AutofillProfileChange>(&change));
 
   std::vector<AutofillProfile> new_sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
       &new_sync_profiles));
   ASSERT_EQ(0U, new_sync_profiles.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeError) {
-  EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).WillOnce(Return(true));
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_,
+              GetAllAutofillEntries(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   CreateRootTask task(this, syncable::AUTOFILL);
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.success());
 
   // Inject an evil entry into the sync db to conflict with the same
   // entry added by the user.
   AutofillEntry evil_entry(MakeAutofillEntry("evil", "entry", 1));
   ASSERT_TRUE(AddAutofillSyncNode(evil_entry));
 
@@ skipping 13 matching lines @@
   EXPECT_TRUE(service_->unrecoverable_error_detected());
 
   // Ensure future autofill notifications don't crash.
   notifier->Notify(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED,
                    Source<WebDataService>(web_data_service_.get()),
                    Details<AutofillChangeList>(&changes));
 }
 
 // Crashy, http://crbug.com/57884
 TEST_F(ProfileSyncServiceAutofillTest, DISABLED_ServerChangeRace) {
-  EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).WillOnce(Return(true));
-  EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
-  EXPECT_CALL(autofill_table_, UpdateAutofillEntries(_)).
+  EXPECT_CALL(*autofill_table_,
+              GetAllAutofillEntries(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
+  EXPECT_CALL(*autofill_table_, UpdateAutofillEntries(_)).
       WillRepeatedly(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh()).Times(3);
   CreateRootTask task(this, syncable::AUTOFILL);
   StartSyncService(&task, false, syncable::AUTOFILL);
   ASSERT_TRUE(task.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(
@@ skipping 18 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++) {
     VLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
             << ", " << sync_entries[i].key().value();
   }
 }