AutoFill: Make PersonalDataManager RefCountedThreadSafe.

chrome/browser/sync/profile_sync_service_autofill_unittest.cc

 // Copyright (c) 2010 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 120 matching lines @@
 
 class ProfileSyncServiceAutofillTest : public testing::Test {
  protected:
   ProfileSyncServiceAutofillTest()
       : ui_thread_(ChromeThread::UI, &message_loop_),
         db_thread_(ChromeThread::DB) {
   }
 
   virtual void SetUp() {
     web_data_service_ = new WebDataServiceFake(&web_database_);
-    personal_data_manager_.Init(&profile_);
+    personal_data_manager_ = new PersonalDataManagerMock();
+    personal_data_manager_->Init(&profile_);
     db_thread_.Start();
 
     notification_service_ = new ThreadNotificationService(&db_thread_);
     notification_service_->Init();
   }
 
   virtual void TearDown() {
     service_.reset();
     notification_service_->TearDown();
     db_thread_.Stop();
     MessageLoop::current()->RunAllPending();
   }
 
   void StartSyncService(Task* task) {
     if (!service_.get()) {
       service_.reset(
           new TestProfileSyncService(&factory_, &profile_, false, false));
       service_->AddObserver(&observer_);
       AutofillDataTypeController* data_type_controller =
           new AutofillDataTypeController(&factory_,
                                          &profile_,
                                          service_.get());
 
       EXPECT_CALL(factory_, CreateAutofillSyncComponents(_, _, _, _)).
           WillOnce(MakeAutofillSyncComponents(service_.get(),
                                               &web_database_,
-                                              &personal_data_manager_,
+                                              personal_data_manager_.get(),
                                               data_type_controller));
       EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
           WillOnce(MakeDataTypeManager(&backend_));
 
       EXPECT_CALL(profile_, GetWebDataService(_)).
           WillOnce(Return(web_data_service_.get()));
 
       EXPECT_CALL(profile_, GetPersonalDataManager()).
-          WillRepeatedly(Return(&personal_data_manager_));
+          WillRepeatedly(Return(personal_data_manager_.get()));
 
-      EXPECT_CALL(personal_data_manager_, IsDataLoaded()).
+      EXPECT_CALL(*(personal_data_manager_.get()), IsDataLoaded()).
         WillRepeatedly(Return(true));
 
       // State changes once for the backend init and once for startup done.
       EXPECT_CALL(observer_, OnStateChanged()).
           WillOnce(InvokeTask(task)).
           WillOnce(Return()).
           WillOnce(QuitUIMessageLoop());
       service_->RegisterDataTypeController(data_type_controller);
       service_->Initialize();
       MessageLoop::current()->Run();
@@ skipping 124 matching lines @@
   ChromeThread db_thread_;
   scoped_refptr<ThreadNotificationService> notification_service_;
 
   scoped_ptr<TestProfileSyncService> service_;
   ProfileMock profile_;
   ProfileSyncFactoryMock factory_;
   ProfileSyncServiceObserverMock observer_;
   SyncBackendHostMock backend_;
   WebDatabaseMock web_database_;
   scoped_refptr<WebDataService> web_data_service_;
-  PersonalDataManagerMock personal_data_manager_;
+  scoped_refptr<PersonalDataManagerMock> personal_data_manager_;
 
   TestIdFactory ids_;
 };
 
 class CreateAutofillRootTask : public Task {
  public:
   explicit CreateAutofillRootTask(ProfileSyncServiceAutofillTest* test)
       : test_(test) {
   }
 
@@ skipping 85 matching lines @@
   // Owned by GetAutoFillProfiles caller.
   AutoFillProfile* profile0 = new AutoFillProfile(string16(), 0);
   autofill_unittest::SetProfileInfo(profile0,
       "Billing", "Marion", "Mitchell", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910", "01987654321");
   profiles.push_back(profile0);
   expected_profiles.push_back(*profile0);
   EXPECT_CALL(web_database_, GetAutoFillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(profiles), Return(true)));
-  EXPECT_CALL(personal_data_manager_, Refresh());
+  EXPECT_CALL(*(personal_data_manager_.get()), Refresh());
   SetIdleChangeProcessorExpectations();
   CreateAutofillRootTask task(this);
   StartSyncService(&task);
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutoFillProfile> sync_profiles;
   GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles);
   ASSERT_EQ(1U, entries.size());
   EXPECT_TRUE(entries[0] == sync_entries[0]);
   EXPECT_EQ(1U, sync_profiles.size());
   EXPECT_EQ(expected_profiles[0], sync_profiles[0]);
@@ skipping 40 matching lines @@
   autofill_unittest::SetProfileInfo(profile1,
       "Billing", "Same", "Label", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910", "01987654321");
   profiles.push_back(profile0);
   profiles.push_back(profile1);
   expected_profiles.push_back(*profile0);
   expected_profiles.push_back(*profile1);
   AutoFillProfile relabelled_profile;
   EXPECT_CALL(web_database_, GetAllAutofillEntries(_)).WillOnce(Return(true));
-  EXPECT_CALL(personal_data_manager_, Refresh());
+  EXPECT_CALL(*(personal_data_manager_.get()), Refresh());
   EXPECT_CALL(web_database_, GetAutoFillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(profiles), Return(true)));
   EXPECT_CALL(web_database_, UpdateAutoFillProfile(
       ProfileMatchesExceptLabel(expected_profiles[1]))).
       WillOnce(DoAll(SaveArg<0>(&relabelled_profile), Return(true)));
 
   SetIdleChangeProcessorExpectations();
   CreateAutofillRootTask task(this);
   StartSyncService(&task);
   std::vector<AutofillEntry> sync_entries;
@@ skipping 59 matching lines @@
   std::vector<AutoFillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillEntriesTask task(this, sync_entries, sync_profiles);
 
   AutoFillProfile to_be_added(sync_profile);
   to_be_added.set_unique_id(1);
   EXPECT_CALL(web_database_, UpdateAutofillEntries(ElementsAre(sync_entry))).
       WillOnce(Return(true));
   EXPECT_CALL(web_database_, AddAutoFillProfile(Eq(to_be_added))).
       WillOnce(Return(true));
-  EXPECT_CALL(personal_data_manager_, Refresh());
+  EXPECT_CALL(*(personal_data_manager_.get()), Refresh());
   StartSyncService(&task);
 
   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;
   GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles);
   std::set<AutofillEntry> new_sync_entries_set(new_sync_entries.begin(),
@@ skipping 51 matching lines @@
   EXPECT_CALL(web_database_, GetAutoFillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutoFillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillEntriesTask task(this, sync_entries, sync_profiles);
 
   EXPECT_CALL(web_database_, UpdateAutoFillProfile(Eq(sync_profile))).
       WillOnce(Return(true));
-  EXPECT_CALL(personal_data_manager_, Refresh());
+  EXPECT_CALL(*(personal_data_manager_.get()), Refresh());
   StartSyncService(&task);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutoFillProfile> new_sync_profiles;
   GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles);
   ASSERT_EQ(1U, new_sync_profiles.size());
   EXPECT_TRUE(sync_profile == new_sync_profiles[0]);
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeAddEntry) {
@@ skipping 76 matching lines @@
       "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
       "32801", "US", "19482937549", "13502849239");
 
   AutofillProfileChange change(AutofillProfileChange::ADD,
       added_profile.Label(), &added_profile, string16());
 
   AutoFillProfile relabelled_profile;
   EXPECT_CALL(web_database_, UpdateAutoFillProfile(
       ProfileMatchesExceptLabel(added_profile))).
       WillOnce(DoAll(SaveArg<0>(&relabelled_profile), Return(true)));
-  EXPECT_CALL(personal_data_manager_, Refresh());
+  EXPECT_CALL(*(personal_data_manager_.get()), Refresh());
 
   scoped_refptr<ThreadNotifier> notifier = new ThreadNotifier(&db_thread_);
   notifier->Notify(NotificationType::AUTOFILL_PROFILE_CHANGED,
                    Source<WebDataService>(web_data_service_.get()),
                    Details<AutofillProfileChange>(&change));
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutoFillProfile> new_sync_profiles;
   GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles);
   ASSERT_EQ(2U, new_sync_profiles.size());
