Support autocompletion for HTMl5 tags:"email", "month" and "tel".

chrome/browser/autofill/autofill_manager_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 <vector>
 
 #include "app/l10n_util.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/scoped_vector.h"
@@ skipping 30 matching lines @@
 const int kDefaultPageID = 137;
 
 typedef Tuple5<int,
                std::vector<string16>,
                std::vector<string16>,
                std::vector<string16>,
                std::vector<int> > AutoFillParam;
 
 class TestPersonalDataManager : public PersonalDataManager {
  public:
-  TestPersonalDataManager() {
+  explicit TestPersonalDataManager(bool four_credit_cards_with_year_month) {

[Ilya Sherman, 2011/01/07 07:28:28]

Rather than adding a boolean here, please add an |AddCreditCard()| method and
use that + the ClearCreditCards() method.

     CreateTestAutoFillProfiles(&web_profiles_);
-    CreateTestCreditCards(&credit_cards_);
+    if (four_credit_cards_with_year_month)
+      CreateTestCreditCardsYearMonth(&credit_cards_);
+    else
+      CreateTestCreditCards(&credit_cards_);
   }
 
   virtual void InitializeIfNeeded() {}
   virtual void SaveImportedFormData() {}
   virtual bool IsDataLoaded() const { return true; }
 
   AutoFillProfile* GetLabeledProfile(const char* label) {
     for (std::vector<AutoFillProfile *>::iterator it = web_profiles_.begin();
          it != web_profiles_.end(); ++it) {
       if (!(*it)->Label().compare(ASCIIToUTF16(label)))
@@ skipping 60 matching lines @@
                                      "5187654321098765", // Mastercard
                                      "10", "2014");
     credit_card->set_guid("00000000-0000-0000-0000-000000000005");
     credit_cards->push_back(credit_card);
     credit_card = new CreditCard;
     autofill_test::SetCreditCardInfo(credit_card, "Empty", "", "", "", "");
     credit_card->set_guid("00000000-0000-0000-0000-000000000006");
     credit_cards->push_back(credit_card);
   }
 
+  void CreateTestCreditCardsYearMonth(ScopedVector<CreditCard>* credit_cards) {
+    // Create four credit cards with year month combination as following,
+    // 1. year empty, month empty
+    // 2. year empty, month non-empty
+    // 3. year non-empty, month empty
+    // 4. both non-empty
+    for (int i = 0; i < 4; i++) {

[dhollowa, 2011/01/07 03:47:15]

I'm a lazy reader.  It'd be easier on me if we unroll this loop and set the
values explicitly.  I like to save the thinking for "real" code.  ;-)

+      const char* year  = i%2 ? "" : "2012";
+      const char* month = i/2 ? "" : "04";
+      std::string name = base::StringPrintf("Miku%d",i);
+      CreditCard* credit_card = new CreditCard;
+      autofill_test::SetCreditCardInfo(credit_card, name.c_str(),
+          "Miku Hatsune",
+          "4234567890654321", // Visa
+          month, year);
+      credit_card->set_guid("00000000-0000-0000-0000-" +
+                            base::StringPrintf("%012d", 7 + i));
+      credit_cards->push_back(credit_card);
+    }
+  }

[honten.org, 2011/01/06 07:04:54]

Make four credit cards for year month combination checking.

+
   DISALLOW_COPY_AND_ASSIGN(TestPersonalDataManager);
 };
 
 // Populates |form| with data corresponding to a simple address form.
 // Note that this actually appends fields to the form data, which can be useful
 // for building up more complex test forms.
 void CreateTestAddressFormData(FormData* form) {
   form->name = ASCIIToUTF16("MyForm");
   form->method = ASCIIToUTF16("POST");
   form->origin = GURL("http://myform.com/form.html");
@@ skipping 30 matching lines @@
   form->fields.push_back(field);
   autofill_test::CreateTestFormField(
       "Phone Number", "phonenumber", "", "text", &field);
   form->fields.push_back(field);
   autofill_test::CreateTestFormField(
       "Fax", "fax", "", "text", &field);
   form->fields.push_back(field);
   autofill_test::CreateTestFormField(
       "Email", "email", "", "text", &field);
   form->fields.push_back(field);
-}
+  autofill_test::CreateTestFormField(
+      "Email", "email2", "", "email", &field);
+  form->fields.push_back(field);
+  autofill_test::CreateTestFormField(
+      "Phone Number", "phonenumber2", "", "tel", &field);
+  form->fields.push_back(field);
+ }
 
 // Populates |form| with data corresponding to a simple credit card form.
 // Note that this actually appends fields to the form data, which can be useful
 // for building up more complex test forms.
