Make PersonalDataManager use GetCreditCards() (rather than using credit_cards_ directly) so Autofill

components/autofill/browser/personal_data_manager_unittest.cc

 // Copyright (c) 2012 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/guid.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 233 matching lines @@
 
   // Add two test credit cards to the database.
   personal_data_->AddCreditCard(credit_card0);
   personal_data_->AddCreditCard(credit_card1);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
-  const std::vector<CreditCard*>& results1 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards();
   ASSERT_EQ(2U, results1.size());
   EXPECT_EQ(0, credit_card0.Compare(*results1[0]));
   EXPECT_EQ(0, credit_card1.Compare(*results1[1]));
 
   // Update, remove, and add.
   credit_card0.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Joe"));
   personal_data_->UpdateCreditCard(credit_card0);
   personal_data_->RemoveByGUID(credit_card1.guid());
   personal_data_->AddCreditCard(credit_card2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  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();
 
   // Verify that we've loaded the credit cards from the web database.
-  const std::vector<CreditCard*>& results3 = personal_data_->credit_cards();
+  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.
   AutofillProfile profile;
   profile.set_origin("https://www.example.com/");
   test::SetProfileInfo(&profile,
@@ skipping 12 matching lines @@
   personal_data_->AddProfile(profile);
   personal_data_->AddCreditCard(credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   const std::vector<AutofillProfile*>& profiles1 =
       personal_data_->GetProfiles();
-  const std::vector<CreditCard*>& cards1 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& cards1 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, profiles1.size());
   ASSERT_EQ(1U, cards1.size());
   EXPECT_EQ(0, profile.Compare(*profiles1[0]));
   EXPECT_EQ(0, credit_card.Compare(*cards1[0]));
 
   // Try to update with just the origin changed.
   AutofillProfile original_profile(profile);
   CreditCard original_credit_card(credit_card);
   profile.set_origin("Chrome settings");
   credit_card.set_origin("Chrome settings");
 
   EXPECT_TRUE(profile.IsVerified());
   EXPECT_TRUE(credit_card.IsVerified());
 
   personal_data_->UpdateProfile(profile);
   personal_data_->UpdateCreditCard(credit_card);
 
   // Note: No refresh, as no update is expected.
 
   const std::vector<AutofillProfile*>& profiles2 =
       personal_data_->GetProfiles();
-  const std::vector<CreditCard*>& cards2 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& cards2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, profiles2.size());
   ASSERT_EQ(1U, cards2.size());
   EXPECT_NE(profile.origin(), profiles2[0]->origin());
   EXPECT_NE(credit_card.origin(), cards2[0]->origin());
   // TODO(isherman): Verify that the origins match once they are saved and read
   // from the database.  http://crbug.com/170401
   // EXPECT_EQ(original_profile.origin(), profiles2[0]->origin());
   // EXPECT_EQ(original_credit_card.origin(), cards2[0]->origin());
 
   // Try to update with data changed as well.
   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
   credit_card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Joe"));
 
   personal_data_->UpdateProfile(profile);
   personal_data_->UpdateCreditCard(credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   const std::vector<AutofillProfile*>& profiles3 =
       personal_data_->GetProfiles();
-  const std::vector<CreditCard*>& cards3 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& cards3 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, profiles3.size());
   ASSERT_EQ(1U, cards3.size());
   EXPECT_EQ(0, profile.Compare(*profiles3[0]));
   EXPECT_EQ(0, credit_card.Compare(*cards3[0]));
   // TODO(isherman): Verify that the origins match once they are saved and read
   // from the database.  http://crbug.com/170401
   // EXPECT_EQ(profile.origin(), profiles3[0]->origin());
   // EXPECT_EQ(credit_card.origin(), cards3[0]->origin());
 }
 
