Componentize several Autofill unit tests.

components/autofill/core/browser/personal_data_manager_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/basictypes.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/guid.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
-#include "chrome/test/base/testing_profile.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/personal_data_manager_observer.h"
 #include "components/autofill/core/browser/webdata/autofill_table.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/webdata/common/web_data_service_base.h"
 #include "components/webdata/common/web_database_service.h"
-#include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 
-using content::BrowserThread;
-
 namespace autofill {
 namespace {
 
 ACTION(QuitUIMessageLoop) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

[blundell, 2014/03/05 15:55:01]

Is it important to preserve this DCHECK in some way here?

[Ilya Sherman, 2014/03/05 23:59:44]

Nah, though it might be worth renaming the action to something like
"QuitMainMessageLoop"

[blundell, 2014/03/06 09:32:32]

Done.

   base::MessageLoop::current()->Quit();
 }
 
 class PersonalDataLoadedObserverMock : public PersonalDataManagerObserver {
  public:
   PersonalDataLoadedObserverMock() {}
   virtual ~PersonalDataLoadedObserverMock() {}
 
   MOCK_METHOD0(OnPersonalDataChanged, void());
 };
 
 // Unlike the base AutofillMetrics, exposes copy and assignment constructors,
 // which are handy for briefer test code.  The AutofillMetrics class is
 // stateless, so this is safe.
 class TestAutofillMetrics : public AutofillMetrics {
  public:
   TestAutofillMetrics() {}
   virtual ~TestAutofillMetrics() {}
 };
 
 }  // anonymous namespace
 
 class PersonalDataManagerTest : public testing::Test {
  protected:
-  PersonalDataManagerTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
-        db_thread_(BrowserThread::DB) {
-  }
+  PersonalDataManagerTest() {}
 
   virtual void SetUp() {
-    db_thread_.Start();
 
+    prefs_ = test::PrefServiceForTesting();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     base::FilePath path = temp_dir_.path().AppendASCII("TestWebDB");
-    web_database_ = new WebDatabaseService(
-        path,
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB));
+    web_database_ = new WebDatabaseService(path,
+                                           base::MessageLoopProxy::current(),
+                                           base::MessageLoopProxy::current());
     web_database_->AddTable(
         scoped_ptr<WebDatabaseTable>(new AutofillTable("en-US")));
     web_database_->LoadDatabase();
-    autofill_database_service_ = new AutofillWebDataService(
-        web_database_,
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB),
-        WebDataServiceBase::ProfileErrorCallback());
+    autofill_database_service_ =
+        new AutofillWebDataService(web_database_,
+                                   base::MessageLoopProxy::current(),
+                                   base::MessageLoopProxy::current(),
+                                   WebDataServiceBase::ProfileErrorCallback());
     autofill_database_service_->Init();
 
-    profile_.reset(new TestingProfile);
-    profile_->CreateWebDataService();
-
-    test::DisableSystemServices(profile_.get());
-    ResetPersonalDataManager();
+    ResetPersonalDataManager(false);
   }
 
   virtual void TearDown() {
     // Destruction order is imposed explicitly here.
     personal_data_.reset(NULL);
-    profile_.reset(NULL);
 
     autofill_database_service_->ShutdownOnUIThread();
     web_database_->ShutdownDatabase();
     autofill_database_service_ = NULL;
     web_database_ = NULL;
-
-    // Schedule another task on the DB thread to notify us that it's safe to

[blundell, 2014/03/05 15:55:01]

Related to the question that I have below, this code seems to indicate that
db_thread_ was using a different MessageLoop before. Is it important to preserve
that?

[Ilya Sherman, 2014/03/05 23:59:44]

No, this is a test pattern that's discouraged these days, so it's great that
you're cleaning it up :)

-    // stop the thread.
-    base::WaitableEvent done(false, false);
-    BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
-        base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done)));
-    done.Wait();
-    base::MessageLoop::current()->PostTask(FROM_HERE,
-                                           base::MessageLoop::QuitClosure());
-    base::MessageLoop::current()->Run();
-    db_thread_.Stop();
   }
 
