Profile shouldn't own PersonalDataManager

chrome/browser/autofill/autofill_manager_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 <vector>
 
-#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/tuple.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete_history_manager.h"
 #include "chrome/browser/autofill/autofill_common_test.h"
 #include "chrome/browser/autofill/autofill_manager.h"
 #include "chrome/browser/autofill/autofill_profile.h"
 #include "chrome/browser/autofill/credit_card.h"
 #include "chrome/browser/autofill/personal_data_manager.h"
+#include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/tab_contents/test_tab_contents_wrapper.h"
 #include "chrome/common/autofill_messages.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/tab_contents/test_tab_contents.h"
@@ skipping 21 matching lines @@
                std::vector<string16>,
                std::vector<int> > AutofillParam;
 
 class TestPersonalDataManager : public PersonalDataManager {
  public:
   TestPersonalDataManager() {
     CreateTestAutofillProfiles(&web_profiles_);
     CreateTestCreditCards(&credit_cards_);
   }
 
+  // Factory method for keyed service.  PersonalDataManager is NULL for testing.
+  static ProfileKeyedService* Build(Profile* profile) {
+    return NULL;
+  }
+
   MOCK_METHOD1(SaveImportedProfile, void(const AutofillProfile&));
 
   AutofillProfile* GetProfileWithGUID(const char* guid) {
     for (std::vector<AutofillProfile *>::iterator it = web_profiles_.begin();
          it != web_profiles_.end(); ++it) {
       if (!(*it)->guid().compare(guid))
         return *it;
     }
     return NULL;
   }
@@ skipping 319 matching lines @@
                                               const char* month) {
   ExpectFilledForm(page_id, filled_form, expected_page_id,
                    "", "", "", "", "", "", "", "", "", "", "",
                    "Miku Hatsune", "4234567890654321", month, year,
                    has_address_fields, true, true);
 }
 
 class TestAutofillManager : public AutofillManager {
  public:
   TestAutofillManager(TabContentsWrapper* tab_contents,
-                      TestPersonalDataManager* personal_manager)
-      : AutofillManager(tab_contents, personal_manager),
+                      TestPersonalDataManager* personal_data)
+      : AutofillManager(tab_contents, personal_data),
+        personal_data_(personal_data),
         autofill_enabled_(true) {
-    test_personal_data_ = personal_manager;
   }
 
   virtual bool IsAutofillEnabled() const OVERRIDE { return autofill_enabled_; }
 
   void set_autofill_enabled(bool autofill_enabled) {
     autofill_enabled_ = autofill_enabled;
   }
 
   virtual void UploadFormData(const FormStructure& submitted_form) OVERRIDE {
     submitted_form_signature_ = submitted_form.FormSignature();
   }
 
   const std::string GetSubmittedFormSignature() {
     return submitted_form_signature_;
   }
 
   AutofillProfile* GetProfileWithGUID(const char* guid) {
-    return test_personal_data_->GetProfileWithGUID(guid);
+    return personal_data_->GetProfileWithGUID(guid);
   }
 
   void AddProfile(AutofillProfile* profile) {
-    test_personal_data_->AddProfile(profile);
+    personal_data_->AddProfile(profile);
   }
 
   void AddCreditCard(CreditCard* credit_card) {
-    test_personal_data_->AddCreditCard(credit_card);
+    personal_data_->AddCreditCard(credit_card);
   }
 
   int GetPackedCreditCardID(int credit_card_id) {
     return PackGUIDs(IDToGUID(credit_card_id), GUIDPair(std::string(), 0));
   }
 
   virtual int GUIDToID(const GUIDPair& guid) const OVERRIDE {
     if (guid.first.empty())
       return 0;
 
     int id;
     EXPECT_TRUE(base::StringToInt(guid.first.substr(guid.first.rfind("-") + 1),
                                   &id));
     return id;
   }
 
   virtual const GUIDPair IDToGUID(int id) const OVERRIDE {
     EXPECT_TRUE(id >= 0);
     if (id <= 0)
       return GUIDPair(std::string(), 0);
 
     return GUIDPair(base::StringPrintf("00000000-0000-0000-0000-%012d", id), 0);
   }
 
   void AddSeenForm(FormStructure* form) {
     form_structures()->push_back(form);
   }
 
  private:
-  TestPersonalDataManager* test_personal_data_;
+  // Weak reference.
+  TestPersonalDataManager* personal_data_;
   bool autofill_enabled_;
   std::string submitted_form_signature_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
 };
 
 }  // namespace
 
 class AutofillManagerTest : public TabContentsWrapperTestHarness {
  public:
   typedef AutofillManager::GUIDPair GUIDPair;
 
   AutofillManagerTest()
       : TabContentsWrapperTestHarness(),
         browser_thread_(BrowserThread::UI, &message_loop_) {}
 
   virtual ~AutofillManagerTest() {
     // Order of destruction is important as AutofillManager relies on
     // PersonalDataManager to be around when it gets destroyed.
     autofill_manager_.reset(NULL);
-    test_personal_data_ = NULL;
   }
 
   virtual void SetUp() {
+    Profile* profile = new TestingProfile();
+    browser_context_.reset(profile);
+    PersonalDataManagerFactory::GetInstance()->SetTestingFactory(
+        profile, TestPersonalDataManager::Build);
+
     TabContentsWrapperTestHarness::SetUp();
-    test_personal_data_ = new TestPersonalDataManager();
     autofill_manager_.reset(new TestAutofillManager(contents_wrapper(),
-                                                    test_personal_data_.get()));
+                                                    &personal_data_));
   }
 
   void GetAutofillSuggestions(int query_id,
                               const webkit_glue::FormData& form,
                               const webkit_glue::FormField& field) {
     autofill_manager_->OnQueryFormFieldAutofill(query_id, form, field);
   }
 
   void GetAutofillSuggestions(const webkit_glue::FormData& form,
                               const webkit_glue::FormField& field) {
@@ skipping 63 matching lines @@
       *results = autofill_param.b;
 
     process()->sink().ClearMessages();
     return true;
   }
 
  protected:
   BrowserThread browser_thread_;
 
   scoped_ptr<TestAutofillManager> autofill_manager_;
-  scoped_refptr<TestPersonalDataManager> test_personal_data_;
+  TestPersonalDataManager personal_data_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AutofillManagerTest);
 };
 
 class TestFormStructure : public FormStructure {
  public:
   explicit TestFormStructure(const FormData& form) : FormStructure(form) {}
   virtual ~TestFormStructure() {}
 
@@ skipping 240 matching lines @@
     ASCIIToUTF16("Jason")
   };
   string16 expected_labels2[] = {string16(), string16(), string16()};
   string16 expected_icons2[] = {string16(), string16(), string16()};
   int expected_unique_ids2[] = {-1, 0, 0};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kPageID2, arraysize(expected_values2), expected_values2,
                     expected_labels2, expected_icons2, expected_unique_ids2);
 
   // Now clear the test profiles and try again -- we shouldn't return a warning.
-  test_personal_data_->ClearAutofillProfiles();
+  personal_data_.ClearAutofillProfiles();
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(GetAutofillSuggestionsMessage(NULL, NULL, NULL, NULL, NULL));
 }
 
 // Test that we return all credit card profile suggestions when all form fields
 // are empty.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsEmptyValue) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
@@ skipping 166 matching lines @@
     ASCIIToUTF16("Jason")
   };
   string16 expected_labels2[] = {string16(), string16(), string16()};
   string16 expected_icons2[] = {string16(), string16(), string16()};
   int expected_unique_ids2[] = {-1, 0, 0};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kPageID2, arraysize(expected_values2), expected_values2,
                     expected_labels2, expected_icons2, expected_unique_ids2);
 
   // Clear the test credit cards and try again -- we shouldn't return a warning.
-  test_personal_data_->ClearCreditCards();
+  personal_data_.ClearCreditCards();
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(GetAutofillSuggestionsMessage(NULL, NULL, NULL, NULL, NULL));
 }
 
 // Test that we return all credit card suggestions in the case that two cards
 // have the same obfuscated number.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsRepeatedObfuscatedNumber) {
   // Add a credit card with the same obfuscated number as Elvis's.
   // |credit_card| will be owned by the mock PersonalDataManager.
   CreditCard* credit_card = new CreditCard;
@@ skipping 180 matching lines @@
     l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION)
   };
   string16 expected_labels2[] = {string16()};
   string16 expected_icons2[] = {string16()};
   int expected_unique_ids2[] = {-1};
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kPageID2, arraysize(expected_values2), expected_values2,
                     expected_labels2, expected_icons2, expected_unique_ids2);
 
   // Clear the test credit cards and try again -- we shouldn't return a warning.
-  test_personal_data_->ClearCreditCards();
+  personal_data_.ClearCreditCards();
   GetAutofillSuggestions(form, field);
   EXPECT_FALSE(GetAutofillSuggestionsMessage(NULL, NULL, NULL, NULL, NULL));
 }
 
 // Test that we correctly combine autofill and autocomplete suggestions.
 TEST_F(AutofillManagerTest, GetCombinedAutofillAndAutocompleteSuggestions) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
