Profile shouldn't own PersonalDataManager

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/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"
 #include "chrome/browser/autofill/autofill_common_test.h"
+#include "chrome/browser/autofill/personal_data_manager.h"
+#include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
 #include "chrome/browser/sync/engine/model_changing_syncer_command.h"
 #include "chrome/browser/sync/glue/autofill_change_processor.h"
 #include "chrome/browser/sync/glue/autofill_data_type_controller.h"
 #include "chrome/browser/sync/glue/autofill_model_associator.h"
 #include "chrome/browser/sync/glue/autofill_profile_data_type_controller.h"
 #include "chrome/browser/sync/glue/autofill_profile_syncable_service.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/generic_change_processor.h"
 #include "chrome/browser/sync/glue/syncable_service_adapter.h"
@@ skipping 125 matching lines @@
   }
 
   virtual WebDatabase* GetDatabase() {
     return web_database_;
   }
 
  private:
   WebDatabase* web_database_;
 };
 
-ACTION_P4(MakeAutofillSyncComponents, service, wd, pdm, dtc) {
+ACTION_P3(MakeAutofillSyncComponents, service, wd, dtc) {
   EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
   if (!BrowserThread::CurrentlyOn(BrowserThread::DB))
     return ProfileSyncFactory::SyncComponents(NULL, NULL);
   AutofillModelAssociator* model_associator =
-      new AutofillModelAssociator(service, wd, pdm);
+      new AutofillModelAssociator(service, wd, service->profile());
   AutofillChangeProcessor* change_processor =
-      new AutofillChangeProcessor(model_associator, wd, pdm, dtc);
+      new AutofillChangeProcessor(model_associator, wd,
+                                  service->profile(), dtc);
   return ProfileSyncFactory::SyncComponents(model_associator,
                                             change_processor);
 }
 
-ACTION_P4(MakeAutofillProfileSyncComponents, service, wd, pdm, dtc) {
+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, pdm, service->profile());
+      new AutofillProfileSyncableService(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);
 }
 
 class AbstractAutofillFactory {
  public:
   virtual AutofillDataTypeController* CreateDataTypeController(
       ProfileSyncFactory* factory,
       ProfileMock* profile,
       ProfileSyncService* service) = 0;
   virtual void SetExpectation(ProfileSyncFactoryMock* factory,
       ProfileSyncService* service,
       WebDatabase* wd,
-      PersonalDataManager* pdm,
       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);
   }
 
   void SetExpectation(ProfileSyncFactoryMock* factory,
       ProfileSyncService* service,
       WebDatabase* wd,
-      PersonalDataManager* pdm,
       DataTypeController* dtc) {
-    EXPECT_CALL(*factory, CreateAutofillSyncComponents(_,_,_,_)).
-        WillOnce(MakeAutofillSyncComponents(service, wd, pdm, 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);
   }
 
   void SetExpectation(ProfileSyncFactoryMock* factory,
       ProfileSyncService* service,
       WebDatabase* wd,
-      PersonalDataManager* pdm,
       DataTypeController* dtc) {
-    EXPECT_CALL(*factory, CreateAutofillProfileSyncComponents(_,_,_,_)).
-        WillOnce(MakeAutofillProfileSyncComponents(service, wd, pdm, 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() {}
 
   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_));
     web_data_service_ = new WebDataServiceFake(web_database_.get());
-    personal_data_manager_ = new PersonalDataManagerMock();
+    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();
     profile_.ResetRequestContext();
@@ skipping 12 matching lines @@
     AutofillDataTypeController* data_type_controller =
         factory->CreateDataTypeController(&factory_,
             &profile_,
             service_.get());
     SyncBackendHostForProfileSyncTest::
         SetDefaultExpectationsForWorkerCreation(&profile_);
 
     factory->SetExpectation(&factory_,
                             service_.get(),
                             web_database_.get(),
-                            personal_data_manager_.get(),
                             data_type_controller);
 
     EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
         WillOnce(ReturnNewDataTypeManager());
 
-    EXPECT_CALL(profile_, GetWebDataService(_)).
-        // TokenService::Initialize
-        // AutofillDataTypeController::StartModels()
-        // In some tests:
-        // AutofillProfileSyncableService::AutofillProfileSyncableService()
-        WillRepeatedly(Return(web_data_service_.get()));
-
-    EXPECT_CALL(profile_, GetPersonalDataManager()).
-        WillRepeatedly(Return(personal_data_manager_.get()));
-
     EXPECT_CALL(*personal_data_manager_, IsDataLoaded()).
         WillRepeatedly(Return(true));
 
      // We need tokens to get the tests going
     token_service_->IssueAuthTokenForTest(
         GaiaConstants::kSyncService, "token");
 
     EXPECT_CALL(profile_, GetTokenService()).
         WillRepeatedly(Return(token_service_.get()));
 
@@ skipping 126 matching lines @@
   friend class AddAutofillTask<AutofillEntry>;
   friend class AddAutofillTask<AutofillProfile>;
   friend class FakeServerUpdater;
 
   scoped_refptr<ThreadNotificationService> notification_service_;
 
   ProfileMock profile_;
   AutofillTableMock autofill_table_;
   scoped_ptr<WebDatabaseFake> web_database_;
   scoped_refptr<WebDataService> web_data_service_;
-  scoped_refptr<PersonalDataManagerMock> personal_data_manager_;
+  PersonalDataManagerMock* personal_data_manager_;
 };
 
 template <class T>
 class AddAutofillTask : public Task {
  public:
   AddAutofillTask(ProfileSyncServiceAutofillTest* test,
                          const std::vector<T>& entries)
       : test_(test), entries_(entries), success_(false) {
   }
 
@@ skipping 602 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();
   }
 }