-void CreateTestCreditCardFormData(FormData* form, bool is_https) {
+void CreateTestCreditCardFormData(FormData* form,
+                                  bool is_https,
+                                  bool use_month_type) {
   form->name = ASCIIToUTF16("MyForm");
   form->method = ASCIIToUTF16("POST");
   if (is_https) {
     form->origin = GURL("https://myform.com/form.html");
     form->action = GURL("https://myform.com/submit.html");
   } else {
     form->origin = GURL("http://myform.com/form.html");
     form->action = GURL("http://myform.com/submit.html");
   }
   form->user_submitted = true;
 
   FormField field;
   autofill_test::CreateTestFormField(
       "Name on Card", "nameoncard", "", "text", &field);
   form->fields.push_back(field);
   autofill_test::CreateTestFormField(
       "Card Number", "cardnumber", "", "text", &field);
   form->fields.push_back(field);
-  autofill_test::CreateTestFormField(
-      "Expiration Date", "ccmonth", "", "text", &field);
-  form->fields.push_back(field);
-  autofill_test::CreateTestFormField(
-      "", "ccyear", "", "text", &field);
-  form->fields.push_back(field);
+  if (use_month_type) {
+    autofill_test::CreateTestFormField(
+        "Expiration Date", "ccmonth", "", "month", &field);
+    form->fields.push_back(field);
+  } else {
+    autofill_test::CreateTestFormField(
+        "Expiration Date", "ccmonth", "", "text", &field);
+    form->fields.push_back(field);
+    autofill_test::CreateTestFormField(
+        "", "ccyear", "", "text", &field);
+    form->fields.push_back(field);
+  }
 }
 
 void ExpectSuggestions(int page_id,
                        const std::vector<string16>& values,
                        const std::vector<string16>& labels,
                        const std::vector<string16>& icons,
                        const std::vector<int>& unique_ids,
                        int expected_page_id,
                        size_t expected_num_suggestions,
                        const string16 expected_values[],
@@ skipping 10 matching lines @@
     EXPECT_EQ(expected_values[i], values[i]);
     EXPECT_EQ(expected_labels[i], labels[i]);
     EXPECT_EQ(expected_icons[i], icons[i]);
     EXPECT_EQ(expected_unique_ids[i], unique_ids[i]);
   }
 }
 
 // Verifies that the |filled_form| has been filled with the given data.
 // Verifies address fields if |has_address_fields| is true, and verifies
 // credit card fields if |has_credit_card_fields| is true. Verifies both if both
-// are true.
+// are true. |use_month_type| is used for credit card input month type.
 void ExpectFilledForm(int page_id,
                       const FormData& filled_form,
                       int expected_page_id,
                       const char* first,
                       const char* middle,
                       const char* last,
                       const char* address1,
                       const char* address2,
                       const char* city,
                       const char* state,
                       const char* postal_code,
                       const char* country,
                       const char* phone,
                       const char* fax,
                       const char* email,
                       const char* name_on_card,
                       const char* card_number,
                       const char* expiration_month,
                       const char* expiration_year,
                       bool has_address_fields,
-                      bool has_credit_card_fields) {
+                      bool has_credit_card_fields,
+                      int use_month_type) {

[Ilya Sherman, 2011/01/07 07:28:28]

nit: bool rather than int

   // The number of fields in the address and credit card forms created above.
-  const size_t kAddressFormSize = 12;
-  const size_t kCreditCardFormSize = 4;
+  const size_t kAddressFormSize = 14;
+  const size_t kCreditCardFormSize = use_month_type ? 3 : 4;
 
   EXPECT_EQ(expected_page_id, page_id);
   EXPECT_EQ(ASCIIToUTF16("MyForm"), filled_form.name);
   EXPECT_EQ(ASCIIToUTF16("POST"), filled_form.method);
   if (has_credit_card_fields) {
     EXPECT_EQ(GURL("https://myform.com/form.html"), filled_form.origin);
     EXPECT_EQ(GURL("https://myform.com/submit.html"), filled_form.action);
   } else {
     EXPECT_EQ(GURL("http://myform.com/form.html"), filled_form.origin);
     EXPECT_EQ(GURL("http://myform.com/submit.html"), filled_form.action);
@@ skipping 38 matching lines @@
     EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[8]));
     autofill_test::CreateTestFormField(
         "Phone Number", "phonenumber", phone, "text", &field);
     EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[9]));
     autofill_test::CreateTestFormField(
         "Fax", "fax", fax, "text", &field);
     EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[10]));
     autofill_test::CreateTestFormField(
          "Email", "email", email, "text", &field);
     EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[11]));