-  void ResetPersonalDataManager() {
+  void ResetPersonalDataManager(bool is_incognito) {

[Ilya Sherman, 2014/03/05 23:59:44]

nit: Please define an enum for this parameter, rather than passing a boolean. 
An enum makes the semantics of call sites easier to understand.

[blundell, 2014/03/06 09:32:32]

Done.

     personal_data_.reset(new PersonalDataManager("en-US"));
     personal_data_->Init(
         scoped_refptr<AutofillWebDataService>(autofill_database_service_),
-        profile_->GetPrefs(),
-        profile_->IsOffTheRecord());
+        prefs_.get(),
+        is_incognito);
     personal_data_->AddObserver(&personal_data_observer_);
 
     // Verify that the web database has been updated and the notification sent.
     EXPECT_CALL(personal_data_observer_,
                 OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
     base::MessageLoop::current()->Run();
   }
 
-  void MakeProfileIncognito() {
-    // Switch to an incognito profile.
-    profile_->ForceIncognito(true);
-    DCHECK(profile_->IsOffTheRecord());
-  }
-
   base::MessageLoopForUI message_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread db_thread_;

[blundell, 2014/03/05 15:55:01]

I can't remember how TestBrowserThread works off the top of my head -- were
these using the same or different message loops before? If they were different,
is it important to preserve that?

[Ilya Sherman, 2014/03/05 23:59:44]

These were previously different message loops, but it's good that you're
replacing them with just a single loop instead.  It might be appropriate to add
a TestBrowserThreadBundle to this test, though I suppose if things work without
it, then even better :)

[blundell, 2014/03/06 09:32:32]

I can't use TestBrowserThreadBundle here in any case as it's in //content.

On 2014/03/05 23:59:44, Ilya Sherman wrote:

-  scoped_ptr<TestingProfile> profile_;
+  scoped_ptr<PrefService> prefs_;
   scoped_refptr<AutofillWebDataService> autofill_database_service_;
   scoped_refptr<WebDatabaseService> web_database_;
   base::ScopedTempDir temp_dir_;
   scoped_ptr<PersonalDataManager> personal_data_;
   PersonalDataLoadedObserverMock personal_data_observer_;
 };
 
 TEST_F(PersonalDataManagerTest, AddProfile) {
   // Add profile0 to the database.
   AutofillProfile profile0(autofill::test::GetFullProfile());
   profile0.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("j@s.com"));
   personal_data_->AddProfile(profile0);
 
   // Reload the database.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // Verify the addition.
   const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results1.size());
   EXPECT_EQ(0, profile0.Compare(*results1[0]));
 
   // Add profile with identical values.  Duplicates should not get saved.
   AutofillProfile profile0a = profile0;
   profile0a.set_guid(base::GenerateGUID());
   personal_data_->AddProfile(profile0a);
 
   // Reload the database.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // Verify the non-addition.
   const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, profile0.Compare(*results2[0]));
 
   // New profile with different email.
   AutofillProfile profile1 = profile0;
   profile1.set_guid(base::GenerateGUID());
   profile1.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("john@smith.com"));
 
   // Add the different profile.  This should save as a separate profile.
   // Note that if this same profile was "merged" it would collapse to one
   // profile with a multi-valued entry for email.
   personal_data_->AddProfile(profile1);
 
   // Reload the database.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // Verify the addition.
   const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles();
   ASSERT_EQ(2U, results3.size());
   EXPECT_EQ(0, profile0.Compare(*results3[0]));
   EXPECT_EQ(0, profile1.Compare(*results3[1]));
 }
 
 TEST_F(PersonalDataManagerTest, AddUpdateRemoveProfiles) {
   AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
@@ skipping 40 matching lines @@
   base::MessageLoop::current()->Run();
 
   const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
   ASSERT_EQ(2U, results2.size());
   EXPECT_EQ(0, profile0.Compare(*results2[0]));
   EXPECT_EQ(0, profile2.Compare(*results2[1]));
 
   // Reset the PersonalDataManager.  This tests that the personal data was saved
   // to the web database, and that we can load the profiles from the web
   // database.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // Verify that we've loaded the profiles from the web database.
   const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles();
   ASSERT_EQ(2U, results3.size());
   EXPECT_EQ(0, profile0.Compare(*results3[0]));
   EXPECT_EQ(0, profile2.Compare(*results3[1]));
 }
 
 TEST_F(PersonalDataManagerTest, AddUpdateRemoveCreditCards) {
   CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com");
@@ skipping 34 matching lines @@
   base::MessageLoop::current()->Run();
 
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(2U, results2.size());
   EXPECT_EQ(credit_card0, *results2[0]);
   EXPECT_EQ(credit_card2, *results2[1]);
 
   // Reset the PersonalDataManager.  This tests that the personal data was saved
   // to the web database, and that we can load the credit cards from the web
   // database.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // Verify that we've loaded the credit cards from the web database.
   const std::vector<CreditCard*>& results3 = personal_data_->GetCreditCards();
   ASSERT_EQ(2U, results3.size());
   EXPECT_EQ(credit_card0, *results3[0]);
   EXPECT_EQ(credit_card2, *results3[1]);
 }
 
 TEST_F(PersonalDataManagerTest, UpdateUnverifiedProfilesAndCreditCards) {
   // Start with unverified data.
@@ skipping 177 matching lines @@
       "", "", "", "", "", "", "", "", "", "", "", "");
 
   // Add the empty profile to the database.
   personal_data_->AddProfile(profile0);
 
   // Note: no refresh here.
 
   // Reset the PersonalDataManager.  This tests that the personal data was saved
   // to the web database, and that we can load the profiles from the web
   // database.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // Verify that we've loaded the profiles from the web database.
   const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles();
   ASSERT_EQ(0U, results2.size());
 }
 
 TEST_F(PersonalDataManagerTest, SetEmptyCreditCard) {
   CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&credit_card0, "", "", "", "");
 
   // Add the empty credit card to the database.
   personal_data_->AddCreditCard(credit_card0);
 
   // Note: no refresh here.
 
   // Reset the PersonalDataManager.  This tests that the personal data was saved
   // to the web database, and that we can load the credit cards from the web
   // database.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // Verify that we've loaded the credit cards from the web database.
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(0U, results2.size());
 }
 
 TEST_F(PersonalDataManagerTest, Refresh) {
   AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
   test::SetProfileInfo(&profile0,
       "Marion", "Mitchell", "Morrison",
@@ skipping 417 matching lines @@
   personal_data_->AddCreditCard(credit_card0);
   personal_data_->AddCreditCard(credit_card1);
   personal_data_->AddCreditCard(credit_card2);
   personal_data_->AddCreditCard(credit_card3);
   personal_data_->AddCreditCard(credit_card4);
   personal_data_->AddCreditCard(credit_card5);
 
   // Reset the PersonalDataManager.  This tests that the personal data was saved
   // to the web database, and that we can load the credit cards from the web
   // database.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(6U, results.size());
   EXPECT_EQ(credit_card0.guid(), results[0]->guid());
   EXPECT_EQ(credit_card1.guid(), results[1]->guid());
   EXPECT_EQ(credit_card2.guid(), results[2]->guid());
   EXPECT_EQ(credit_card3.guid(), results[3]->guid());
   EXPECT_EQ(credit_card4.guid(), results[4]->guid());
   EXPECT_EQ(credit_card5.guid(), results[5]->guid());
 }
@@ skipping 461 matching lines @@
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes(TestAutofillMetrics());
   scoped_ptr<CreditCard> imported_credit_card;
   EXPECT_FALSE(personal_data_->ImportFormData(form_structure1,
                                               &imported_credit_card));
   ASSERT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
   ASSERT_EQ(0U, profiles.size());
   const std::vector<CreditCard*>& cards = personal_data_->GetCreditCards();
   ASSERT_EQ(0U, cards.size());
 }
 
 TEST_F(PersonalDataManagerTest, AggregateExistingAuxiliaryProfile) {
   // Simulate having access to an auxiliary profile.
   // |auxiliary_profile| will be owned by |personal_data_|.
@@ skipping 167 matching lines @@
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
   EXPECT_FALSE(personal_data_->ImportFormData(form_structure2,
                                               &imported_credit_card));
   ASSERT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, AggregateSameCreditCardWithConflict) {
   FormData form1;
 
   // Start with a single valid credit card form.
@@ skipping 111 matching lines @@
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
   EXPECT_FALSE(personal_data_->ImportFormData(form_structure2,
                                               &imported_credit_card));
   EXPECT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // No change is expected.
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2,
       "Biggie Smalls", "4111111111111111", "01", "2011");
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
@@ skipping 46 matching lines @@
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes(TestAutofillMetrics());
   EXPECT_TRUE(personal_data_->ImportFormData(form_structure2,
                                              &imported_credit_card));
   EXPECT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // No change is expected.
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2,
       "Biggie Smalls", "4111111111111111", "01", "2011");
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 
   // Add a third credit card where the expiration date is missing.
   FormData form3;
   test::CreateTestFormField(
       "Name on card:", "name_on_card", "Johnny McEnroe", "text", &field);
   form3.fields.push_back(field);
   test::CreateTestFormField(
       "Card Number:", "card_number", "5555555555554444", "text", &field);
   form3.fields.push_back(field);
   // Note missing expiration month and year..
 
   FormStructure form_structure3(form3);
   form_structure3.DetermineHeuristicTypes(TestAutofillMetrics());
   EXPECT_FALSE(personal_data_->ImportFormData(form_structure3,
                                               &imported_credit_card));
   ASSERT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // No change is expected.
   CreditCard expected3(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected3,
       "Biggie Smalls", "4111111111111111", "01", "2011");
   const std::vector<CreditCard*>& results3 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results3.size());
   EXPECT_EQ(0, expected3.Compare(*results3[0]));
 }
 
