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) {
     CreateTestAutoFillProfiles(&web_profiles_);
-    CreateTestCreditCards(&credit_cards_);
+    CreateTestCreditCards(&credit_cards_, four_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 41 matching lines @@
                                   "");
     profile->set_guid("00000000-0000-0000-0000-000000000002");
     profiles->push_back(profile);
     profile = new AutoFillProfile;
     autofill_test::SetProfileInfo(profile, "Empty", "", "", "", "", "", "", "",
                                   "", "", "", "", "", "");
     profile->set_guid("00000000-0000-0000-0000-000000000003");
     profiles->push_back(profile);
   }
 
-  void CreateTestCreditCards(ScopedVector<CreditCard>* credit_cards) {
-    CreditCard* credit_card = new CreditCard;
-    autofill_test::SetCreditCardInfo(credit_card, "First", "Elvis Presley",
-                                     "4234567890123456", // Visa
-                                     "04", "2012");
-    credit_card->set_guid("00000000-0000-0000-0000-000000000004");
-    credit_cards->push_back(credit_card);
-    credit_card = new CreditCard;
-    autofill_test::SetCreditCardInfo(credit_card, "Second", "Buddy Holly",
-                                     "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 CreateTestCreditCards(ScopedVector<CreditCard>* credit_cards,
+                             bool four_credit_cards) {
+    if (!four_credit_cards) {
+      CreditCard* credit_card = new CreditCard;
+      autofill_test::SetCreditCardInfo(credit_card, "First", "Elvis Presley",
+          "4234567890123456", // Visa

[dhollowa, 2011/01/07 20:43:39]

nit: indentation should be at open paren.  And below.

+          "04", "2012");
+      credit_card->set_guid("00000000-0000-0000-0000-000000000004");
+      credit_cards->push_back(credit_card);
+      credit_card = new CreditCard;
+      autofill_test::SetCreditCardInfo(credit_card, "Second", "Buddy Holly",
+          "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);
+    } else {
+      // Create four credit cards with year month combination as following,
+      // 1. year empty, month empty
+      CreditCard* credit_card = new CreditCard;
+      autofill_test::SetCreditCardInfo(credit_card, "Miku0",
+          "Miku Hatsune",
+          "4234567890654321", // Visa
+          "", "");
+      credit_card->set_guid("00000000-0000-0000-0000-000000000007");
+      credit_cards->push_back(credit_card);
+      // 2. year empty, month non-empty
+      credit_card = new CreditCard;
+      autofill_test::SetCreditCardInfo(credit_card, "Miku1",
+          "Miku Hatsune",
+          "4234567890654321", // Visa
+          "04", "");
+      credit_card->set_guid("00000000-0000-0000-0000-000000000008");
+      credit_cards->push_back(credit_card);
+      // 3. year non-empty, month empty
+      credit_card = new CreditCard;
+      autofill_test::SetCreditCardInfo(credit_card, "Miku2",
+          "Miku Hatsune",
+          "4234567890654321", // Visa
+          "", "2012");
+      credit_card->set_guid("00000000-0000-0000-0000-000000000009");
+      credit_cards->push_back(credit_card);
+      // 4. both non-empty
+      credit_card = new CreditCard;
+      autofill_test::SetCreditCardInfo(credit_card, "Miku3",
+          "Miku Hatsune",
+          "4234567890654321", // Visa
+          "04", "2012");
+      credit_card->set_guid("00000000-0000-0000-0000-000000000010");
+      credit_cards->push_back(credit_card);
+    }
   }
 
   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");
@@ skipping 32 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) {
   // 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;
+      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 ExpectFilledCreditCardYearMonthWithYearMonth(int page_id,
+                                              const FormData& filled_form,
+                                              int expected_page_id,
+                                              bool has_address_fields,
+                                              const char* year,
+                                              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(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.
+// 1. year empty, month empty
+TEST_F(AutoFillManagerTest, FillCreditCardFormNoYearNoMonth) {
+  // 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("Miku0")->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));
+  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.
+  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("Miku1")->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));
+  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.
+  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("Miku2")->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));
+  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.
+  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("Miku3")->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));
+  ExpectFilledCreditCardYearMonthWithYearMonth(page_id, results,
+      kDefaultPageID, false, "2012", "04");
+}
+
 // 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
 }