-  }
+    autofill_test::CreateTestFormField(
+         "Email", "email2", email, "email", &field);
+    EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[12]));
+    autofill_test::CreateTestFormField(
+        "Phone Number", "phonenumber2", phone, "tel", &field);
+    EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[13]));
+   }
 
   if (has_credit_card_fields) {
     size_t offset = has_address_fields? kAddressFormSize : 0;
     autofill_test::CreateTestFormField(
         "Name on Card", "nameoncard", name_on_card, "text", &field);
     EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[offset + 0]));
     autofill_test::CreateTestFormField(
         "Card Number", "cardnumber", card_number, "text", &field);
     EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[offset + 1]));
-    autofill_test::CreateTestFormField(
-        "Expiration Date", "ccmonth", expiration_month, "text", &field);
-    EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[offset + 2]));
-    autofill_test::CreateTestFormField(
-        "", "ccyear", expiration_year, "text", &field);
-    EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[offset + 3]));
+    if (use_month_type) {
+      std::string exp_year = expiration_year;
+      std::string exp_month = expiration_month;
+      std::string year_month;

[Ilya Sherman, 2011/01/07 07:28:28]

nit: "date" might be a better name

+      if (!exp_year.empty() && !exp_month.empty())
+        year_month = exp_year + "-" + exp_month;
+      autofill_test::CreateTestFormField("Expiration Date", "ccmonth",
+          year_month.c_str(), "month", &field);
+      EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[offset + 2]));
+    } else {
+      autofill_test::CreateTestFormField(
+          "Expiration Date", "ccmonth", expiration_month, "text", &field);
+      EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[offset + 2]));
+      autofill_test::CreateTestFormField(
+          "", "ccyear", expiration_year, "text", &field);
+      EXPECT_TRUE(field.StrictlyEqualsHack(filled_form.fields[offset + 3]));
+    }
   }
 }
 
 void ExpectFilledAddressFormElvis(int page_id,
                                   const FormData& filled_form,
                                   int expected_page_id,
                                   bool has_credit_card_fields) {
   ExpectFilledForm(page_id, filled_form, expected_page_id, "Elvis", "Aaron",
                    "Presley", "3734 Elvis Presley Blvd.", "Apt. 10", "Memphis",
                    "Tennessee", "38116", "USA", "12345678901", "",
                    "theking@gmail.com", "", "", "", "", true,
-                   has_credit_card_fields);
+                   has_credit_card_fields, false);
 }
 
 void ExpectFilledCreditCardFormElvis(int page_id,
                                      const FormData& filled_form,
                                      int expected_page_id,
                                      bool has_address_fields) {
   ExpectFilledForm(page_id, filled_form, expected_page_id,
                    "", "", "", "", "", "", "", "", "", "", "", "",
                    "Elvis Presley", "4234567890123456", "04", "2012",
-                   has_address_fields, true);
+                   has_address_fields, true, false);
+}
+
+void ExpectFilledCreditCardYearMonthWithIndex(int page_id,
+                                              const FormData& filled_form,
+                                              int expected_page_id,
+                                              bool has_address_fields,
+                                              int i) {
+  const char* year  = i%2 ? "" : "2012";
+  const char* month = i/2 ? "" : "04";
+  ExpectFilledForm(page_id, filled_form, expected_page_id,
+                   "", "", "", "", "", "", "", "", "", "", "", "",
+                   "Miku Hatsune", "4234567890654321", month, year,
+                   has_address_fields, true, true);
 }
 
 class TestAutoFillManager : public AutoFillManager {
  public:
   TestAutoFillManager(TabContents* tab_contents,
                       TestPersonalDataManager* personal_manager)
       : AutoFillManager(tab_contents, personal_manager),
         autofill_enabled_(true) {
     test_personal_data_ = personal_manager;
   }
@@ skipping 51 matching lines @@
   AutoFillManagerTest() {}
   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() {
     RenderViewHostTestHarness::SetUp();
-    test_personal_data_ = new TestPersonalDataManager();
+    test_personal_data_ = new TestPersonalDataManager(false);
     autofill_manager_.reset(new TestAutoFillManager(contents(),
                                                     test_personal_data_.get()));
   }
 
   Profile* profile() { return contents()->profile(); }
 
   bool GetAutoFillSuggestionsMessage(int* page_id,
                                      std::vector<string16>* values,
                                      std::vector<string16>* labels,
                                      std::vector<string16>* icons,
@@ skipping 279 matching lines @@
   // Now clear the test profiles and try again -- we shouldn't return a warning.
   test_personal_data_->ClearAutoFillProfiles();
   EXPECT_FALSE(autofill_manager_->GetAutoFillSuggestions(form, field));
 }
 
 // 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);
+  CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   autofill_manager_->FormsSeen(forms);
 
   FormField field = form.fields[1];
   rvh()->ResetAutoFillState(kDefaultPageID);
   EXPECT_TRUE(autofill_manager_->GetAutoFillSuggestions(form, field));
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   rvh()->AutocompleteSuggestionsReturned(std::vector<string16>());
@@ skipping 23 matching lines @@
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return only matching credit card profile suggestions when the
 // selected form field has been partially filled out.
 TEST_F(AutoFillManagerTest, GetCreditCardSuggestionsMatchCharacter) {
   // Set up our form data.
   FormData form;
-  CreateTestCreditCardFormData(&form, true);
+  CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   autofill_manager_->FormsSeen(forms);
 
   FormField field;
   autofill_test::CreateTestFormField(
       "Card Number", "cardnumber", "4", "text", &field);
   rvh()->ResetAutoFillState(kDefaultPageID);
   EXPECT_TRUE(autofill_manager_->GetAutoFillSuggestions(form, field));
 
   // No suggestions provided, so send an empty vector as the results.
@@ skipping 16 matching lines @@
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return credit card profile suggestions when the selected form
 // field is not the credit card number field.
 TEST_F(AutoFillManagerTest, GetCreditCardSuggestionsNonCCNumber) {
   // Set up our form data.
   FormData form;
-  CreateTestCreditCardFormData(&form, true);
+  CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   autofill_manager_->FormsSeen(forms);
 
   const FormField& field = form.fields[0];
   rvh()->ResetAutoFillState(kDefaultPageID);
   EXPECT_TRUE(autofill_manager_->GetAutoFillSuggestions(form, field));
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   rvh()->AutocompleteSuggestionsReturned(std::vector<string16>());
@@ skipping 23 matching lines @@
   ExpectSuggestions(page_id, values, labels, icons, unique_ids,
                     kDefaultPageID, arraysize(expected_values), expected_values,
                     expected_labels, expected_icons, expected_unique_ids);
 }
 
 // Test that we return a warning explaining that credit card profile suggestions
 // are unavailable when the form is not https.
 TEST_F(AutoFillManagerTest, GetCreditCardSuggestionsNonHTTPS) {
   // Set up our form data.
   FormData form;
-  CreateTestCreditCardFormData(&form, false);
+  CreateTestCreditCardFormData(&form, false, false);
   std::vector<FormData> forms(1, form);
   autofill_manager_->FormsSeen(forms);
 
   const FormField& field = form.fields[0];
   rvh()->ResetAutoFillState(kDefaultPageID);
   EXPECT_TRUE(autofill_manager_->GetAutoFillSuggestions(form, field));
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   rvh()->AutocompleteSuggestionsReturned(std::vector<string16>());
@@ skipping 46 matching lines @@
   // Clear the test credit cards and try again -- we shouldn't return a warning.
   test_personal_data_->ClearCreditCards();
   EXPECT_FALSE(autofill_manager_->GetAutoFillSuggestions(form, field));
 }
 
 // Test that we return profile and credit card suggestions for combined forms.
 TEST_F(AutoFillManagerTest, GetAddressAndCreditCardSuggestions) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
-  CreateTestCreditCardFormData(&form, true);
+  CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   autofill_manager_->FormsSeen(forms);
 
   FormField field = form.fields[0];
   rvh()->ResetAutoFillState(kDefaultPageID);
   EXPECT_TRUE(autofill_manager_->GetAutoFillSuggestions(form, field));
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   rvh()->AutocompleteSuggestionsReturned(std::vector<string16>());
@@ skipping 56 matching lines @@
 }
 
 // Test that for non-https forms with both address and credit card fields, we
 // only return address suggestions. Instead of credit card suggestions, we
 // should return a warning explaining that credit card profile suggestions are
 // unavailable when the form is not https.
 TEST_F(AutoFillManagerTest, GetAddressAndCreditCardSuggestionsNonHttps) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
-  CreateTestCreditCardFormData(&form, false);
+  CreateTestCreditCardFormData(&form, false, false);
   std::vector<FormData> forms(1, form);
   autofill_manager_->FormsSeen(forms);
 
   FormField field = form.fields[0];
   rvh()->ResetAutoFillState(kDefaultPageID);
   EXPECT_TRUE(autofill_manager_->GetAutoFillSuggestions(form, field));
 
   // No suggestions provided, so send an empty vector as the results.
   // This triggers the combined message send.
   rvh()->AutocompleteSuggestionsReturned(std::vector<string16>());
@@ skipping 245 matching lines @@
   int page_id = 0;
   FormData results;
   EXPECT_TRUE(GetAutoFillFormDataFilledMessage(&page_id, &results));
   ExpectFilledAddressFormElvis(page_id, results, kDefaultPageID, false);
 }
 
 // Test that we correctly fill a credit card form.
 TEST_F(AutoFillManagerTest, FillCreditCardForm) {
   // Set up our form data.
   FormData form;
-  CreateTestCreditCardFormData(&form, true);
+  CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   autofill_manager_->FormsSeen(forms);
 
   std::string guid = autofill_manager_->GetLabeledCreditCard("First")->guid();
   EXPECT_TRUE(autofill_manager_->FillAutoFillFormData(
       kDefaultPageID, form, *form.fields.begin(),
       autofill_manager_->PackGUIDs(guid, std::string())));
 
   int page_id = 0;
   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.
+TEST_F(AutoFillManagerTest, FillCreditCardFormWithMonthInput) {
+  for (int i  = 0; i < 4; ++i) {

[dhollowa, 2011/01/07 03:47:15]

Same here.  I'd prefer to unroll the loop with these.

[Ilya Sherman, 2011/01/07 07:28:28]

I think it's reasonable to preserve the loop, but unroll the credit card
creation.  One way to do this is to create an array of the four credit cards and
the corresponding expectations, and loop over that.

[honten.org, 2011/01/07 08:06:17]

I see... I'll change it again.

On 2011/01/07 07:28:28, Ilya Sherman wrote:

[dhollowa, 2011/01/07 18:44:13]

No, don't!  No loops!

On 2011/01/07 08:06:17, honten wrote:

[honten.org, 2011/01/07 18:45:52]

So... which should I choose????

Could you discuss between you guys?

On 2011/01/07 18:44:13, dhollowa wrote:

[honten.org, 2011/01/07 18:48:31]

BTW, if the no-loop is fine, is my latest change Ok, dhollowa?

I separate this loop to four test functions. Is this fine? Please refer to the
latest patch.

Thanks,

On 2011/01/07 18:45:52, honten wrote:

[dhollowa, 2011/01/07 18:54:18]

Yes, I like the latest unrolled version.  Thanks.

On 2011/01/07 18:48:31, honten wrote:

[Ilya Sherman, 2011/01/10 20:08:48]

Unrolled is fine.  I prefer loops to extra boilerplate, but I don't feel
strongly about it. =)

+    // Same as the SetUp(), but generate 4 credit cards with year month
+    // combination.
+    RenderViewHostTestHarness::SetUp();
+    test_personal_data_ = new TestPersonalDataManager(true);
+    autofill_manager_.reset(new TestAutoFillManager(contents(),
+                            test_personal_data_.get()));
+
+    // Set up our form data.
+    FormData form;
+    CreateTestCreditCardFormData(&form, true, true);
+    std::vector<FormData> forms(1, form);
+    autofill_manager_->FormsSeen(forms);
+
+    std::string guid = autofill_manager_->GetLabeledCreditCard(
+        base::StringPrintf("Miku%d", i).c_str())->guid();
+    EXPECT_TRUE(autofill_manager_->FillAutoFillFormData(
+        kDefaultPageID, form, *form.fields.begin(),
+        autofill_manager_->PackGUIDs(guid, std::string())));
+
+    int page_id = 0;
+    FormData results;
+    EXPECT_TRUE(GetAutoFillFormDataFilledMessage(&page_id, &results));
+    ExpectFilledCreditCardYearMonthWithIndex(page_id, results, kDefaultPageID,
+                                             false, i);
+  }
+}
+
 // Test that we correctly fill a combined address and credit card form.
 TEST_F(AutoFillManagerTest, FillAddressAndCreditCardForm) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