@@ skipping 87 matching lines @@
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
   scoped_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
                                              &imported_credit_card));
   EXPECT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // Expect that no new card is saved.
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, saved_credit_card.Compare(*results2[0]));
 }
 
 // Ensure that if a verified profile already exists, aggregated profiles cannot
 // modify it in any way.
 TEST_F(PersonalDataManagerTest, AggregateExistingVerifiedProfileWithConflict) {
@@ skipping 87 matching lines @@
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
   scoped_ptr<CreditCard> imported_credit_card;
   EXPECT_TRUE(personal_data_->ImportFormData(form_structure,
                                              &imported_credit_card));
   ASSERT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
 
   // Expect that the saved credit card is not modified.
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, credit_card.Compare(*results[0]));
 }
 
 // Ensure that verified profiles can be saved via SaveImportedProfile,
 // overwriting existing unverified profiles.
 TEST_F(PersonalDataManagerTest, SaveImportedProfileWithVerifiedData) {
@@ skipping 338 matching lines @@
   test::SetProfileInfo(&steve_jobs, "Steven", "Paul", "Jobs", "sjobs@apple.com",
       "Apple Computer, Inc.", "1 Infinite Loop", "", "Cupertino", "CA", "95014",
       "US", "(800) 275-2273");
   personal_data_->AddProfile(steve_jobs);
 
   CreditCard bill_gates(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(
       &bill_gates, "William H. Gates", "5555555555554444", "1", "2020");
   personal_data_->AddCreditCard(bill_gates);
 
-  MakeProfileIncognito();
-
   // The personal data manager should be able to read existing profiles in an
   // off-the-record context.
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(true);
   ASSERT_EQ(1U, personal_data_->GetProfiles().size());
   ASSERT_EQ(1U, personal_data_->GetCreditCards().size());
 
   // No adds, saves, or updates should take effect.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()).Times(0);
 
   // Add profiles or credit card shouldn't work.
   personal_data_->AddProfile(test::GetFullProfile());
 
   CreditCard larry_page(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(
       &larry_page, "Lawrence Page", "4111111111111111", "10", "2025");
   personal_data_->AddCreditCard(larry_page);
 
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(true);
   EXPECT_EQ(1U, personal_data_->GetProfiles().size());
   EXPECT_EQ(1U, personal_data_->GetCreditCards().size());
 
   // Saving or creating profiles from imported profiles shouldn't work.
   steve_jobs.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Steve"));
   personal_data_->SaveImportedProfile(steve_jobs);
 
   bill_gates.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Bill Gates"));
   personal_data_->SaveImportedCreditCard(bill_gates);
 
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(true);
   EXPECT_EQ(ASCIIToUTF16("Steven"),
             personal_data_->GetProfiles()[0]->GetRawInfo(NAME_FIRST));
   EXPECT_EQ(ASCIIToUTF16("William H. Gates"),
             personal_data_->GetCreditCards()[0]->GetRawInfo(CREDIT_CARD_NAME));
 
   // Updating existing profiles shouldn't work.
   steve_jobs.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Steve"));
   personal_data_->UpdateProfile(steve_jobs);
 
   bill_gates.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Bill Gates"));
   personal_data_->UpdateCreditCard(bill_gates);
 
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(true);
   EXPECT_EQ(ASCIIToUTF16("Steven"),
             personal_data_->GetProfiles()[0]->GetRawInfo(NAME_FIRST));
   EXPECT_EQ(ASCIIToUTF16("William H. Gates"),
             personal_data_->GetCreditCards()[0]->GetRawInfo(CREDIT_CARD_NAME));
 
   // Removing shouldn't work.
   personal_data_->RemoveByGUID(steve_jobs.guid());
   personal_data_->RemoveByGUID(bill_gates.guid());
 
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(true);
   EXPECT_EQ(1U, personal_data_->GetProfiles().size());
   EXPECT_EQ(1U, personal_data_->GetCreditCards().size());
 }
 
 TEST_F(PersonalDataManagerTest, DefaultCountryCodeIsCached) {
   // The return value should always be some country code, no matter what.
   std::string default_country =
       personal_data_->GetDefaultCountryCodeForNewAddress();
   EXPECT_EQ(2U, default_country.size());
 
   AutofillProfile moose(base::GenerateGUID(), "Chrome settings");
   test::SetProfileInfo(&moose, "Moose", "P", "McMahon", "mpm@example.com",
       "", "1 Taiga TKTR", "", "Calgary", "AB", "T2B 2K2",
       "CA", "(800) 555-9000");
   personal_data_->AddProfile(moose);
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   base::MessageLoop::current()->Run();
   // The value is cached and doesn't change even after adding an address.
   EXPECT_EQ(default_country,
             personal_data_->GetDefaultCountryCodeForNewAddress());
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()).Times(2);
 
   // Disabling Autofill blows away this cache and shouldn't account for Autofill
   // profiles.
-  profile_->GetPrefs()->SetBoolean(prefs::kAutofillEnabled, false);
+  prefs_->SetBoolean(prefs::kAutofillEnabled, false);
   EXPECT_EQ(default_country,
             personal_data_->GetDefaultCountryCodeForNewAddress());
 
   // Enabling Autofill blows away the cached value and should reflect the new
   // value (accounting for profiles).
-  profile_->GetPrefs()->SetBoolean(prefs::kAutofillEnabled, true);
+  prefs_->SetBoolean(prefs::kAutofillEnabled, true);
   EXPECT_EQ(base::UTF16ToUTF8(moose.GetRawInfo(ADDRESS_HOME_COUNTRY)),
             personal_data_->GetDefaultCountryCodeForNewAddress());
 }
 
 TEST_F(PersonalDataManagerTest, DefaultCountryCodeComesFromProfiles) {
   AutofillProfile moose(base::GenerateGUID(), "Chrome settings");
   test::SetProfileInfo(&moose, "Moose", "P", "McMahon", "mpm@example.com",
       "", "1 Taiga TKTR", "", "Calgary", "AB", "T2B 2K2",
       "CA", "(800) 555-9000");
   personal_data_->AddProfile(moose);
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
   EXPECT_EQ("CA", personal_data_->GetDefaultCountryCodeForNewAddress());
 
   // Multiple profiles cast votes.
   AutofillProfile armadillo(base::GenerateGUID(), "Chrome settings");
   test::SetProfileInfo(&armadillo, "Armin", "Dill", "Oh", "ado@example.com",
       "", "1 Speed Bump", "", "Lubbock", "TX", "77500",
       "MX", "(800) 555-9000");
   AutofillProfile armadillo2(base::GenerateGUID(), "Chrome settings");
   test::SetProfileInfo(&armadillo2, "Armin", "Dill", "Oh", "ado@example.com",
       "", "2 Speed Bump", "", "Lubbock", "TX", "77500",
       "MX", "(800) 555-9000");
   personal_data_->AddProfile(armadillo);
   personal_data_->AddProfile(armadillo2);
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
   EXPECT_EQ("MX", personal_data_->GetDefaultCountryCodeForNewAddress());
 
   personal_data_->RemoveByGUID(armadillo.guid());
   personal_data_->RemoveByGUID(armadillo2.guid());
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
   // Verified profiles count more.
   armadillo.set_origin("http://randomwebsite.com");
   armadillo2.set_origin("http://randomwebsite.com");
   personal_data_->AddProfile(armadillo);
   personal_data_->AddProfile(armadillo2);
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
   EXPECT_EQ("CA", personal_data_->GetDefaultCountryCodeForNewAddress());
 
   personal_data_->RemoveByGUID(armadillo.guid());
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
   // But unverified profiles can be a tie breaker.
   armadillo.set_origin("Chrome settings");
   personal_data_->AddProfile(armadillo);
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
   EXPECT_EQ("MX", personal_data_->GetDefaultCountryCodeForNewAddress());
 
   // Invalid country codes are ignored.
   personal_data_->RemoveByGUID(armadillo.guid());
   personal_data_->RemoveByGUID(moose.guid());
   AutofillProfile space_invader(base::GenerateGUID(), "Chrome settings");
   test::SetProfileInfo(&space_invader, "Marty", "", "Martian",
       "mm@example.com", "", "1 Flying Object", "", "Valles Marineris", "",
       "", "XX", "");
   personal_data_->AddProfile(moose);
-  ResetPersonalDataManager();
+  ResetPersonalDataManager(false);
   EXPECT_EQ("MX", personal_data_->GetDefaultCountryCodeForNewAddress());
 }
 
 }  // namespace autofill