@@ skipping 174 matching lines @@
 
   // |profile| will be owned by the mock PersonalDataManager.
   AutofillProfile* profile = new AutofillProfile;
   autofill_test::SetProfileInfo(profile, "Elvis", "", "Presley", "me@x.com", "",
                                 "", "", "", "", "", "", "");
   profile->set_guid("00000000-0000-0000-0000-000000000101");
   std::vector<string16> multi_values(2);
   multi_values[0] = ASCIIToUTF16("Elvis Presley");
   multi_values[1] = ASCIIToUTF16("Elena Love");
   profile->SetMultiInfo(NAME_FULL, multi_values);
-  test_personal_data_->ClearAutofillProfiles();
+  personal_data_.ClearAutofillProfiles();
   autofill_manager_->AddProfile(profile);
 
   {
     // Get the first name field.
     // Start out with "E", hoping for either "Elvis" or "Elena.
     FormField& field = form.fields[0];
     field.value = ASCIIToUTF16("E");
     field.is_autofilled = false;
     GetAutofillSuggestions(form, field);
 
@@ skipping 195 matching lines @@
   FormData results;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
   ExpectFilledCreditCardFormElvis(page_id, results, kDefaultPageID, false);
 }
 
 // Test that we correctly fill a credit card form with month input type.
 // 1. year empty, month empty
 TEST_F(AutofillManagerTest, FillCreditCardFormNoYearNoMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
-  test_personal_data_->CreateTestCreditCardsYearAndMonth("", "");
+  personal_data_.CreateTestCreditCardsYearAndMonth("", "");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   GUIDPair empty(std::string(), 0);
   FillAutofillFormData(
       kDefaultPageID, form, *form.fields.begin(),
       autofill_manager_->PackGUIDs(guid, empty));
 
   int page_id = 0;
   FormData results;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
   ExpectFilledCreditCardYearMonthWithYearMonth(page_id, results,
       kDefaultPageID, false, "", "");
 }
 
 
 // Test that we correctly fill a credit card form with month input type.
 // 2. year empty, month non-empty
 TEST_F(AutofillManagerTest, FillCreditCardFormNoYearMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
-  test_personal_data_->CreateTestCreditCardsYearAndMonth("", "04");
+  personal_data_.CreateTestCreditCardsYearAndMonth("", "04");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   GUIDPair empty(std::string(), 0);
   FillAutofillFormData(
       kDefaultPageID, form, *form.fields.begin(),
       autofill_manager_->PackGUIDs(guid, empty));
 
   int page_id = 0;
   FormData results;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
   ExpectFilledCreditCardYearMonthWithYearMonth(page_id, results,
       kDefaultPageID, false, "", "04");
 }
 
 // Test that we correctly fill a credit card form with month input type.
 // 3. year non-empty, month empty
 TEST_F(AutofillManagerTest, FillCreditCardFormYearNoMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
-  test_personal_data_->CreateTestCreditCardsYearAndMonth("2012", "");
+  personal_data_.CreateTestCreditCardsYearAndMonth("2012", "");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   GUIDPair empty(std::string(), 0);
   FillAutofillFormData(
       kDefaultPageID, form, *form.fields.begin(),
       autofill_manager_->PackGUIDs(guid, empty));
 
   int page_id = 0;
   FormData results;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
   ExpectFilledCreditCardYearMonthWithYearMonth(page_id, results,
       kDefaultPageID, false, "2012", "");
 }
 
 // Test that we correctly fill a credit card form with month input type.
 // 4. year non-empty, month empty
 TEST_F(AutofillManagerTest, FillCreditCardFormYearMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
-  test_personal_data_->ClearCreditCards();
-  test_personal_data_->CreateTestCreditCardsYearAndMonth("2012", "04");
+  personal_data_.ClearCreditCards();
+  personal_data_.CreateTestCreditCardsYearAndMonth("2012", "04");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   GUIDPair empty(std::string(), 0);
   FillAutofillFormData(
       kDefaultPageID, form, *form.fields.begin(),
@@ skipping 572 matching lines @@
   FillAutofillFormData(kDefaultPageID, form, form.fields[0],
                        autofill_manager_->PackGUIDs(empty, guid));
 
   int page_id = 0;
   FormData results;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
   ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
 
   // Simulate form submission. We should call into the PDM to try to save the
   // filled data.
-  EXPECT_CALL(*test_personal_data_, SaveImportedProfile(::testing::_)).Times(1);
+  EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
   FormSubmitted(results);
 }
 
 // Test that we are able to save form data when forms are submitted and we only
 // have server data for the field types.
 TEST_F(AutofillManagerTest, FormSubmittedServerTypes) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
 
@@ skipping 17 matching lines @@
   FillAutofillFormData(kDefaultPageID, form, form.fields[0],
                        autofill_manager_->PackGUIDs(empty, guid));
 
   int page_id = 0;
   FormData results;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
   ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
 
   // Simulate form submission. We should call into the PDM to try to save the
   // filled data.
-  EXPECT_CALL(*test_personal_data_, SaveImportedProfile(::testing::_)).Times(1);
+  EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
   FormSubmitted(results);
 }
 
 // Test that the form signature for an uploaded form always matches the form
 // signature from the query.
 TEST_F(AutofillManagerTest, FormSubmittedWithDifferentFields) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