@@ skipping 34 matching lines @@
 
   // Add two test credit cards to the database.
   personal_data_->AddCreditCard(credit_card0);
   personal_data_->AddCreditCard(credit_card1);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(2U, results2.size());
   EXPECT_EQ(credit_card0, *results2[0]);
   EXPECT_EQ(credit_card1, *results2[1]);
 
   // Determine uniqueness by inserting all of the GUIDs into a set and verifying
   // the size of the set matches the number of GUIDs.
   std::set<std::string> guids;
   guids.insert(profile0.guid());
   guids.insert(profile1.guid());
   guids.insert(credit_card0.guid());
@@ skipping 68 matching lines @@
   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();
 
   // Verify that we've loaded the credit cards from the web database.
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(0U, results2.size());
 }
 
 TEST_F(PersonalDataManagerTest, Refresh) {
   AutofillProfile profile0;
   test::SetProfileInfo(&profile0,
       "Marion", "Mitchell", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910");
 
@@ skipping 224 matching lines @@
   form.fields.push_back(field);
   FormStructure form_structure(form, std::string());
   form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
   const CreditCard* imported_credit_card;
   EXPECT_FALSE(personal_data_->ImportFormData(form_structure,
                                               &imported_credit_card));
   ASSERT_FALSE(imported_credit_card);
 
   const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
   ASSERT_EQ(0U, profiles.size());
-  const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards();
-  ASSERT_EQ(0U, credit_cards.size());
+  const std::vector<CreditCard*>& cards = personal_data_->GetCreditCards();
+  ASSERT_EQ(0U, cards.size());
 }
 
 TEST_F(PersonalDataManagerTest, ImportFormMinimumAddressUSA) {
   // United States addresses must specifiy one address line, a city, state and
   // zip code.
   FormData form;
   FormFieldData field;
   test::CreateTestFormField("Name:", "name", "Barack Obama", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField(
@@ skipping 136 matching lines @@
   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();
 
-  const std::vector<CreditCard*>& results = personal_data_->credit_cards();
+  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());
 }
 
 TEST_F(PersonalDataManagerTest, AggregateTwoDifferentProfiles) {
@@ skipping 463 matching lines @@
   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();
 
   const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
   ASSERT_EQ(0U, profiles.size());
-  const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards();
-  ASSERT_EQ(0U, credit_cards.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_|.
   AutofillProfile* auxiliary_profile = new AutofillProfile;
   test::SetProfileInfo(auxiliary_profile,
       "Tester", "Frederick", "McAddressBookTesterson",
       "tester@example.com", "Acme Inc.", "1 Main", "Apt A", "San Francisco",
       "CA", "94102", "US", "1.415.888.9999");
@@ skipping 68 matching lines @@
   delete imported_credit_card;
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   CreditCard expected;
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2011");
-  const std::vector<CreditCard*>& results = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card.
   FormData form2;
   test::CreateTestFormField(
       "Name on card:", "name_on_card", "", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField(
       "Card Number:", "card_number", "5500 0000 0000 0004", "text", &field);
@@ skipping 11 matching lines @@
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
   delete imported_credit_card;
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   CreditCard expected2;
   test::SetCreditCardInfo(&expected2,"", "5500000000000004", "02", "2012");
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(2U, results2.size());
   EXPECT_EQ(0, expected.Compare(*results2[0]));
   EXPECT_EQ(0, expected2.Compare(*results2[1]));
 }
 
 TEST_F(PersonalDataManagerTest, AggregateInvalidCreditCard) {
   FormData form1;
 
   // Start with a single valid credit card form.
   FormFieldData field;
@@ skipping 18 matching lines @@
   delete imported_credit_card;
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   CreditCard expected;
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2011");
-  const std::vector<CreditCard*>& results = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different invalid credit card.
   FormData form2;
   test::CreateTestFormField(
       "Name on card:", "name_on_card", "Jim Johansen", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField(
       "Card Number:", "card_number", "1000000000000000", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField("Exp Month:", "exp_month", "02", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field);
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2, std::string());
   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();
 
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  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.
   FormFieldData field;
   test::CreateTestFormField(
@@ skipping 17 matching lines @@
   delete imported_credit_card;
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   CreditCard expected;
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2011");
-  const std::vector<CreditCard*>& results = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card where the year is different but
   // the credit card number matches.
   FormData form2;
   test::CreateTestFormField(
       "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField(
@@ skipping 13 matching lines @@
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   // Expect that the newer information is saved.  In this case the year is
   // updated to "2012".
   CreditCard expected2;
   test::SetCreditCardInfo(&expected2,
       "Biggie Smalls", "4111111111111111", "01", "2012");
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, AggregateEmptyCreditCardWithConflict) {
   FormData form1;
 
   // Start with a single valid credit card form.
   FormFieldData field;
   test::CreateTestFormField(
@@ skipping 17 matching lines @@
   delete imported_credit_card;
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   CreditCard expected;
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2011");
-  const std::vector<CreditCard*>& results = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second credit card with no number.
   FormData form2;
   test::CreateTestFormField(
       "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field);
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2, std::string());
   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();
 
   // No change is expected.
   CreditCard expected2;
   test::SetCreditCardInfo(&expected2,
       "Biggie Smalls", "4111111111111111", "01", "2011");
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInNew) {
   FormData form1;
 
   // Start with a single valid credit card form.
   FormFieldData field;
   test::CreateTestFormField(
@@ skipping 17 matching lines @@
   delete imported_credit_card;
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   CreditCard expected;
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2011");
-  const std::vector<CreditCard*>& results = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card where the name is missing but
   // the credit card number matches.
   FormData form2;
   // Note missing name.
   test::CreateTestFormField(
       "Card Number:", "card_number", "4111111111111111", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field);
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2, std::string());
   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();
 
   // No change is expected.
   CreditCard expected2;
   test::SetCreditCardInfo(&expected2,
       "Biggie Smalls", "4111111111111111", "01", "2011");
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  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, std::string());
   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();
 
   // No change is expected.
   CreditCard expected3;
   test::SetCreditCardInfo(&expected3,
       "Biggie Smalls", "4111111111111111", "01", "2011");
-  const std::vector<CreditCard*>& results3 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results3 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results3.size());
   EXPECT_EQ(0, expected3.Compare(*results3[0]));
 }
 
 TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInOld) {
   // Start with a single valid credit card stored via the preferences.
   // Note the empty name.
   CreditCard saved_credit_card;
   test::SetCreditCardInfo(&saved_credit_card,
       "", "4111111111111111" /* Visa */, "01", "2011");
   personal_data_->AddCreditCard(saved_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
-  const std::vector<CreditCard*>& results1 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results1.size());
   EXPECT_EQ(saved_credit_card, *results1[0]);
 
 
   // Add a second different valid credit card where the year is different but
   // the credit card number matches.
   FormData form;
   FormFieldData field;
   test::CreateTestFormField(
       "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
@@ skipping 16 matching lines @@
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   // Expect that the newer information is saved.  In this case the year is
   // added to the existing credit card.
   CreditCard expected2;
   test::SetCreditCardInfo(&expected2,
       "Biggie Smalls", "4111111111111111", "01", "2012");
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
 // We allow the user to store a credit card number with separators via the UI.
 // We should not try to re-aggregate the same card with the separators stripped.
 TEST_F(PersonalDataManagerTest, AggregateSameCreditCardWithSeparators) {
   // Start with a single valid credit card stored via the preferences.
   // Note the separators in the credit card number.
   CreditCard saved_credit_card;
   test::SetCreditCardInfo(&saved_credit_card,
       "Biggie Smalls", "4111 1111 1111 1111" /* Visa */, "01", "2011");
   personal_data_->AddCreditCard(saved_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataChanged()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
-  const std::vector<CreditCard*>& results1 = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results1.size());
   EXPECT_EQ(0, saved_credit_card.Compare(*results1[0]));
 
   // Import the same card info, but with different separators in the number.
   FormData form;
   FormFieldData field;
   test::CreateTestFormField(
       "Name on card:", "name_on_card", "Biggie Smalls", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField(
       "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field);
   form.fields.push_back(field);
 
   FormStructure form_structure(form, std::string());
   form_structure.DetermineHeuristicTypes(TestAutofillMetrics());
   const 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();
 
   // Expect that no new card is saved.
-  const std::vector<CreditCard*>& results2 = personal_data_->credit_cards();
+  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.
 // TODO(isherman): Enable this test once origins are saved and read from the
 // database.  http://crbug.com/170401
 TEST_F(PersonalDataManagerTest,
        DISABLED_AggregateExistingVerifiedProfileWithConflict) {
@@ skipping 94 matching lines @@
   const 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();
 
   // Expect that the saved credit card is not modified.
-  const std::vector<CreditCard*>& results = personal_data_->credit_cards();
+  const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, credit_card.Compare(*results[0]));
 }
 
 TEST_F(PersonalDataManagerTest, GetNonEmptyTypes) {
   // Check that there are no available types with no profiles stored.
   FieldTypeSet non_empty_types;
   personal_data_->GetNonEmptyTypes(&non_empty_types);
   EXPECT_EQ(0U, non_empty_types.size());
 
@@ skipping 200 matching lines @@
   expected.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values);
   values.push_back(ASCIIToUTF16("(214) 555-1234"));
   expected.SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, values);
 
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, IncognitoReadOnly) {
   ASSERT_TRUE(personal_data_->GetProfiles().empty());
-  ASSERT_TRUE(personal_data_->credit_cards().empty());
+  ASSERT_TRUE(personal_data_->GetCreditCards().empty());
 
   AutofillProfile steve_jobs;
   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;
   test::SetCreditCardInfo(
       &bill_gates, "William H. Gates", "5555555555554444", "1", "2020");
   personal_data_->AddCreditCard(bill_gates);
 
   ResetPersonalDataManager();
   ASSERT_EQ(1U, personal_data_->GetProfiles().size());
-  ASSERT_EQ(1U, personal_data_->credit_cards().size());
+  ASSERT_EQ(1U, personal_data_->GetCreditCards().size());
 
   // After this point no adds, saves, or updates should take effect.
   MakeProfileIncognito();
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()).Times(0);
 
   // Add profiles or credit card shouldn't work.
   personal_data_->AddProfile(test::GetFullProfile());
 
   CreditCard larry_page;
   test::SetCreditCardInfo(
       &larry_page, "Lawrence Page", "4111111111111111", "10", "2025");
   personal_data_->AddCreditCard(larry_page);
 
   ResetPersonalDataManager();
   EXPECT_EQ(1U, personal_data_->GetProfiles().size());
-  EXPECT_EQ(1U, personal_data_->credit_cards().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();
   EXPECT_EQ(ASCIIToUTF16("Steven"),
             personal_data_->GetProfiles()[0]->GetRawInfo(NAME_FIRST));
   EXPECT_EQ(ASCIIToUTF16("William H. Gates"),
-            personal_data_->credit_cards()[0]->GetRawInfo(CREDIT_CARD_NAME));
+            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();
   EXPECT_EQ(ASCIIToUTF16("Steven"),
             personal_data_->GetProfiles()[0]->GetRawInfo(NAME_FIRST));
   EXPECT_EQ(ASCIIToUTF16("William H. Gates"),
-            personal_data_->credit_cards()[0]->GetRawInfo(CREDIT_CARD_NAME));
+            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();
   EXPECT_EQ(1U, personal_data_->GetProfiles().size());
-  EXPECT_EQ(1U, personal_data_->credit_cards().size());
+  EXPECT_EQ(1U, personal_data_->GetCreditCards().size());
 }
 
 }  // namespace autofill