-  CreateTestCreditCardFormData(&form, true);
+  CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   autofill_manager_->FormsSeen(forms);
 
   // First fill the address data.
   std::string guid = autofill_manager_->GetLabeledProfile("Home")->guid();
   EXPECT_TRUE(autofill_manager_->FillAutoFillFormData(
       kDefaultPageID, form, form.fields[0],
       autofill_manager_->PackGUIDs(std::string(), guid)));
 
   int page_id = 0;
@@ skipping 20 matching lines @@
   }
 }
 
 // Test that we correctly fill a previously auto-filled form.
 TEST_F(AutoFillManagerTest, FillAutoFilledForm) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   // Mark one of the address fields as autofilled.
   form.fields[4].set_autofilled(true);
-  CreateTestCreditCardFormData(&form, true);
+  CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   autofill_manager_->FormsSeen(forms);
 
   // First fill the address data.
   std::string guid = autofill_manager_->GetLabeledProfile("Home")->guid();
   EXPECT_TRUE(autofill_manager_->FillAutoFillFormData(
       kDefaultPageID, form, *form.fields.begin(),
       autofill_manager_->PackGUIDs(std::string(), guid)));
 
   int page_id = 0;
   FormData results;
   EXPECT_TRUE(GetAutoFillFormDataFilledMessage(&page_id, &results));
   {
     SCOPED_TRACE("Address");
     ExpectFilledForm(page_id, results, kDefaultPageID,
                      "Elvis", "", "", "", "", "", "", "", "", "", "", "",
-                     "", "", "", "", true, true);
+                     "", "", "", "", true, true, false);
   }
 
   // Now fill the credit card data.
   process()->sink().ClearMessages();
   const int kPageID2 = 2;
   guid = autofill_manager_->GetLabeledCreditCard("First")->guid();
   EXPECT_TRUE(autofill_manager_->FillAutoFillFormData(
       kPageID2, form, form.fields.back(),
       autofill_manager_->PackGUIDs(guid, std::string())));
 