@@ skipping 129 matching lines @@
   EXPECT_CALL(web_database_, GetAutoFillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
   CreateAutofillRootTask task(this);
   StartSyncService(&task);
 
   josephine_update.set_label(ASCIIToUTF16("ExistingLabel"));
   AutoFillProfile relabelled_profile;
   EXPECT_CALL(web_database_, UpdateAutoFillProfile(
       ProfileMatchesExceptLabel(josephine_update))).
       WillOnce(DoAll(SaveArg<0>(&relabelled_profile), Return(true)));
-  EXPECT_CALL(personal_data_manager_, Refresh());
+  EXPECT_CALL(*(personal_data_manager_.get()), Refresh());
 
   AutofillProfileChange change(AutofillProfileChange::UPDATE,
                                josephine_update.Label(), &josephine_update,
                                ASCIIToUTF16("Billing"));
   scoped_refptr<ThreadNotifier> notifier = new ThreadNotifier(&db_thread_);
   notifier->Notify(NotificationType::AUTOFILL_PROFILE_CHANGED,
                    Source<WebDataService>(web_data_service_.get()),
                    Details<AutofillProfileChange>(&change));
 
   std::vector<AutofillEntry> new_sync_entries;
@@ skipping 48 matching lines @@
   native_profiles.push_back(native_profile);
   EXPECT_CALL(web_database_, GetAllAutofillEntries(_)). WillOnce(Return(true));
   EXPECT_CALL(web_database_, GetAutoFillProfiles(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutoFillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillEntriesTask task(this, sync_entries, sync_profiles);
 
-  EXPECT_CALL(personal_data_manager_, Refresh());
+  EXPECT_CALL(*(personal_data_manager_.get()), Refresh());
   StartSyncService(&task);
 
   AutofillProfileChange change(AutofillProfileChange::REMOVE,
                                sync_profile.Label(), NULL, string16());
   scoped_refptr<ThreadNotifier> notifier = new ThreadNotifier(&db_thread_);
   notifier->Notify(NotificationType::AUTOFILL_PROFILE_CHANGED,
                    Source<WebDataService>(web_data_service_.get()),
                    Details<AutofillProfileChange>(&change));
 
   std::vector<AutofillEntry> new_sync_entries;
@@ skipping 24 matching lines @@
   // Wait for the PPS to shut everything down and signal us.
   EXPECT_CALL(observer_, OnStateChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
   EXPECT_TRUE(service_->unrecoverable_error_detected());
 
   // Ensure future autofill notifications don't crash.
   notifier->Notify(NotificationType::AUTOFILL_ENTRIES_CHANGED,
                    Source<WebDataService>(web_data_service_.get()),
                    Details<AutofillChangeList>(&changes));
 }