@@ skipping 37 matching lines @@
   GUIDPair empty(std::string(), 0);
   FillAutofillFormData(kDefaultPageID, form, form.fields[3],
                        autofill_manager_->PackGUIDs(empty, guid));
 
   int page_id = 0;
   FormData results;
   EXPECT_TRUE(GetAutofillFormDataFilledMessage(&page_id, &results));
 
   // Simulate form submission.  We should call into the PDM to try to save the
   // filled data.
-  EXPECT_CALL(*test_personal_data_, SaveImportedProfile(::testing::_)).Times(1);
+  EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
   FormSubmitted(results);
 
   // Set the address field's value back to the default value.
   results.fields[3].value = ASCIIToUTF16("Enter your address");
 
   // Simulate form submission.  We should not call into the PDM to try to save
   // the filled data, since the filled form is effectively missing an address.
-  EXPECT_CALL(*test_personal_data_, SaveImportedProfile(::testing::_)).Times(0);
+  EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(0);
   FormSubmitted(results);
 }
 
 // Checks that resetting the auxiliary profile enabled preference does the right
 // thing on all platforms.
 TEST_F(AutofillManagerTest, AuxiliaryProfilesReset) {
 #if defined(OS_MACOSX)
   // Auxiliary profiles is implemented on Mac only.  It enables Mac Address
   // Book integration.
   ASSERT_TRUE(profile()->GetPrefs()->GetBoolean(
@@ skipping 302 matching lines @@
     EXPECT_EQ(expected_types[i].size(), possible_types.size());
     for (FieldTypeSet::const_iterator it = expected_types[i].begin();
          it != expected_types[i].end(); ++it) {
       EXPECT_TRUE(possible_types.count(*it))
           << "Expected type: " << AutofillType::FieldTypeToString(*it);
     }
   }
 }
 
 TEST_F(AutofillManagerTest, DeterminePossibleFieldTypesForUploadStressTest) {
-  test_personal_data_->ClearAutofillProfiles();
+  personal_data_.ClearAutofillProfiles();
   const int kNumProfiles = 5;
   for (int i = 0; i < kNumProfiles; ++i) {
     AutofillProfile* profile = new AutofillProfile;
     autofill_test::SetProfileInfo(profile,
                                   StringPrintf("John%d", i).c_str(),
                                   "",
                                   StringPrintf("Doe%d", i).c_str(),
                                   StringPrintf("JohnDoe%d@somesite.com",
                                                i).c_str(),
                                   "",
                                   StringPrintf("%d 1st st.", i).c_str(),
                                   "",
                                   "Memphis", "Tennessee", "38116", "USA",
                                   StringPrintf("650234%04d", i).c_str());
     profile->set_guid(
         StringPrintf("00000000-0000-0000-0001-00000000%04d", i).c_str());
-    test_personal_data_->AddProfile(profile);
+    personal_data_.AddProfile(profile);
   }
   FormData form;
   CreateTestAddressFormData(&form);
   ASSERT_LT(3U, form.fields.size());
   form.fields[0].value = ASCIIToUTF16("6502340001");
   form.fields[1].value = ASCIIToUTF16("John1");
   form.fields[2].value = ASCIIToUTF16("12345");
   FormStructure form_structure(form);
   autofill_manager_->DeterminePossibleFieldTypesForUpload(&form_structure);
   ASSERT_LT(3U, form_structure.field_count());
   const FieldTypeSet& possible_types0 =
       form_structure.field(0)->possible_types();
   EXPECT_EQ(2U, possible_types0.size());
   EXPECT_TRUE(possible_types0.find(PHONE_HOME_WHOLE_NUMBER) !=
               possible_types0.end());
   EXPECT_TRUE(possible_types0.find(PHONE_HOME_CITY_AND_NUMBER) !=
               possible_types0.end());
   const FieldTypeSet& possible_types1 =
       form_structure.field(1)->possible_types();
   EXPECT_EQ(1U, possible_types1.size());
   EXPECT_TRUE(possible_types1.find(NAME_FIRST) != possible_types1.end());
   const FieldTypeSet& possible_types2 =
       form_structure.field(2)->possible_types();
   EXPECT_EQ(1U, possible_types2.size());
   EXPECT_TRUE(possible_types2.find(UNKNOWN_TYPE) !=
               possible_types2.end());
 }