@@ skipping 17 matching lines @@
   EXPECT_TRUE(autofill_manager_->FillAutoFillFormData(
       kPageID3, form, *form.fields.rbegin(),
       autofill_manager_->PackGUIDs(guid, std::string())));
 
   page_id = 0;
   EXPECT_TRUE(GetAutoFillFormDataFilledMessage(&page_id, &results));
   {
     SCOPED_TRACE("Credit card 2");
     ExpectFilledForm(page_id, results, kPageID3,
                    "", "", "", "", "", "", "", "", "", "", "", "",
-                   "", "", "", "2012", true, true);
+                   "", "", "", "2012", true, true, false);
   }
 }
 
 // Test that we correctly fill a phone number split across multiple fields.
 TEST_F(AutoFillManagerTest, FillPhoneNumber) {
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("MyPhoneForm");
   form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://myform.com/phone_form.html");
@@ skipping 165 matching lines @@
   ASSERT_FALSE(profile()->GetPrefs()->GetBoolean(
       prefs::kAutoFillAuxiliaryProfilesEnabled));
   profile()->GetPrefs()->SetBoolean(
       prefs::kAutoFillAuxiliaryProfilesEnabled, true);
   profile()->GetPrefs()->ClearPref(prefs::kAutoFillAuxiliaryProfilesEnabled);
   ASSERT_FALSE(profile()->GetPrefs()->GetBoolean(
       prefs::kAutoFillAuxiliaryProfilesEnabled));
 #endif
 }