Home | History | Annotate | Download | only in browser 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <algorithm>
      6 #include <vector>
      7 
      8 #include "base/command_line.h"
      9 #include "base/format_macros.h"
     10 #include "base/memory/ref_counted.h"
     11 #include "base/memory/scoped_ptr.h"
     12 #include "base/memory/scoped_vector.h"
     13 #include "base/message_loop/message_loop.h"
     14 #include "base/prefs/pref_service.h"
     15 #include "base/run_loop.h"
     16 #include "base/strings/string16.h"
     17 #include "base/strings/string_number_conversions.h"
     18 #include "base/strings/stringprintf.h"
     19 #include "base/strings/utf_string_conversions.h"
     20 #include "base/time/time.h"
     21 #include "base/tuple.h"
     22 #include "components/autofill/core/browser/autocomplete_history_manager.h"
     23 #include "components/autofill/core/browser/autofill_manager.h"
     24 #include "components/autofill/core/browser/autofill_metrics.h"
     25 #include "components/autofill/core/browser/autofill_profile.h"
     26 #include "components/autofill/core/browser/autofill_test_utils.h"
     27 #include "components/autofill/core/browser/credit_card.h"
     28 #include "components/autofill/core/browser/personal_data_manager.h"
     29 #include "components/autofill/core/browser/popup_item_ids.h"
     30 #include "components/autofill/core/browser/test_autofill_client.h"
     31 #include "components/autofill/core/browser/test_autofill_driver.h"
     32 #include "components/autofill/core/browser/test_autofill_external_delegate.h"
     33 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
     34 #include "components/autofill/core/common/autofill_pref_names.h"
     35 #include "components/autofill/core/common/form_data.h"
     36 #include "components/autofill/core/common/form_field_data.h"
     37 #include "grit/components_strings.h"
     38 #include "testing/gmock/include/gmock/gmock.h"
     39 #include "testing/gtest/include/gtest/gtest.h"
     40 #include "ui/base/l10n/l10n_util.h"
     41 #include "ui/gfx/rect.h"
     42 #include "url/gurl.h"
     43 
     44 using base::ASCIIToUTF16;
     45 using base::UTF8ToUTF16;
     46 using testing::_;
     47 
     48 namespace autofill {
     49 
     50 typedef PersonalDataManager::GUIDPair GUIDPair;
     51 
     52 namespace {
     53 
     54 const int kDefaultPageID = 137;
     55 
     56 class TestPersonalDataManager : public PersonalDataManager {
     57  public:
     58   TestPersonalDataManager() : PersonalDataManager("en-US") {
     59     CreateTestAutofillProfiles(&web_profiles_);
     60     CreateTestCreditCards(&credit_cards_);
     61   }
     62 
     63   using PersonalDataManager::set_database;
     64   using PersonalDataManager::SetPrefService;
     65 
     66   MOCK_METHOD1(SaveImportedProfile, std::string(const AutofillProfile&));
     67 
     68   AutofillProfile* GetProfileWithGUID(const char* guid) {
     69     for (std::vector<AutofillProfile *>::iterator it = web_profiles_.begin();
     70          it != web_profiles_.end(); ++it) {
     71       if (!(*it)->guid().compare(guid))
     72         return *it;
     73     }
     74     return NULL;
     75   }
     76 
     77   CreditCard* GetCreditCardWithGUID(const char* guid) {
     78     for (std::vector<CreditCard *>::iterator it = credit_cards_.begin();
     79          it != credit_cards_.end(); ++it){
     80       if (!(*it)->guid().compare(guid))
     81         return *it;
     82     }
     83     return NULL;
     84   }
     85 
     86   void AddProfile(AutofillProfile* profile) {
     87     web_profiles_.push_back(profile);
     88   }
     89 
     90   void AddCreditCard(CreditCard* credit_card) {
     91     credit_cards_.push_back(credit_card);
     92   }
     93 
     94   virtual void RemoveByGUID(const std::string& guid) OVERRIDE {
     95     CreditCard* credit_card = GetCreditCardWithGUID(guid.c_str());
     96     if (credit_card) {
     97       credit_cards_.erase(
     98           std::find(credit_cards_.begin(), credit_cards_.end(), credit_card));
     99     }
    100 
    101     AutofillProfile* profile = GetProfileWithGUID(guid.c_str());
    102     if (profile) {
    103       web_profiles_.erase(
    104           std::find(web_profiles_.begin(), web_profiles_.end(), profile));
    105     }
    106   }
    107 
    108   // Do nothing (auxiliary profiles will be created in
    109   // CreateTestAuxiliaryProfile).
    110   virtual void LoadAuxiliaryProfiles(bool record_metrics) const OVERRIDE {}
    111 
    112   void ClearAutofillProfiles() {
    113     web_profiles_.clear();
    114   }
    115 
    116   void ClearCreditCards() {
    117     credit_cards_.clear();
    118   }
    119 
    120   void CreateTestAuxiliaryProfiles() {
    121     CreateTestAutofillProfiles(&auxiliary_profiles_);
    122   }
    123 
    124   void CreateTestCreditCardsYearAndMonth(const char* year, const char* month) {
    125     ClearCreditCards();
    126     CreditCard* credit_card = new CreditCard;
    127     test::SetCreditCardInfo(credit_card, "Miku Hatsune",
    128                             "4234567890654321", // Visa
    129                             month, year);
    130     credit_card->set_guid("00000000-0000-0000-0000-000000000007");
    131     credit_cards_.push_back(credit_card);
    132   }
    133 
    134  private:
    135   void CreateTestAutofillProfiles(ScopedVector<AutofillProfile>* profiles) {
    136     AutofillProfile* profile = new AutofillProfile;
    137     test::SetProfileInfo(profile, "Elvis", "Aaron",
    138                          "Presley", "theking (at) gmail.com", "RCA",
    139                          "3734 Elvis Presley Blvd.", "Apt. 10",
    140                          "Memphis", "Tennessee", "38116", "US",
    141                          "12345678901");
    142     profile->set_guid("00000000-0000-0000-0000-000000000001");
    143     profiles->push_back(profile);
    144     profile = new AutofillProfile;
    145     test::SetProfileInfo(profile, "Charles", "Hardin",
    146                          "Holley", "buddy (at) gmail.com", "Decca",
    147                          "123 Apple St.", "unit 6", "Lubbock",
    148                          "Texas", "79401", "US", "23456789012");
    149     profile->set_guid("00000000-0000-0000-0000-000000000002");
    150     profiles->push_back(profile);
    151     profile = new AutofillProfile;
    152     test::SetProfileInfo(
    153         profile, "", "", "", "", "", "", "", "", "", "", "", "");
    154     profile->set_guid("00000000-0000-0000-0000-000000000003");
    155     profiles->push_back(profile);
    156   }
    157 
    158   void CreateTestCreditCards(ScopedVector<CreditCard>* credit_cards) {
    159     CreditCard* credit_card = new CreditCard;
    160     test::SetCreditCardInfo(credit_card, "Elvis Presley",
    161                             "4234 5678 9012 3456",  // Visa
    162                             "04", "2012");
    163     credit_card->set_guid("00000000-0000-0000-0000-000000000004");
    164     credit_cards->push_back(credit_card);
    165 
    166     credit_card = new CreditCard;
    167     test::SetCreditCardInfo(credit_card, "Buddy Holly",
    168                             "5187654321098765",  // Mastercard
    169                             "10", "2014");
    170     credit_card->set_guid("00000000-0000-0000-0000-000000000005");
    171     credit_cards->push_back(credit_card);
    172 
    173     credit_card = new CreditCard;
    174     test::SetCreditCardInfo(credit_card, "", "", "", "");
    175     credit_card->set_guid("00000000-0000-0000-0000-000000000006");
    176     credit_cards->push_back(credit_card);
    177   }
    178 
    179   DISALLOW_COPY_AND_ASSIGN(TestPersonalDataManager);
    180 };
    181 
    182 // Populates |form| with data corresponding to a simple credit card form.
    183 // Note that this actually appends fields to the form data, which can be useful
    184 // for building up more complex test forms.
    185 void CreateTestCreditCardFormData(FormData* form,
    186                                   bool is_https,
    187                                   bool use_month_type) {
    188   form->name = ASCIIToUTF16("MyForm");
    189   if (is_https) {
    190     form->origin = GURL("https://myform.com/form.html");
    191     form->action = GURL("https://myform.com/submit.html");
    192   } else {
    193     form->origin = GURL("http://myform.com/form.html");
    194     form->action = GURL("http://myform.com/submit.html");
    195   }
    196   form->user_submitted = true;
    197 
    198   FormFieldData field;
    199   test::CreateTestFormField("Name on Card", "nameoncard", "", "text", &field);
    200   form->fields.push_back(field);
    201   test::CreateTestFormField("Card Number", "cardnumber", "", "text", &field);
    202   form->fields.push_back(field);
    203   if (use_month_type) {
    204     test::CreateTestFormField(
    205         "Expiration Date", "ccmonth", "", "month", &field);
    206     form->fields.push_back(field);
    207   } else {
    208     test::CreateTestFormField("Expiration Date", "ccmonth", "", "text", &field);
    209     form->fields.push_back(field);
    210     test::CreateTestFormField("", "ccyear", "", "text", &field);
    211     form->fields.push_back(field);
    212   }
    213 }
    214 
    215 void ExpectFilledField(const char* expected_label,
    216                        const char* expected_name,
    217                        const char* expected_value,
    218                        const char* expected_form_control_type,
    219                        const FormFieldData& field) {
    220   SCOPED_TRACE(expected_label);
    221   EXPECT_EQ(UTF8ToUTF16(expected_label), field.label);
    222   EXPECT_EQ(UTF8ToUTF16(expected_name), field.name);
    223   EXPECT_EQ(UTF8ToUTF16(expected_value), field.value);
    224   EXPECT_EQ(expected_form_control_type, field.form_control_type);
    225 }
    226 
    227 // Verifies that the |filled_form| has been filled with the given data.
    228 // Verifies address fields if |has_address_fields| is true, and verifies
    229 // credit card fields if |has_credit_card_fields| is true. Verifies both if both
    230 // are true. |use_month_type| is used for credit card input month type.
    231 void ExpectFilledForm(int page_id,
    232                       const FormData& filled_form,
    233                       int expected_page_id,
    234                       const char* first,
    235                       const char* middle,
    236                       const char* last,
    237                       const char* address1,
    238                       const char* address2,
    239                       const char* city,
    240                       const char* state,
    241                       const char* postal_code,
    242                       const char* country,
    243                       const char* phone,
    244                       const char* email,
    245                       const char* name_on_card,
    246                       const char* card_number,
    247                       const char* expiration_month,
    248                       const char* expiration_year,
    249                       bool has_address_fields,
    250                       bool has_credit_card_fields,
    251                       bool use_month_type) {
    252   // The number of fields in the address and credit card forms created above.
    253   const size_t kAddressFormSize = 11;
    254   const size_t kCreditCardFormSize = use_month_type ? 3 : 4;
    255 
    256   EXPECT_EQ(expected_page_id, page_id);
    257   EXPECT_EQ(ASCIIToUTF16("MyForm"), filled_form.name);
    258   if (has_credit_card_fields) {
    259     EXPECT_EQ(GURL("https://myform.com/form.html"), filled_form.origin);
    260     EXPECT_EQ(GURL("https://myform.com/submit.html"), filled_form.action);
    261   } else {
    262     EXPECT_EQ(GURL("http://myform.com/form.html"), filled_form.origin);
    263     EXPECT_EQ(GURL("http://myform.com/submit.html"), filled_form.action);
    264   }
    265   EXPECT_TRUE(filled_form.user_submitted);
    266 
    267   size_t form_size = 0;
    268   if (has_address_fields)
    269     form_size += kAddressFormSize;
    270   if (has_credit_card_fields)
    271     form_size += kCreditCardFormSize;
    272   ASSERT_EQ(form_size, filled_form.fields.size());
    273 
    274   if (has_address_fields) {
    275     ExpectFilledField("First Name", "firstname", first, "text",
    276                       filled_form.fields[0]);
    277     ExpectFilledField("Middle Name", "middlename", middle, "text",
    278                       filled_form.fields[1]);
    279     ExpectFilledField("Last Name", "lastname", last, "text",
    280                       filled_form.fields[2]);
    281     ExpectFilledField("Address Line 1", "addr1", address1, "text",
    282                       filled_form.fields[3]);
    283     ExpectFilledField("Address Line 2", "addr2", address2, "text",
    284                       filled_form.fields[4]);
    285     ExpectFilledField("City", "city", city, "text",
    286                       filled_form.fields[5]);
    287     ExpectFilledField("State", "state", state, "text",
    288                       filled_form.fields[6]);
    289     ExpectFilledField("Postal Code", "zipcode", postal_code, "text",
    290                       filled_form.fields[7]);
    291     ExpectFilledField("Country", "country", country, "text",
    292                       filled_form.fields[8]);
    293     ExpectFilledField("Phone Number", "phonenumber", phone, "tel",
    294                       filled_form.fields[9]);
    295     ExpectFilledField("Email", "email", email, "email",
    296                       filled_form.fields[10]);
    297   }
    298 
    299   if (has_credit_card_fields) {
    300     size_t offset = has_address_fields? kAddressFormSize : 0;
    301     ExpectFilledField("Name on Card", "nameoncard", name_on_card, "text",
    302                       filled_form.fields[offset + 0]);
    303     ExpectFilledField("Card Number", "cardnumber", card_number, "text",
    304                       filled_form.fields[offset + 1]);
    305     if (use_month_type) {
    306       std::string exp_year = expiration_year;
    307       std::string exp_month = expiration_month;
    308       std::string date;
    309       if (!exp_year.empty() && !exp_month.empty())
    310         date = exp_year + "-" + exp_month;
    311 
    312       ExpectFilledField("Expiration Date", "ccmonth", date.c_str(), "month",
    313                         filled_form.fields[offset + 2]);
    314     } else {
    315       ExpectFilledField("Expiration Date", "ccmonth", expiration_month, "text",
    316                         filled_form.fields[offset + 2]);
    317       ExpectFilledField("", "ccyear", expiration_year, "text",
    318                         filled_form.fields[offset + 3]);
    319     }
    320   }
    321 }
    322 
    323 void ExpectFilledAddressFormElvis(int page_id,
    324                                   const FormData& filled_form,
    325                                   int expected_page_id,
    326                                   bool has_credit_card_fields) {
    327   ExpectFilledForm(page_id, filled_form, expected_page_id, "Elvis", "Aaron",
    328                    "Presley", "3734 Elvis Presley Blvd.", "Apt. 10", "Memphis",
    329                    "Tennessee", "38116", "United States", "12345678901",
    330                    "theking (at) gmail.com", "", "", "", "", true,
    331                    has_credit_card_fields, false);
    332 }
    333 
    334 void ExpectFilledCreditCardFormElvis(int page_id,
    335                                      const FormData& filled_form,
    336                                      int expected_page_id,
    337                                      bool has_address_fields) {
    338   ExpectFilledForm(page_id, filled_form, expected_page_id,
    339                    "", "", "", "", "", "", "", "", "", "", "",
    340                    "Elvis Presley", "4234567890123456", "04", "2012",
    341                    has_address_fields, true, false);
    342 }
    343 
    344 void ExpectFilledCreditCardYearMonthWithYearMonth(int page_id,
    345                                                   const FormData& filled_form,
    346                                                   int expected_page_id,
    347                                                   bool has_address_fields,
    348                                                   const char* year,
    349                                                   const char* month) {
    350   ExpectFilledForm(page_id, filled_form, expected_page_id,
    351                    "", "", "", "", "", "", "", "", "", "", "",
    352                    "Miku Hatsune", "4234567890654321", month, year,
    353                    has_address_fields, true, true);
    354 }
    355 
    356 class MockAutocompleteHistoryManager : public AutocompleteHistoryManager {
    357  public:
    358   MockAutocompleteHistoryManager(AutofillDriver* driver, AutofillClient* client)
    359       : AutocompleteHistoryManager(driver, client) {}
    360 
    361   MOCK_METHOD1(OnFormSubmitted, void(const FormData& form));
    362 
    363  private:
    364   DISALLOW_COPY_AND_ASSIGN(MockAutocompleteHistoryManager);
    365 };
    366 
    367 class MockAutofillDriver : public TestAutofillDriver {
    368  public:
    369   MockAutofillDriver() {}
    370 
    371   // Mock methods to enable testability.
    372   MOCK_METHOD3(SendFormDataToRenderer, void(int query_id,
    373                                             RendererFormDataAction action,
    374                                             const FormData& data));
    375 
    376  private:
    377   DISALLOW_COPY_AND_ASSIGN(MockAutofillDriver);
    378 };
    379 
    380 class TestAutofillManager : public AutofillManager {
    381  public:
    382   TestAutofillManager(AutofillDriver* driver,
    383                       autofill::AutofillClient* client,
    384                       TestPersonalDataManager* personal_data)
    385       : AutofillManager(driver, client, personal_data),
    386         personal_data_(personal_data),
    387         autofill_enabled_(true) {}
    388   virtual ~TestAutofillManager() {}
    389 
    390   virtual bool IsAutofillEnabled() const OVERRIDE { return autofill_enabled_; }
    391 
    392   void set_autofill_enabled(bool autofill_enabled) {
    393     autofill_enabled_ = autofill_enabled;
    394   }
    395 
    396   void set_expected_submitted_field_types(
    397       const std::vector<ServerFieldTypeSet>& expected_types) {
    398     expected_submitted_field_types_ = expected_types;
    399   }
    400 
    401   virtual void UploadFormDataAsyncCallback(
    402       const FormStructure* submitted_form,
    403       const base::TimeTicks& load_time,
    404       const base::TimeTicks& interaction_time,
    405       const base::TimeTicks& submission_time) OVERRIDE {
    406     run_loop_->Quit();
    407 
    408     // If we have expected field types set, make sure they match.
    409     if (!expected_submitted_field_types_.empty()) {
    410       ASSERT_EQ(expected_submitted_field_types_.size(),
    411                 submitted_form->field_count());
    412       for (size_t i = 0; i < expected_submitted_field_types_.size(); ++i) {
    413         SCOPED_TRACE(
    414             base::StringPrintf(
    415                 "Field %d with value %s", static_cast<int>(i),
    416                 base::UTF16ToUTF8(submitted_form->field(i)->value).c_str()));
    417         const ServerFieldTypeSet& possible_types =
    418             submitted_form->field(i)->possible_types();
    419         EXPECT_EQ(expected_submitted_field_types_[i].size(),
    420                   possible_types.size());
    421         for (ServerFieldTypeSet::const_iterator it =
    422                  expected_submitted_field_types_[i].begin();
    423              it != expected_submitted_field_types_[i].end(); ++it) {
    424           EXPECT_TRUE(possible_types.count(*it))
    425               << "Expected type: " << AutofillType(*it).ToString();
    426         }
    427       }
    428     }
    429 
    430     AutofillManager::UploadFormDataAsyncCallback(submitted_form,
    431                                                  load_time,
    432                                                  interaction_time,
    433                                                  submission_time);
    434   }
    435 
    436   // Resets the run loop so that it can wait for an asynchronous form
    437   // submission to complete.
    438   void ResetRunLoop() { run_loop_.reset(new base::RunLoop()); }
    439 
    440   // Wait for the asynchronous OnFormSubmitted() call to complete.
    441   void WaitForAsyncFormSubmit() { run_loop_->Run(); }
    442 
    443   virtual void UploadFormData(const FormStructure& submitted_form) OVERRIDE {
    444     submitted_form_signature_ = submitted_form.FormSignature();
    445   }
    446 
    447   const std::string GetSubmittedFormSignature() {
    448     return submitted_form_signature_;
    449   }
    450 
    451   AutofillProfile* GetProfileWithGUID(const char* guid) {
    452     return personal_data_->GetProfileWithGUID(guid);
    453   }
    454 
    455   CreditCard* GetCreditCardWithGUID(const char* guid) {
    456     return personal_data_->GetCreditCardWithGUID(guid);
    457   }
    458 
    459   void AddProfile(AutofillProfile* profile) {
    460     personal_data_->AddProfile(profile);
    461   }
    462 
    463   void AddCreditCard(CreditCard* credit_card) {
    464     personal_data_->AddCreditCard(credit_card);
    465   }
    466 
    467   int GetPackedCreditCardID(int credit_card_id) {
    468     std::string credit_card_guid =
    469         base::StringPrintf("00000000-0000-0000-0000-%012d", credit_card_id);
    470 
    471     return PackGUIDs(GUIDPair(credit_card_guid, 0), GUIDPair(std::string(), 0));
    472   }
    473 
    474   void AddSeenForm(FormStructure* form) {
    475     form_structures()->push_back(form);
    476   }
    477 
    478   void ClearFormStructures() {
    479     form_structures()->clear();
    480   }
    481 
    482  private:
    483   // Weak reference.
    484   TestPersonalDataManager* personal_data_;
    485 
    486   bool autofill_enabled_;
    487 
    488   scoped_ptr<base::RunLoop> run_loop_;
    489 
    490   std::string submitted_form_signature_;
    491   std::vector<ServerFieldTypeSet> expected_submitted_field_types_;
    492 
    493   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
    494 };
    495 
    496 class TestAutofillExternalDelegate : public AutofillExternalDelegate {
    497  public:
    498   explicit TestAutofillExternalDelegate(AutofillManager* autofill_manager,
    499                                         AutofillDriver* autofill_driver)
    500       : AutofillExternalDelegate(autofill_manager, autofill_driver),
    501         on_query_seen_(false),
    502         on_suggestions_returned_seen_(false) {}
    503   virtual ~TestAutofillExternalDelegate() {}
    504 
    505   virtual void OnQuery(int query_id,
    506                        const FormData& form,
    507                        const FormFieldData& field,
    508                        const gfx::RectF& bounds,
    509                        bool display_warning) OVERRIDE {
    510     on_query_seen_ = true;
    511     on_suggestions_returned_seen_ = false;
    512   }
    513 
    514   virtual void OnSuggestionsReturned(
    515       int query_id,
    516       const std::vector<base::string16>& autofill_values,
    517       const std::vector<base::string16>& autofill_labels,
    518       const std::vector<base::string16>& autofill_icons,
    519       const std::vector<int>& autofill_unique_ids) OVERRIDE {
    520     on_suggestions_returned_seen_ = true;
    521 
    522     query_id_ = query_id;
    523     autofill_values_ = autofill_values;
    524     autofill_labels_ = autofill_labels;
    525     autofill_icons_ = autofill_icons;
    526     autofill_unique_ids_ = autofill_unique_ids;
    527   }
    528 
    529   void CheckSuggestions(int expected_page_id,
    530                         size_t expected_num_suggestions,
    531                         const base::string16 expected_values[],
    532                         const base::string16 expected_labels[],
    533                         const base::string16 expected_icons[],
    534                         const int expected_unique_ids[]) {
    535     // Ensure that these results are from the most recent query.
    536     EXPECT_TRUE(on_suggestions_returned_seen_);
    537 
    538     EXPECT_EQ(expected_page_id, query_id_);
    539     ASSERT_EQ(expected_num_suggestions, autofill_values_.size());
    540     ASSERT_EQ(expected_num_suggestions, autofill_labels_.size());
    541     ASSERT_EQ(expected_num_suggestions, autofill_icons_.size());
    542     ASSERT_EQ(expected_num_suggestions, autofill_unique_ids_.size());
    543     for (size_t i = 0; i < expected_num_suggestions; ++i) {
    544       SCOPED_TRACE(base::StringPrintf("i: %" PRIuS, i));
    545       EXPECT_EQ(expected_values[i], autofill_values_[i]);
    546       EXPECT_EQ(expected_labels[i], autofill_labels_[i]);
    547       EXPECT_EQ(expected_icons[i], autofill_icons_[i]);
    548       EXPECT_EQ(expected_unique_ids[i], autofill_unique_ids_[i]);
    549     }
    550   }
    551 
    552   bool on_query_seen() const {
    553     return on_query_seen_;
    554   }
    555 
    556   bool on_suggestions_returned_seen() const {
    557     return on_suggestions_returned_seen_;
    558   }
    559 
    560  private:
    561   // Records if OnQuery has been called yet.
    562   bool on_query_seen_;
    563 
    564   // Records if OnSuggestionsReturned has been called after the most recent
    565   // call to OnQuery.
    566   bool on_suggestions_returned_seen_;
    567 
    568   // The query id of the most recent Autofill query.
    569   int query_id_;
    570 
    571   // The results returned by the most recent Autofill query.
    572   std::vector<base::string16> autofill_values_;
    573   std::vector<base::string16> autofill_labels_;
    574   std::vector<base::string16> autofill_icons_;
    575   std::vector<int> autofill_unique_ids_;
    576 
    577   DISALLOW_COPY_AND_ASSIGN(TestAutofillExternalDelegate);
    578 };
    579 
    580 }  // namespace
    581 
    582 class AutofillManagerTest : public testing::Test {
    583  public:
    584   virtual void SetUp() OVERRIDE {
    585     autofill_client_.SetPrefs(test::PrefServiceForTesting());
    586     personal_data_.set_database(autofill_client_.GetDatabase());
    587     personal_data_.SetPrefService(autofill_client_.GetPrefs());
    588     autofill_driver_.reset(new MockAutofillDriver());
    589     autofill_manager_.reset(new TestAutofillManager(
    590         autofill_driver_.get(), &autofill_client_, &personal_data_));
    591 
    592     external_delegate_.reset(new TestAutofillExternalDelegate(
    593         autofill_manager_.get(),
    594         autofill_driver_.get()));
    595     autofill_manager_->SetExternalDelegate(external_delegate_.get());
    596   }
    597 
    598   virtual void TearDown() OVERRIDE {
    599     // Order of destruction is important as AutofillManager relies on
    600     // PersonalDataManager to be around when it gets destroyed.
    601     autofill_manager_.reset();
    602     autofill_driver_.reset();
    603 
    604     // Remove the AutofillWebDataService so TestPersonalDataManager does not
    605     // need to care about removing self as an observer in destruction.
    606     personal_data_.set_database(scoped_refptr<AutofillWebDataService>(NULL));
    607     personal_data_.SetPrefService(NULL);
    608   }
    609 
    610   void GetAutofillSuggestions(int query_id,
    611                               const FormData& form,
    612                               const FormFieldData& field) {
    613     autofill_manager_->OnQueryFormFieldAutofill(query_id,
    614                                                 form,
    615                                                 field,
    616                                                 gfx::Rect(),
    617                                                 false);
    618   }
    619 
    620   void GetAutofillSuggestions(const FormData& form,
    621                               const FormFieldData& field) {
    622     GetAutofillSuggestions(kDefaultPageID, form, field);
    623   }
    624 
    625   void AutocompleteSuggestionsReturned(
    626       const std::vector<base::string16>& result) {
    627     autofill_manager_->autocomplete_history_manager_->SendSuggestions(&result);
    628   }
    629 
    630   void FormsSeen(const std::vector<FormData>& forms) {
    631     autofill_manager_->OnFormsSeen(forms, base::TimeTicks());
    632   }
    633 
    634   void FormSubmitted(const FormData& form) {
    635     autofill_manager_->ResetRunLoop();
    636     if (autofill_manager_->OnFormSubmitted(form, base::TimeTicks::Now()))
    637       autofill_manager_->WaitForAsyncFormSubmit();
    638   }
    639 
    640   void FillAutofillFormData(int query_id,
    641                             const FormData& form,
    642                             const FormFieldData& field,
    643                             int unique_id) {
    644     autofill_manager_->FillOrPreviewForm(
    645         AutofillDriver::FORM_DATA_ACTION_FILL, query_id, form, field,
    646         unique_id);
    647   }
    648 
    649   // Calls |autofill_manager_->OnFillAutofillFormData()| with the specified
    650   // input parameters after setting up the expectation that the mock driver's
    651   // |SendFormDataToRenderer()| method will be called and saving the parameters
    652   // of that call into the |response_query_id| and |response_data| output
    653   // parameters.
    654   void FillAutofillFormDataAndSaveResults(int input_query_id,
    655                                           const FormData& input_form,
    656                                           const FormFieldData& input_field,
    657                                           int unique_id,
    658                                           int* response_query_id,
    659                                           FormData* response_data) {
    660     EXPECT_CALL(*autofill_driver_, SendFormDataToRenderer(_, _, _)).
    661         WillOnce((DoAll(testing::SaveArg<0>(response_query_id),
    662                         testing::SaveArg<2>(response_data))));
    663     FillAutofillFormData(input_query_id, input_form, input_field, unique_id);
    664   }
    665 
    666   int PackGUIDs(const GUIDPair& cc_guid, const GUIDPair& profile_guid) const {
    667     return autofill_manager_->PackGUIDs(cc_guid, profile_guid);
    668   }
    669 
    670  protected:
    671   base::MessageLoop message_loop_;
    672   TestAutofillClient autofill_client_;
    673   scoped_ptr<MockAutofillDriver> autofill_driver_;
    674   scoped_ptr<TestAutofillManager> autofill_manager_;
    675   scoped_ptr<TestAutofillExternalDelegate> external_delegate_;
    676   TestPersonalDataManager personal_data_;
    677 };
    678 
    679 class TestFormStructure : public FormStructure {
    680  public:
    681   explicit TestFormStructure(const FormData& form)
    682       : FormStructure(form) {}
    683   virtual ~TestFormStructure() {}
    684 
    685   void SetFieldTypes(const std::vector<ServerFieldType>& heuristic_types,
    686                      const std::vector<ServerFieldType>& server_types) {
    687     ASSERT_EQ(field_count(), heuristic_types.size());
    688     ASSERT_EQ(field_count(), server_types.size());
    689 
    690     for (size_t i = 0; i < field_count(); ++i) {
    691       AutofillField* form_field = field(i);
    692       ASSERT_TRUE(form_field);
    693       form_field->set_heuristic_type(heuristic_types[i]);
    694       form_field->set_server_type(server_types[i]);
    695     }
    696 
    697     UpdateAutofillCount();
    698   }
    699 
    700  private:
    701   DISALLOW_COPY_AND_ASSIGN(TestFormStructure);
    702 };
    703 
    704 // Test that we return all address profile suggestions when all form fields are
    705 // empty.
    706 TEST_F(AutofillManagerTest, GetProfileSuggestionsEmptyValue) {
    707   // Set up our form data.
    708   FormData form;
    709   test::CreateTestAddressFormData(&form);
    710   std::vector<FormData> forms(1, form);
    711   FormsSeen(forms);
    712 
    713   const FormFieldData& field = form.fields[0];
    714   GetAutofillSuggestions(form, field);
    715 
    716   // No suggestions provided, so send an empty vector as the results.
    717   // This triggers the combined message send.
    718   AutocompleteSuggestionsReturned(std::vector<base::string16>());
    719 
    720   // Test that we sent the right values to the external delegate.
    721   base::string16 expected_values[] = {
    722     ASCIIToUTF16("Elvis"),
    723     ASCIIToUTF16("Charles")
    724   };
    725   // Inferred labels include full first relevant field, which in this case is
    726   // the address line 1.
    727   base::string16 expected_labels[] = {
    728     ASCIIToUTF16("3734 Elvis Presley Blvd."),
    729     ASCIIToUTF16("123 Apple St.")
    730   };
    731   base::string16 expected_icons[] = {base::string16(), base::string16()};
    732   int expected_unique_ids[] = {1, 2};
    733   external_delegate_->CheckSuggestions(
    734       kDefaultPageID, arraysize(expected_values), expected_values,
    735       expected_labels, expected_icons, expected_unique_ids);
    736 }
    737 
    738 // Test that we return only matching address profile suggestions when the
    739 // selected form field has been partially filled out.
    740 TEST_F(AutofillManagerTest, GetProfileSuggestionsMatchCharacter) {
    741   // Set up our form data.
    742   FormData form;
    743   test::CreateTestAddressFormData(&form);
    744   std::vector<FormData> forms(1, form);
    745   FormsSeen(forms);
    746 
    747   FormFieldData field;
    748   test::CreateTestFormField("First Name", "firstname", "E", "text",&field);
    749   GetAutofillSuggestions(form, field);
    750 
    751   // No suggestions provided, so send an empty vector as the results.
    752   // This triggers the combined message send.
    753   AutocompleteSuggestionsReturned(std::vector<base::string16>());
    754 
    755   // Test that we sent the right values to the external delegate.
    756   base::string16 expected_values[] = {ASCIIToUTF16("Elvis")};
    757   base::string16 expected_labels[] = {ASCIIToUTF16("3734 Elvis Presley Blvd.")};
    758   base::string16 expected_icons[] = {base::string16()};
    759   int expected_unique_ids[] = {1};
    760   external_delegate_->CheckSuggestions(
    761       kDefaultPageID, arraysize(expected_values), expected_values,
    762       expected_labels, expected_icons, expected_unique_ids);
    763 }
    764 
    765 // Test that we return no suggestions when the form has no relevant fields.
    766 TEST_F(AutofillManagerTest, GetProfileSuggestionsUnknownFields) {
    767   // Set up our form data.
    768   FormData form;
    769   form.name = ASCIIToUTF16("MyForm");
    770   form.origin = GURL("http://myform.com/form.html");
    771   form.action = GURL("http://myform.com/submit.html");
    772   form.user_submitted = true;
    773 
    774   FormFieldData field;
    775   test::CreateTestFormField("Username", "username", "", "text",&field);
    776   form.fields.push_back(field);
    777   test::CreateTestFormField("Password", "password", "", "password",&field);
    778   form.fields.push_back(field);
    779   test::CreateTestFormField("Quest", "quest", "", "quest", &field);
    780   form.fields.push_back(field);
    781   test::CreateTestFormField("Color", "color", "", "text", &field);
    782   form.fields.push_back(field);
    783 
    784   std::vector<FormData> forms(1, form);
    785   FormsSeen(forms);
    786 
    787   GetAutofillSuggestions(form, field);
    788   EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
    789 }
    790 
    791 // Test that we cull duplicate profile suggestions.
    792 TEST_F(AutofillManagerTest, GetProfileSuggestionsWithDuplicates) {
    793   // Set up our form data.
    794   FormData form;
    795   test::CreateTestAddressFormData(&form);
    796   std::vector<FormData> forms(1, form);
    797   FormsSeen(forms);
    798 
    799   // Add a duplicate profile.
    800   AutofillProfile* duplicate_profile =
    801       new AutofillProfile(
    802           *(autofill_manager_->GetProfileWithGUID(
    803               "00000000-0000-0000-0000-000000000001")));
    804   autofill_manager_->AddProfile(duplicate_profile);
    805 
    806   const FormFieldData& field = form.fields[0];
    807   GetAutofillSuggestions(form, field);
    808 
    809   // No suggestions provided, so send an empty vector as the results.
    810   // This triggers the combined message send.
    811   AutocompleteSuggestionsReturned(std::vector<base::string16>());
    812 
    813   // Test that we sent the right values to the external delegate.
    814   base::string16 expected_values[] = {
    815     ASCIIToUTF16("Elvis"),
    816     ASCIIToUTF16("Charles")
    817   };
    818   base::string16 expected_labels[] = {
    819     ASCIIToUTF16("3734 Elvis Presley Blvd."),
    820     ASCIIToUTF16("123 Apple St.")
    821   };
    822   base::string16 expected_icons[] = {base::string16(), base::string16()};
    823   int expected_unique_ids[] = {1, 2};
    824   external_delegate_->CheckSuggestions(
    825       kDefaultPageID, arraysize(expected_values), expected_values,
    826       expected_labels, expected_icons, expected_unique_ids);
    827 }
    828 
    829 // Test that we return no suggestions when autofill is disabled.
    830 TEST_F(AutofillManagerTest, GetProfileSuggestionsAutofillDisabledByUser) {
    831   // Set up our form data.
    832   FormData form;
    833   test::CreateTestAddressFormData(&form);
    834   std::vector<FormData> forms(1, form);
    835   FormsSeen(forms);
    836 
    837   // Disable Autofill.
    838   autofill_manager_->set_autofill_enabled(false);
    839 
    840   const FormFieldData& field = form.fields[0];
    841   GetAutofillSuggestions(form, field);
    842   EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
    843 }
    844 
    845 // Test that we return all credit card profile suggestions when all form fields
    846 // are empty.
    847 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsEmptyValue) {
    848   // Set up our form data.
    849   FormData form;
    850   CreateTestCreditCardFormData(&form, true, false);
    851   std::vector<FormData> forms(1, form);
    852   FormsSeen(forms);
    853 
    854   FormFieldData field = form.fields[1];
    855   GetAutofillSuggestions(form, field);
    856 
    857   // No suggestions provided, so send an empty vector as the results.
    858   // This triggers the combined message send.
    859   AutocompleteSuggestionsReturned(std::vector<base::string16>());
    860 
    861   // Test that we sent the right values to the external delegate.
    862   base::string16 expected_values[] = {
    863     ASCIIToUTF16("************3456"),
    864     ASCIIToUTF16("************8765")
    865   };
    866   base::string16 expected_labels[] = { ASCIIToUTF16("04/12"),
    867                                        ASCIIToUTF16("10/14")};
    868   base::string16 expected_icons[] = {
    869     ASCIIToUTF16(kVisaCard),
    870     ASCIIToUTF16(kMasterCard)
    871   };
    872   int expected_unique_ids[] = {
    873     autofill_manager_->GetPackedCreditCardID(4),
    874     autofill_manager_->GetPackedCreditCardID(5)
    875   };
    876   external_delegate_->CheckSuggestions(
    877       kDefaultPageID, arraysize(expected_values), expected_values,
    878       expected_labels, expected_icons, expected_unique_ids);
    879 }
    880 
    881 // Test that we return only matching credit card profile suggestions when the
    882 // selected form field has been partially filled out.
    883 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsMatchCharacter) {
    884   // Set up our form data.
    885   FormData form;
    886   CreateTestCreditCardFormData(&form, true, false);
    887   std::vector<FormData> forms(1, form);
    888   FormsSeen(forms);
    889 
    890   FormFieldData field;
    891   test::CreateTestFormField("Card Number", "cardnumber", "4", "text", &field);
    892   GetAutofillSuggestions(form, field);
    893 
    894   // No suggestions provided, so send an empty vector as the results.
    895   // This triggers the combined message send.
    896   AutocompleteSuggestionsReturned(std::vector<base::string16>());
    897 
    898   // Test that we sent the right values to the external delegate.
    899   base::string16 expected_values[] = {ASCIIToUTF16("************3456")};
    900   base::string16 expected_labels[] = {ASCIIToUTF16("04/12")};
    901   base::string16 expected_icons[] = {ASCIIToUTF16(kVisaCard)};
    902   int expected_unique_ids[] = {autofill_manager_->GetPackedCreditCardID(4)};
    903   external_delegate_->CheckSuggestions(
    904       kDefaultPageID, arraysize(expected_values), expected_values,
    905       expected_labels, expected_icons, expected_unique_ids);
    906 }
    907 
    908 // Test that we return credit card profile suggestions when the selected form
    909 // field is not the credit card number field.
    910 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsNonCCNumber) {
    911   // Set up our form data.
    912   FormData form;
    913   CreateTestCreditCardFormData(&form, true, false);
    914   std::vector<FormData> forms(1, form);
    915   FormsSeen(forms);
    916 
    917   const FormFieldData& field = form.fields[0];
    918   GetAutofillSuggestions(form, field);
    919 
    920   // No suggestions provided, so send an empty vector as the results.
    921   // This triggers the combined message send.
    922   AutocompleteSuggestionsReturned(std::vector<base::string16>());
    923 
    924   // Test that we sent the right values to the external delegate.
    925   base::string16 expected_values[] = {
    926     ASCIIToUTF16("Elvis Presley"),
    927     ASCIIToUTF16("Buddy Holly")
    928   };
    929   base::string16 expected_labels[] = { ASCIIToUTF16("*3456"),
    930                                        ASCIIToUTF16("*8765") };
    931   base::string16 expected_icons[] = {
    932     ASCIIToUTF16(kVisaCard),
    933     ASCIIToUTF16(kMasterCard)
    934   };
    935   int expected_unique_ids[] = {
    936     autofill_manager_->GetPackedCreditCardID(4),
    937     autofill_manager_->GetPackedCreditCardID(5)
    938   };
    939   external_delegate_->CheckSuggestions(
    940       kDefaultPageID, arraysize(expected_values), expected_values,
    941       expected_labels, expected_icons, expected_unique_ids);
    942 }
    943 
    944 // Test that we return a warning explaining that credit card profile suggestions
    945 // are unavailable when the form is not https.
    946 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsNonHTTPS) {
    947   // Set up our form data.
    948   FormData form;
    949   CreateTestCreditCardFormData(&form, false, false);
    950   std::vector<FormData> forms(1, form);
    951   FormsSeen(forms);
    952 
    953   const FormFieldData& field = form.fields[0];
    954   GetAutofillSuggestions(form, field);
    955 
    956   // No suggestions provided, so send an empty vector as the results.
    957   // This triggers the combined message send.
    958   AutocompleteSuggestionsReturned(std::vector<base::string16>());
    959 
    960   // Test that we sent the right values to the external delegate.
    961   base::string16 expected_values[] = {
    962     l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION)
    963   };
    964   base::string16 expected_labels[] = {base::string16()};
    965   base::string16 expected_icons[] = {base::string16()};
    966   int expected_unique_ids[] = {-1};
    967   external_delegate_->CheckSuggestions(
    968       kDefaultPageID, arraysize(expected_values), expected_values,
    969       expected_labels, expected_icons, expected_unique_ids);
    970 
    971   // Now add some Autocomplete suggestions. We should show the autocomplete
    972   // suggestions and the warning.
    973   const int kPageID2 = 2;
    974   GetAutofillSuggestions(kPageID2, form, field);
    975 
    976   std::vector<base::string16> suggestions;
    977   suggestions.push_back(ASCIIToUTF16("Jay"));
    978   suggestions.push_back(ASCIIToUTF16("Jason"));
    979   AutocompleteSuggestionsReturned(suggestions);
    980 
    981   base::string16 expected_values2[] = {
    982     l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
    983     ASCIIToUTF16("Jay"),
    984     ASCIIToUTF16("Jason")
    985   };
    986   base::string16 expected_labels2[] = { base::string16(), base::string16(),
    987                                         base::string16() };
    988   base::string16 expected_icons2[] = { base::string16(), base::string16(),
    989                                        base::string16() };
    990   int expected_unique_ids2[] = {-1, 0, 0};
    991   external_delegate_->CheckSuggestions(
    992       kPageID2, arraysize(expected_values2), expected_values2,
    993       expected_labels2, expected_icons2, expected_unique_ids2);
    994 
    995   // Clear the test credit cards and try again -- we shouldn't return a warning.
    996   personal_data_.ClearCreditCards();
    997   GetAutofillSuggestions(form, field);
    998   EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
    999 }
   1000 
   1001 // Test that we return all credit card suggestions in the case that two cards
   1002 // have the same obfuscated number.
   1003 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsRepeatedObfuscatedNumber) {
   1004   // Add a credit card with the same obfuscated number as Elvis's.
   1005   // |credit_card| will be owned by the mock PersonalDataManager.
   1006   CreditCard* credit_card = new CreditCard;
   1007   test::SetCreditCardInfo(credit_card, "Elvis Presley",
   1008                           "5231567890123456",  // Mastercard
   1009                           "05", "2012");
   1010   credit_card->set_guid("00000000-0000-0000-0000-000000000007");
   1011   autofill_manager_->AddCreditCard(credit_card);
   1012 
   1013   // Set up our form data.
   1014   FormData form;
   1015   CreateTestCreditCardFormData(&form, true, false);
   1016   std::vector<FormData> forms(1, form);
   1017   FormsSeen(forms);
   1018 
   1019   FormFieldData field = form.fields[1];
   1020   GetAutofillSuggestions(form, field);
   1021 
   1022   // No suggestions provided, so send an empty vector as the results.
   1023   // This triggers the combined message send.
   1024   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1025 
   1026   // Test that we sent the right values to the external delegate.
   1027   base::string16 expected_values[] = {
   1028     ASCIIToUTF16("************3456"),
   1029     ASCIIToUTF16("************8765"),
   1030     ASCIIToUTF16("************3456")
   1031   };
   1032   base::string16 expected_labels[] = {
   1033     ASCIIToUTF16("04/12"),
   1034     ASCIIToUTF16("10/14"),
   1035     ASCIIToUTF16("05/12"),
   1036   };
   1037   base::string16 expected_icons[] = {
   1038     ASCIIToUTF16(kVisaCard),
   1039     ASCIIToUTF16(kMasterCard),
   1040     ASCIIToUTF16(kMasterCard)
   1041   };
   1042   int expected_unique_ids[] = {
   1043     autofill_manager_->GetPackedCreditCardID(4),
   1044     autofill_manager_->GetPackedCreditCardID(5),
   1045     autofill_manager_->GetPackedCreditCardID(7)
   1046   };
   1047   external_delegate_->CheckSuggestions(
   1048       kDefaultPageID, arraysize(expected_values), expected_values,
   1049       expected_labels, expected_icons, expected_unique_ids);
   1050 }
   1051 
   1052 // Test that we return profile and credit card suggestions for combined forms.
   1053 TEST_F(AutofillManagerTest, GetAddressAndCreditCardSuggestions) {
   1054   // Set up our form data.
   1055   FormData form;
   1056   test::CreateTestAddressFormData(&form);
   1057   CreateTestCreditCardFormData(&form, true, false);
   1058   std::vector<FormData> forms(1, form);
   1059   FormsSeen(forms);
   1060 
   1061   FormFieldData field = form.fields[0];
   1062   GetAutofillSuggestions(form, field);
   1063 
   1064   // No suggestions provided, so send an empty vector as the results.
   1065   // This triggers the combined message send.
   1066   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1067 
   1068   // Test that we sent the right address suggestions to the external delegate.
   1069   base::string16 expected_values[] = {
   1070     ASCIIToUTF16("Elvis"),
   1071     ASCIIToUTF16("Charles")
   1072   };
   1073   base::string16 expected_labels[] = {
   1074     ASCIIToUTF16("3734 Elvis Presley Blvd."),
   1075     ASCIIToUTF16("123 Apple St.")
   1076   };
   1077   base::string16 expected_icons[] = {base::string16(), base::string16()};
   1078   int expected_unique_ids[] = {1, 2};
   1079   external_delegate_->CheckSuggestions(
   1080       kDefaultPageID, arraysize(expected_values), expected_values,
   1081       expected_labels, expected_icons, expected_unique_ids);
   1082 
   1083   const int kPageID2 = 2;
   1084   test::CreateTestFormField("Card Number", "cardnumber", "", "text", &field);
   1085   GetAutofillSuggestions(kPageID2, form, field);
   1086 
   1087   // No suggestions provided, so send an empty vector as the results.
   1088   // This triggers the combined message send.
   1089   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1090 
   1091   // Test that we sent the credit card suggestions to the external delegate.
   1092   base::string16 expected_values2[] = {
   1093     ASCIIToUTF16("************3456"),
   1094     ASCIIToUTF16("************8765")
   1095   };
   1096   base::string16 expected_labels2[] = { ASCIIToUTF16("04/12"),
   1097                                         ASCIIToUTF16("10/14")};
   1098   base::string16 expected_icons2[] = {
   1099     ASCIIToUTF16(kVisaCard),
   1100     ASCIIToUTF16(kMasterCard)
   1101   };
   1102   int expected_unique_ids2[] = {
   1103     autofill_manager_->GetPackedCreditCardID(4),
   1104     autofill_manager_->GetPackedCreditCardID(5)
   1105   };
   1106   external_delegate_->CheckSuggestions(
   1107       kPageID2, arraysize(expected_values2), expected_values2,
   1108       expected_labels2, expected_icons2, expected_unique_ids2);
   1109 }
   1110 
   1111 // Test that for non-https forms with both address and credit card fields, we
   1112 // only return address suggestions. Instead of credit card suggestions, we
   1113 // should return a warning explaining that credit card profile suggestions are
   1114 // unavailable when the form is not https.
   1115 TEST_F(AutofillManagerTest, GetAddressAndCreditCardSuggestionsNonHttps) {
   1116   // Set up our form data.
   1117   FormData form;
   1118   test::CreateTestAddressFormData(&form);
   1119   CreateTestCreditCardFormData(&form, false, false);
   1120   std::vector<FormData> forms(1, form);
   1121   FormsSeen(forms);
   1122 
   1123   FormFieldData field = form.fields[0];
   1124   GetAutofillSuggestions(form, field);
   1125 
   1126   // No suggestions provided, so send an empty vector as the results.
   1127   // This triggers the combined message send.
   1128   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1129 
   1130   // Test that we sent the right suggestions to the external delegate.
   1131   base::string16 expected_values[] = {
   1132     ASCIIToUTF16("Elvis"),
   1133     ASCIIToUTF16("Charles")
   1134   };
   1135   base::string16 expected_labels[] = {
   1136     ASCIIToUTF16("3734 Elvis Presley Blvd."),
   1137     ASCIIToUTF16("123 Apple St.")
   1138   };
   1139   base::string16 expected_icons[] = {base::string16(), base::string16()};
   1140   int expected_unique_ids[] = {1, 2};
   1141   external_delegate_->CheckSuggestions(
   1142       kDefaultPageID, arraysize(expected_values), expected_values,
   1143       expected_labels, expected_icons, expected_unique_ids);
   1144 
   1145   test::CreateTestFormField("Card Number", "cardnumber", "", "text", &field);
   1146   const int kPageID2 = 2;
   1147   GetAutofillSuggestions(kPageID2, form, field);
   1148 
   1149   // No suggestions provided, so send an empty vector as the results.
   1150   // This triggers the combined message send.
   1151   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1152 
   1153   // Test that we sent the right values to the external delegate.
   1154   base::string16 expected_values2[] = {
   1155     l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION)
   1156   };
   1157   base::string16 expected_labels2[] = {base::string16()};
   1158   base::string16 expected_icons2[] = {base::string16()};
   1159   int expected_unique_ids2[] = {-1};
   1160   external_delegate_->CheckSuggestions(
   1161       kPageID2, arraysize(expected_values2), expected_values2,
   1162       expected_labels2, expected_icons2, expected_unique_ids2);
   1163 
   1164   // Clear the test credit cards and try again -- we shouldn't return a warning.
   1165   personal_data_.ClearCreditCards();
   1166   GetAutofillSuggestions(form, field);
   1167   EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
   1168 }
   1169 
   1170 // Test that we correctly combine autofill and autocomplete suggestions.
   1171 TEST_F(AutofillManagerTest, GetCombinedAutofillAndAutocompleteSuggestions) {
   1172   // Set up our form data.
   1173   FormData form;
   1174   test::CreateTestAddressFormData(&form);
   1175   std::vector<FormData> forms(1, form);
   1176   FormsSeen(forms);
   1177 
   1178   const FormFieldData& field = form.fields[0];
   1179   GetAutofillSuggestions(form, field);
   1180 
   1181   // Add some Autocomplete suggestions.
   1182   // This triggers the combined message send.
   1183   std::vector<base::string16> suggestions;
   1184   suggestions.push_back(ASCIIToUTF16("Jay"));
   1185   // This suggestion is a duplicate, and should be trimmed.
   1186   suggestions.push_back(ASCIIToUTF16("Elvis"));
   1187   suggestions.push_back(ASCIIToUTF16("Jason"));
   1188   AutocompleteSuggestionsReturned(suggestions);
   1189 
   1190   // Test that we sent the right values to the external delegate.
   1191   base::string16 expected_values[] = {
   1192     ASCIIToUTF16("Elvis"),
   1193     ASCIIToUTF16("Charles"),
   1194     ASCIIToUTF16("Jay"),
   1195     ASCIIToUTF16("Jason")
   1196   };
   1197   base::string16 expected_labels[] = {
   1198     ASCIIToUTF16("3734 Elvis Presley Blvd."),
   1199     ASCIIToUTF16("123 Apple St."),
   1200     base::string16(),
   1201     base::string16()
   1202   };
   1203   base::string16 expected_icons[] = { base::string16(), base::string16(),
   1204                                       base::string16(), base::string16()};
   1205   int expected_unique_ids[] = {1, 2, 0, 0};
   1206   external_delegate_->CheckSuggestions(
   1207       kDefaultPageID, arraysize(expected_values), expected_values,
   1208       expected_labels, expected_icons, expected_unique_ids);
   1209 }
   1210 
   1211 // Test that we return autocomplete-like suggestions when trying to autofill
   1212 // already filled forms.
   1213 TEST_F(AutofillManagerTest, GetFieldSuggestionsWhenFormIsAutofilled) {
   1214   // Set up our form data.
   1215   FormData form;
   1216   test::CreateTestAddressFormData(&form);
   1217   std::vector<FormData> forms(1, form);
   1218   FormsSeen(forms);
   1219 
   1220   // Mark one of the fields as filled.
   1221   form.fields[2].is_autofilled = true;
   1222   const FormFieldData& field = form.fields[0];
   1223   GetAutofillSuggestions(form, field);
   1224 
   1225   // No suggestions provided, so send an empty vector as the results.
   1226   // This triggers the combined message send.
   1227   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1228 
   1229   // Test that we sent the right values to the external delegate.
   1230   base::string16 expected_values[] = {
   1231     ASCIIToUTF16("Elvis"),
   1232     ASCIIToUTF16("Charles")
   1233   };
   1234   base::string16 expected_labels[] = {base::string16(), base::string16()};
   1235   base::string16 expected_icons[] = {base::string16(), base::string16()};
   1236   int expected_unique_ids[] = {1, 2};
   1237   external_delegate_->CheckSuggestions(
   1238       kDefaultPageID, arraysize(expected_values), expected_values,
   1239       expected_labels, expected_icons, expected_unique_ids);
   1240 }
   1241 
   1242 // Test that nothing breaks when there are autocomplete suggestions but no
   1243 // autofill suggestions.
   1244 TEST_F(AutofillManagerTest, GetFieldSuggestionsForAutocompleteOnly) {
   1245   // Set up our form data.
   1246   FormData form;
   1247   test::CreateTestAddressFormData(&form);
   1248   FormFieldData field;
   1249   test::CreateTestFormField("Some Field", "somefield", "", "text", &field);
   1250   form.fields.push_back(field);
   1251   std::vector<FormData> forms(1, form);
   1252   FormsSeen(forms);
   1253 
   1254   GetAutofillSuggestions(form, field);
   1255 
   1256   // Add some Autocomplete suggestions.
   1257   // This triggers the combined message send.
   1258   std::vector<base::string16> suggestions;
   1259   suggestions.push_back(ASCIIToUTF16("one"));
   1260   suggestions.push_back(ASCIIToUTF16("two"));
   1261   AutocompleteSuggestionsReturned(suggestions);
   1262 
   1263   // Test that we sent the right values to the external delegate.
   1264   base::string16 expected_values[] = {
   1265     ASCIIToUTF16("one"),
   1266     ASCIIToUTF16("two")
   1267   };
   1268   base::string16 expected_labels[] = {base::string16(), base::string16()};
   1269   base::string16 expected_icons[] = {base::string16(), base::string16()};
   1270   int expected_unique_ids[] = {0, 0};
   1271   external_delegate_->CheckSuggestions(
   1272       kDefaultPageID, arraysize(expected_values), expected_values,
   1273       expected_labels, expected_icons, expected_unique_ids);
   1274 }
   1275 
   1276 // Test that we do not return duplicate values drawn from multiple profiles when
   1277 // filling an already filled field.
   1278 TEST_F(AutofillManagerTest, GetFieldSuggestionsWithDuplicateValues) {
   1279   // Set up our form data.
   1280   FormData form;
   1281   test::CreateTestAddressFormData(&form);
   1282   std::vector<FormData> forms(1, form);
   1283   FormsSeen(forms);
   1284 
   1285   // |profile| will be owned by the mock PersonalDataManager.
   1286   AutofillProfile* profile = new AutofillProfile;
   1287   test::SetProfileInfo(
   1288       profile, "Elvis", "", "", "", "", "", "", "", "", "", "", "");
   1289   profile->set_guid("00000000-0000-0000-0000-000000000101");
   1290   autofill_manager_->AddProfile(profile);
   1291 
   1292   FormFieldData& field = form.fields[0];
   1293   field.is_autofilled = true;
   1294   field.value = ASCIIToUTF16("Elvis");
   1295   GetAutofillSuggestions(form, field);
   1296 
   1297   // No suggestions provided, so send an empty vector as the results.
   1298   // This triggers the combined message send.
   1299   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1300 
   1301   // Test that we sent the right values to the external delegate.
   1302   base::string16 expected_values[] = { ASCIIToUTF16("Elvis") };
   1303   base::string16 expected_labels[] = { base::string16() };
   1304   base::string16 expected_icons[] = { base::string16() };
   1305   int expected_unique_ids[] = { 1 };
   1306   external_delegate_->CheckSuggestions(
   1307       kDefaultPageID, arraysize(expected_values), expected_values,
   1308       expected_labels, expected_icons, expected_unique_ids);
   1309 }
   1310 
   1311 // Test that a non-default value is suggested for multi-valued profile, on an
   1312 // unfilled form.
   1313 TEST_F(AutofillManagerTest, GetFieldSuggestionsForMultiValuedProfileUnfilled) {
   1314   // Set up our form data.
   1315   FormData form;
   1316   test::CreateTestAddressFormData(&form);
   1317   std::vector<FormData> forms(1, form);
   1318   FormsSeen(forms);
   1319 
   1320   // |profile| will be owned by the mock PersonalDataManager.
   1321   AutofillProfile* profile = new AutofillProfile;
   1322   test::SetProfileInfo(profile, "Elvis", "", "Presley", "me (at) x.com", "",
   1323                        "", "", "", "", "", "", "");
   1324   profile->set_guid("00000000-0000-0000-0000-000000000101");
   1325   std::vector<base::string16> multi_values(2);
   1326   multi_values[0] = ASCIIToUTF16("Elvis");
   1327   multi_values[1] = ASCIIToUTF16("Elena");
   1328   profile->SetRawMultiInfo(NAME_FIRST, multi_values);
   1329   multi_values[0] = ASCIIToUTF16("Presley");
   1330   multi_values[1] = ASCIIToUTF16("Love");
   1331   profile->SetRawMultiInfo(NAME_LAST, multi_values);
   1332   personal_data_.ClearAutofillProfiles();
   1333   autofill_manager_->AddProfile(profile);
   1334 
   1335   {
   1336     // Get the first name field.
   1337     // Start out with "E", hoping for either "Elvis" or "Elena.
   1338     FormFieldData& field = form.fields[0];
   1339     field.value = ASCIIToUTF16("E");
   1340     field.is_autofilled = false;
   1341     GetAutofillSuggestions(form, field);
   1342 
   1343     // Trigger the |Send|.
   1344     AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1345 
   1346     // Test that we sent the right values to the external delegate.
   1347     base::string16 expected_values[] = {
   1348       ASCIIToUTF16("Elvis"),
   1349       ASCIIToUTF16("Elena")
   1350     };
   1351     base::string16 expected_labels[] = {
   1352       ASCIIToUTF16("me (at) x.com"),
   1353       ASCIIToUTF16("me (at) x.com")
   1354     };
   1355     base::string16 expected_icons[] = { base::string16(), base::string16() };
   1356     int expected_unique_ids[] = { 1, 2 };
   1357     external_delegate_->CheckSuggestions(
   1358         kDefaultPageID, arraysize(expected_values), expected_values,
   1359         expected_labels, expected_icons, expected_unique_ids);
   1360   }
   1361 
   1362   {
   1363     // Get the first name field.
   1364     // This time, start out with "Ele", hoping for "Elena".
   1365     FormFieldData& field = form.fields[0];
   1366     field.value = ASCIIToUTF16("Ele");
   1367     field.is_autofilled = false;
   1368     GetAutofillSuggestions(form, field);
   1369 
   1370     // Trigger the |Send|.
   1371     AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1372 
   1373     // Test that we sent the right values to the external delegate.
   1374     base::string16 expected_values[] = { ASCIIToUTF16("Elena") };
   1375     base::string16 expected_labels[] = { ASCIIToUTF16("me (at) x.com") };
   1376     base::string16 expected_icons[] = { base::string16() };
   1377     int expected_unique_ids[] = { 2 };
   1378     external_delegate_->CheckSuggestions(
   1379         kDefaultPageID, arraysize(expected_values), expected_values,
   1380         expected_labels, expected_icons, expected_unique_ids);
   1381   }
   1382 }
   1383 
   1384 // Test that all values are suggested for multi-valued profile, on a filled
   1385 // form.  This is the per-field "override" case.
   1386 TEST_F(AutofillManagerTest, GetFieldSuggestionsForMultiValuedProfileFilled) {
   1387   // Set up our form data.
   1388   FormData form;
   1389   test::CreateTestAddressFormData(&form);
   1390   std::vector<FormData> forms(1, form);
   1391   FormsSeen(forms);
   1392 
   1393   // |profile| will be owned by the mock PersonalDataManager.
   1394   AutofillProfile* profile = new AutofillProfile;
   1395   profile->set_guid("00000000-0000-0000-0000-000000000102");
   1396   std::vector<base::string16> multi_values(3);
   1397   multi_values[0] = ASCIIToUTF16("Travis");
   1398   multi_values[1] = ASCIIToUTF16("Cynthia");
   1399   multi_values[2] = ASCIIToUTF16("Zac");
   1400   profile->SetRawMultiInfo(NAME_FIRST, multi_values);
   1401   multi_values[0] = ASCIIToUTF16("Smith");
   1402   multi_values[1] = ASCIIToUTF16("Love");
   1403   multi_values[2] = ASCIIToUTF16("Mango");
   1404   profile->SetRawMultiInfo(NAME_LAST, multi_values);
   1405   autofill_manager_->AddProfile(profile);
   1406 
   1407   // Get the first name field.  And start out with "Travis", hoping for all the
   1408   // multi-valued variants as suggestions.
   1409   FormFieldData& field = form.fields[0];
   1410   field.value = ASCIIToUTF16("Travis");
   1411   field.is_autofilled = true;
   1412   GetAutofillSuggestions(form, field);
   1413 
   1414   // Trigger the |Send|.
   1415   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1416 
   1417   // Test that we sent the right values to the external delegate.
   1418   base::string16 expected_values[] = {
   1419     ASCIIToUTF16("Travis"),
   1420     ASCIIToUTF16("Cynthia"),
   1421     ASCIIToUTF16("Zac")
   1422   };
   1423   base::string16 expected_labels[] = { base::string16(), base::string16(),
   1424                                        base::string16() };
   1425   base::string16 expected_icons[] = { base::string16(), base::string16(),
   1426                                       base::string16() };
   1427   int expected_unique_ids[] = { 1, 2, 3 };
   1428   external_delegate_->CheckSuggestions(
   1429       kDefaultPageID, arraysize(expected_values), expected_values,
   1430       expected_labels, expected_icons, expected_unique_ids);
   1431 }
   1432 
   1433 TEST_F(AutofillManagerTest, GetProfileSuggestionsFancyPhone) {
   1434   // Set up our form data.
   1435   FormData form;
   1436   test::CreateTestAddressFormData(&form);
   1437   std::vector<FormData> forms(1, form);
   1438   FormsSeen(forms);
   1439 
   1440   AutofillProfile* profile = new AutofillProfile;
   1441   profile->set_guid("00000000-0000-0000-0000-000000000103");
   1442   profile->SetInfo(AutofillType(NAME_FULL), ASCIIToUTF16("Natty Bumppo"),
   1443                    "en-US");
   1444   profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
   1445                       ASCIIToUTF16("1800PRAIRIE"));
   1446   autofill_manager_->AddProfile(profile);
   1447 
   1448   const FormFieldData& field = form.fields[9];
   1449   GetAutofillSuggestions(form, field);
   1450 
   1451   // No suggestions provided, so send an empty vector as the results.
   1452   // This triggers the combined message send.
   1453   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1454 
   1455   // Test that we sent the right values to the external delegate.
   1456   base::string16 expected_values[] = {
   1457     ASCIIToUTF16("12345678901"),
   1458     ASCIIToUTF16("23456789012"),
   1459     ASCIIToUTF16("18007724743"),  // 1800PRAIRIE
   1460   };
   1461   // Inferred labels include full first relevant field, which in this case is
   1462   // the address line 1.
   1463   base::string16 expected_labels[] = {
   1464     ASCIIToUTF16("Elvis Aaron Presley"),
   1465     ASCIIToUTF16("Charles Hardin Holley"),
   1466     ASCIIToUTF16("Natty Bumppo"),
   1467   };
   1468   base::string16 expected_icons[] = { base::string16(), base::string16(),
   1469                                       base::string16()};
   1470   int expected_unique_ids[] = {1, 2, 3};
   1471   external_delegate_->CheckSuggestions(
   1472       kDefaultPageID, arraysize(expected_values), expected_values,
   1473       expected_labels, expected_icons, expected_unique_ids);
   1474 }
   1475 
   1476 TEST_F(AutofillManagerTest, GetProfileSuggestionsForPhonePrefixOrSuffix) {
   1477   // Set up our form data.
   1478   FormData form;
   1479   form.name = ASCIIToUTF16("MyForm");
   1480   form.origin = GURL("http://myform.com/form.html");
   1481   form.action = GURL("http://myform.com/submit.html");
   1482   form.user_submitted = true;
   1483 
   1484   struct {
   1485     const char* const label;
   1486     const char* const name;
   1487     size_t max_length;
   1488     const char* const autocomplete_attribute;
   1489   } test_fields[] = {{"country code", "country_code", 1, "tel-country-code"},
   1490                      {"area code", "area_code", 3, "tel-area-code"},
   1491                      {"phone", "phone_prefix", 3, "tel-local-prefix"},
   1492                      {"-", "phone_suffix", 4, "tel-local-suffix"},
   1493                      {"Phone Extension", "ext", 5, "tel-extension"}};
   1494 
   1495   FormFieldData field;
   1496   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_fields); ++i) {
   1497     test::CreateTestFormField(
   1498         test_fields[i].label, test_fields[i].name, "", "text", &field);
   1499     field.max_length = test_fields[i].max_length;
   1500     field.autocomplete_attribute = std::string();
   1501     form.fields.push_back(field);
   1502   }
   1503 
   1504   std::vector<FormData> forms(1, form);
   1505   FormsSeen(forms);
   1506 
   1507   AutofillProfile* profile = new AutofillProfile;
   1508   profile->set_guid("00000000-0000-0000-0000-000000000104");
   1509   std::vector<base::string16> multi_values(2);
   1510   multi_values[0] = ASCIIToUTF16("1800FLOWERS");
   1511   multi_values[1] = ASCIIToUTF16("14158889999");
   1512 
   1513   profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, multi_values);
   1514   personal_data_.ClearAutofillProfiles();
   1515   autofill_manager_->AddProfile(profile);
   1516 
   1517   const FormFieldData& phone_prefix = form.fields[2];
   1518   GetAutofillSuggestions(form, phone_prefix);
   1519   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1520   // Test that we sent the right prefix values to the external delegate.
   1521   base::string16 expected_prefix_values[] = {ASCIIToUTF16("356"),
   1522                                              ASCIIToUTF16("888")};
   1523   base::string16 expected_prefix_labels[] = {ASCIIToUTF16("1"),
   1524                                              ASCIIToUTF16("1")};
   1525   base::string16 expected_prefix_icons[] = {base::string16(), base::string16()};
   1526   int expected_unique_ids[] = {1, 2};
   1527   external_delegate_->CheckSuggestions(kDefaultPageID,
   1528                                        arraysize(expected_prefix_values),
   1529                                        expected_prefix_values,
   1530                                        expected_prefix_labels,
   1531                                        expected_prefix_icons,
   1532                                        expected_unique_ids);
   1533 
   1534   const FormFieldData& phone_suffix = form.fields[3];
   1535   GetAutofillSuggestions(form, phone_suffix);
   1536   AutocompleteSuggestionsReturned(std::vector<base::string16>());
   1537   // Test that we sent the right suffix values to the external delegate.
   1538   base::string16 expected_suffix_values[] = {ASCIIToUTF16("9377"),
   1539                                              ASCIIToUTF16("9999")};
   1540   base::string16 expected_suffix_labels[] = {ASCIIToUTF16("1"),
   1541                                              ASCIIToUTF16("1")};
   1542   base::string16 expected_suffix_icons[] = {base::string16(), base::string16()};
   1543   external_delegate_->CheckSuggestions(kDefaultPageID,
   1544                                        arraysize(expected_suffix_values),
   1545                                        expected_suffix_values,
   1546                                        expected_suffix_labels,
   1547                                        expected_suffix_icons,
   1548                                        expected_unique_ids);
   1549 }
   1550 
   1551 // Test that we correctly fill an address form.
   1552 TEST_F(AutofillManagerTest, FillAddressForm) {
   1553   // Set up our form data.
   1554   FormData form;
   1555   test::CreateTestAddressFormData(&form);
   1556   std::vector<FormData> forms(1, form);
   1557   FormsSeen(forms);
   1558 
   1559   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   1560   GUIDPair empty(std::string(), 0);
   1561   int response_page_id = 0;
   1562   FormData response_data;
   1563   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   1564       PackGUIDs(empty, guid), &response_page_id, &response_data);
   1565   ExpectFilledAddressFormElvis(
   1566       response_page_id, response_data, kDefaultPageID, false);
   1567 }
   1568 
   1569 // Test that we correctly fill an address form from an auxiliary profile.
   1570 TEST_F(AutofillManagerTest, FillAddressFormFromAuxiliaryProfile) {
   1571   personal_data_.ClearAutofillProfiles();
   1572 #if defined(OS_MACOSX) && !defined(OS_IOS)
   1573   autofill_client_.GetPrefs()->SetBoolean(
   1574       ::autofill::prefs::kAutofillUseMacAddressBook, true);
   1575 #else
   1576   autofill_client_.GetPrefs()->SetBoolean(
   1577       ::autofill::prefs::kAutofillAuxiliaryProfilesEnabled, true);
   1578 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
   1579 
   1580   personal_data_.CreateTestAuxiliaryProfiles();
   1581 
   1582   // Set up our form data.
   1583   FormData form;
   1584   test::CreateTestAddressFormData(&form);
   1585   std::vector<FormData> forms(1, form);
   1586   FormsSeen(forms);
   1587 
   1588   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   1589   GUIDPair empty(std::string(), 0);
   1590   int response_page_id = 0;
   1591   FormData response_data;
   1592   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   1593       PackGUIDs(empty, guid), &response_page_id, &response_data);
   1594   ExpectFilledAddressFormElvis(
   1595       response_page_id, response_data, kDefaultPageID, false);
   1596 }
   1597 
   1598 // Test that we correctly fill a credit card form.
   1599 TEST_F(AutofillManagerTest, FillCreditCardForm) {
   1600   // Set up our form data.
   1601   FormData form;
   1602   CreateTestCreditCardFormData(&form, true, false);
   1603   std::vector<FormData> forms(1, form);
   1604   FormsSeen(forms);
   1605 
   1606   GUIDPair guid("00000000-0000-0000-0000-000000000004", 0);
   1607   GUIDPair empty(std::string(), 0);
   1608   int response_page_id = 0;
   1609   FormData response_data;
   1610   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
   1611       PackGUIDs(guid, empty), &response_page_id, &response_data);
   1612   ExpectFilledCreditCardFormElvis(
   1613       response_page_id, response_data, kDefaultPageID, false);
   1614 }
   1615 
   1616 // Test that we correctly fill a credit card form with month input type.
   1617 // 1. year empty, month empty
   1618 TEST_F(AutofillManagerTest, FillCreditCardFormNoYearNoMonth) {
   1619   // Same as the SetUp(), but generate 4 credit cards with year month
   1620   // combination.
   1621   personal_data_.CreateTestCreditCardsYearAndMonth("", "");
   1622   // Set up our form data.
   1623   FormData form;
   1624   CreateTestCreditCardFormData(&form, true, true);
   1625   std::vector<FormData> forms(1, form);
   1626   FormsSeen(forms);
   1627 
   1628   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   1629   GUIDPair empty(std::string(), 0);
   1630   int response_page_id = 0;
   1631   FormData response_data;
   1632   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
   1633       PackGUIDs(guid, empty), &response_page_id, &response_data);
   1634   ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
   1635       kDefaultPageID, false, "", "");
   1636 }
   1637 
   1638 
   1639 // Test that we correctly fill a credit card form with month input type.
   1640 // 2. year empty, month non-empty
   1641 TEST_F(AutofillManagerTest, FillCreditCardFormNoYearMonth) {
   1642   // Same as the SetUp(), but generate 4 credit cards with year month
   1643   // combination.
   1644   personal_data_.CreateTestCreditCardsYearAndMonth("", "04");
   1645   // Set up our form data.
   1646   FormData form;
   1647   CreateTestCreditCardFormData(&form, true, true);
   1648   std::vector<FormData> forms(1, form);
   1649   FormsSeen(forms);
   1650 
   1651   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   1652   GUIDPair empty(std::string(), 0);
   1653   int response_page_id = 0;
   1654   FormData response_data;
   1655   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
   1656       PackGUIDs(guid, empty), &response_page_id, &response_data);
   1657   ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
   1658       kDefaultPageID, false, "", "04");
   1659 }
   1660 
   1661 // Test that we correctly fill a credit card form with month input type.
   1662 // 3. year non-empty, month empty
   1663 TEST_F(AutofillManagerTest, FillCreditCardFormYearNoMonth) {
   1664   // Same as the SetUp(), but generate 4 credit cards with year month
   1665   // combination.
   1666   personal_data_.CreateTestCreditCardsYearAndMonth("2012", "");
   1667   // Set up our form data.
   1668   FormData form;
   1669   CreateTestCreditCardFormData(&form, true, true);
   1670   std::vector<FormData> forms(1, form);
   1671   FormsSeen(forms);
   1672 
   1673   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   1674   GUIDPair empty(std::string(), 0);
   1675   int response_page_id = 0;
   1676   FormData response_data;
   1677   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
   1678       PackGUIDs(guid, empty), &response_page_id, &response_data);
   1679   ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
   1680       kDefaultPageID, false, "2012", "");
   1681 }
   1682 
   1683 // Test that we correctly fill a credit card form with month input type.
   1684 // 4. year non-empty, month empty
   1685 TEST_F(AutofillManagerTest, FillCreditCardFormYearMonth) {
   1686   // Same as the SetUp(), but generate 4 credit cards with year month
   1687   // combination.
   1688   personal_data_.ClearCreditCards();
   1689   personal_data_.CreateTestCreditCardsYearAndMonth("2012", "04");
   1690   // Set up our form data.
   1691   FormData form;
   1692   CreateTestCreditCardFormData(&form, true, true);
   1693   std::vector<FormData> forms(1, form);
   1694   FormsSeen(forms);
   1695 
   1696   GUIDPair guid("00000000-0000-0000-0000-000000000007", 0);
   1697   GUIDPair empty(std::string(), 0);
   1698   int response_page_id = 0;
   1699   FormData response_data;
   1700   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
   1701       PackGUIDs(guid, empty), &response_page_id, &response_data);
   1702   ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
   1703       kDefaultPageID, false, "2012", "04");
   1704 }
   1705 
   1706 // Test that we correctly fill a combined address and credit card form.
   1707 TEST_F(AutofillManagerTest, FillAddressAndCreditCardForm) {
   1708   // Set up our form data.
   1709   FormData form;
   1710   test::CreateTestAddressFormData(&form);
   1711   CreateTestCreditCardFormData(&form, true, false);
   1712   std::vector<FormData> forms(1, form);
   1713   FormsSeen(forms);
   1714 
   1715   // First fill the address data.
   1716   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   1717   GUIDPair empty(std::string(), 0);
   1718   int response_page_id = 0;
   1719   FormData response_data;
   1720   {
   1721     SCOPED_TRACE("Address");
   1722     FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   1723         PackGUIDs(empty, guid), &response_page_id, &response_data);
   1724     ExpectFilledAddressFormElvis(
   1725         response_page_id, response_data, kDefaultPageID, true);
   1726   }
   1727 
   1728   // Now fill the credit card data.
   1729   const int kPageID2 = 2;
   1730   GUIDPair guid2("00000000-0000-0000-0000-000000000004", 0);
   1731   response_page_id = 0;
   1732   {
   1733     FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields.back(),
   1734         PackGUIDs(guid2, empty), &response_page_id, &response_data);
   1735     SCOPED_TRACE("Credit card");
   1736     ExpectFilledCreditCardFormElvis(
   1737         response_page_id, response_data, kPageID2, true);
   1738   }
   1739 }
   1740 
   1741 // Test that we correctly fill a form that has multiple logical sections, e.g.
   1742 // both a billing and a shipping address.
   1743 TEST_F(AutofillManagerTest, FillFormWithMultipleSections) {
   1744   // Set up our form data.
   1745   FormData form;
   1746   test::CreateTestAddressFormData(&form);
   1747   const size_t kAddressFormSize = form.fields.size();
   1748   test::CreateTestAddressFormData(&form);
   1749   for (size_t i = kAddressFormSize; i < form.fields.size(); ++i) {
   1750     // Make sure the fields have distinct names.
   1751     form.fields[i].name = form.fields[i].name + ASCIIToUTF16("_");
   1752   }
   1753   std::vector<FormData> forms(1, form);
   1754   FormsSeen(forms);
   1755 
   1756   // Fill the first section.
   1757   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   1758   GUIDPair empty(std::string(), 0);
   1759   int response_page_id = 0;
   1760   FormData response_data;
   1761   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   1762       PackGUIDs(empty, guid), &response_page_id, &response_data);
   1763   {
   1764     SCOPED_TRACE("Address 1");
   1765     // The second address section should be empty.
   1766     ASSERT_EQ(response_data.fields.size(), 2*kAddressFormSize);
   1767     for (size_t i = kAddressFormSize; i < form.fields.size(); ++i) {
   1768       EXPECT_EQ(base::string16(), response_data.fields[i].value);
   1769     }
   1770 
   1771     // The first address section should be filled with Elvis's data.
   1772     response_data.fields.resize(kAddressFormSize);
   1773     ExpectFilledAddressFormElvis(
   1774         response_page_id, response_data, kDefaultPageID, false);
   1775   }
   1776 
   1777   // Fill the second section, with the initiating field somewhere in the middle
   1778   // of the section.
   1779   const int kPageID2 = 2;
   1780   GUIDPair guid2("00000000-0000-0000-0000-000000000001", 0);
   1781   ASSERT_LT(9U, kAddressFormSize);
   1782   response_page_id = 0;
   1783   FillAutofillFormDataAndSaveResults(
   1784       kPageID2, form, form.fields[kAddressFormSize + 9],
   1785       PackGUIDs(empty, guid2), &response_page_id, &response_data);
   1786   {
   1787     SCOPED_TRACE("Address 2");
   1788     ASSERT_EQ(response_data.fields.size(), form.fields.size());
   1789 
   1790     // The first address section should be empty.
   1791     ASSERT_EQ(response_data.fields.size(), 2*kAddressFormSize);
   1792     for (size_t i = 0; i < kAddressFormSize; ++i) {
   1793       EXPECT_EQ(base::string16(), response_data.fields[i].value);
   1794     }
   1795 
   1796     // The second address section should be filled with Elvis's data.
   1797     FormData secondSection = response_data;
   1798     secondSection.fields.erase(secondSection.fields.begin(),
   1799                                secondSection.fields.begin() + kAddressFormSize);
   1800     for (size_t i = 0; i < kAddressFormSize; ++i) {
   1801       // Restore the expected field names.
   1802       base::string16 name = secondSection.fields[i].name;
   1803       base::string16 original_name = name.substr(0, name.size() - 1);
   1804       secondSection.fields[i].name = original_name;
   1805     }
   1806     ExpectFilledAddressFormElvis(
   1807         response_page_id, secondSection, kPageID2, false);
   1808   }
   1809 }
   1810 
   1811 // Test that we correctly fill a form that has author-specified sections, which
   1812 // might not match our expected section breakdown.
   1813 TEST_F(AutofillManagerTest, FillFormWithAuthorSpecifiedSections) {
   1814   // Create a form with a billing section and an unnamed section, interleaved.
   1815   // The billing section includes both address and credit card fields.
   1816   FormData form;
   1817   form.name = ASCIIToUTF16("MyForm");
   1818   form.origin = GURL("https://myform.com/form.html");
   1819   form.action = GURL("https://myform.com/submit.html");
   1820   form.user_submitted = true;
   1821 
   1822   FormFieldData field;
   1823 
   1824   test::CreateTestFormField("", "country", "", "text", &field);
   1825   field.autocomplete_attribute = "section-billing country";
   1826   form.fields.push_back(field);
   1827 
   1828   test::CreateTestFormField("", "firstname", "", "text", &field);
   1829   field.autocomplete_attribute = "given-name";
   1830   form.fields.push_back(field);
   1831 
   1832   test::CreateTestFormField("", "lastname", "", "text", &field);
   1833   field.autocomplete_attribute = "family-name";
   1834   form.fields.push_back(field);
   1835 
   1836   test::CreateTestFormField("", "address", "", "text", &field);
   1837   field.autocomplete_attribute = "section-billing address-line1";
   1838   form.fields.push_back(field);
   1839 
   1840   test::CreateTestFormField("", "city", "", "text", &field);
   1841   field.autocomplete_attribute = "section-billing locality";
   1842   form.fields.push_back(field);
   1843 
   1844   test::CreateTestFormField("", "state", "", "text", &field);
   1845   field.autocomplete_attribute = "section-billing region";
   1846   form.fields.push_back(field);
   1847 
   1848   test::CreateTestFormField("", "zip", "", "text", &field);
   1849   field.autocomplete_attribute = "section-billing postal-code";
   1850   form.fields.push_back(field);
   1851 
   1852   test::CreateTestFormField("", "ccname", "", "text", &field);
   1853   field.autocomplete_attribute = "section-billing cc-name";
   1854   form.fields.push_back(field);
   1855 
   1856   test::CreateTestFormField("", "ccnumber", "", "text", &field);
   1857   field.autocomplete_attribute = "section-billing cc-number";
   1858   form.fields.push_back(field);
   1859 
   1860   test::CreateTestFormField("", "ccexp", "", "text", &field);
   1861   field.autocomplete_attribute = "section-billing cc-exp";
   1862   form.fields.push_back(field);
   1863 
   1864   test::CreateTestFormField("", "email", "", "text", &field);
   1865   field.autocomplete_attribute = "email";
   1866   form.fields.push_back(field);
   1867 
   1868   std::vector<FormData> forms(1, form);
   1869   FormsSeen(forms);
   1870 
   1871   // Fill the unnamed section.
   1872   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   1873   GUIDPair empty(std::string(), 0);
   1874   int response_page_id = 0;
   1875   FormData response_data;
   1876   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[1],
   1877       PackGUIDs(empty, guid), &response_page_id, &response_data);
   1878   {
   1879     SCOPED_TRACE("Unnamed section");
   1880     EXPECT_EQ(kDefaultPageID, response_page_id);
   1881     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
   1882     EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
   1883     EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
   1884     EXPECT_TRUE(response_data.user_submitted);
   1885     ASSERT_EQ(11U, response_data.fields.size());
   1886 
   1887     ExpectFilledField("", "country", "", "text", response_data.fields[0]);
   1888     ExpectFilledField("", "firstname", "Elvis", "text",
   1889                       response_data.fields[1]);
   1890     ExpectFilledField("", "lastname", "Presley", "text",
   1891                       response_data.fields[2]);
   1892     ExpectFilledField("", "address", "", "text", response_data.fields[3]);
   1893     ExpectFilledField("", "city", "", "text", response_data.fields[4]);
   1894     ExpectFilledField("", "state", "", "text", response_data.fields[5]);
   1895     ExpectFilledField("", "zip", "", "text", response_data.fields[6]);
   1896     ExpectFilledField("", "ccname", "", "text", response_data.fields[7]);
   1897     ExpectFilledField("", "ccnumber", "", "text", response_data.fields[8]);
   1898     ExpectFilledField("", "ccexp", "", "text", response_data.fields[9]);
   1899     ExpectFilledField("", "email", "theking (at) gmail.com", "text",
   1900                       response_data.fields[10]);
   1901   }
   1902 
   1903   // Fill the address portion of the billing section.
   1904   const int kPageID2 = 2;
   1905   GUIDPair guid2("00000000-0000-0000-0000-000000000001", 0);
   1906   response_page_id = 0;
   1907   FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields[0],
   1908       PackGUIDs(empty, guid2), &response_page_id, &response_data);
   1909   {
   1910     SCOPED_TRACE("Billing address");
   1911     EXPECT_EQ(kPageID2, response_page_id);
   1912     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
   1913     EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
   1914     EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
   1915     EXPECT_TRUE(response_data.user_submitted);
   1916     ASSERT_EQ(11U, response_data.fields.size());
   1917 
   1918     ExpectFilledField("", "country", "US", "text",
   1919                       response_data.fields[0]);
   1920     ExpectFilledField("", "firstname", "", "text", response_data.fields[1]);
   1921     ExpectFilledField("", "lastname", "", "text", response_data.fields[2]);
   1922     ExpectFilledField("", "address", "3734 Elvis Presley Blvd.", "text",
   1923                       response_data.fields[3]);
   1924     ExpectFilledField("", "city", "Memphis", "text", response_data.fields[4]);
   1925     ExpectFilledField("", "state", "Tennessee", "text",
   1926                       response_data.fields[5]);
   1927     ExpectFilledField("", "zip", "38116", "text", response_data.fields[6]);
   1928     ExpectFilledField("", "ccname", "", "text", response_data.fields[7]);
   1929     ExpectFilledField("", "ccnumber", "", "text", response_data.fields[8]);
   1930     ExpectFilledField("", "ccexp", "", "text", response_data.fields[9]);
   1931     ExpectFilledField("", "email", "", "text", response_data.fields[10]);
   1932   }
   1933 
   1934   // Fill the credit card portion of the billing section.
   1935   const int kPageID3 = 3;
   1936   GUIDPair guid3("00000000-0000-0000-0000-000000000004", 0);
   1937   response_page_id = 0;
   1938   FillAutofillFormDataAndSaveResults(
   1939       kPageID3, form, form.fields[form.fields.size() - 2],
   1940       PackGUIDs(guid3, empty), &response_page_id, &response_data);
   1941   {
   1942     SCOPED_TRACE("Credit card");
   1943     EXPECT_EQ(kPageID3, response_page_id);
   1944     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
   1945     EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
   1946     EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
   1947     EXPECT_TRUE(response_data.user_submitted);
   1948     ASSERT_EQ(11U, response_data.fields.size());
   1949 
   1950     ExpectFilledField("", "country", "", "text", response_data.fields[0]);
   1951     ExpectFilledField("", "firstname", "", "text", response_data.fields[1]);
   1952     ExpectFilledField("", "lastname", "", "text", response_data.fields[2]);
   1953     ExpectFilledField("", "address", "", "text", response_data.fields[3]);
   1954     ExpectFilledField("", "city", "", "text", response_data.fields[4]);
   1955     ExpectFilledField("", "state", "", "text", response_data.fields[5]);
   1956     ExpectFilledField("", "zip", "", "text", response_data.fields[6]);
   1957     ExpectFilledField("", "ccname", "Elvis Presley", "text",
   1958                       response_data.fields[7]);
   1959     ExpectFilledField("", "ccnumber", "4234567890123456", "text",
   1960                       response_data.fields[8]);
   1961     ExpectFilledField("", "ccexp", "04/2012", "text", response_data.fields[9]);
   1962     ExpectFilledField("", "email", "", "text", response_data.fields[10]);
   1963   }
   1964 }
   1965 
   1966 // Test that we correctly fill a form that has a single logical section with
   1967 // multiple email address fields.
   1968 TEST_F(AutofillManagerTest, FillFormWithMultipleEmails) {
   1969   // Set up our form data.
   1970   FormData form;
   1971   test::CreateTestAddressFormData(&form);
   1972   FormFieldData field;
   1973   test::CreateTestFormField("Confirm email", "email2", "", "text", &field);
   1974   form.fields.push_back(field);
   1975 
   1976   std::vector<FormData> forms(1, form);
   1977   FormsSeen(forms);
   1978 
   1979   // Fill the form.
   1980   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   1981   GUIDPair empty(std::string(), 0);
   1982   int response_page_id = 0;
   1983   FormData response_data;
   1984   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   1985       PackGUIDs(empty, guid), &response_page_id, &response_data);
   1986 
   1987   // The second email address should be filled.
   1988   EXPECT_EQ(ASCIIToUTF16("theking (at) gmail.com"),
   1989             response_data.fields.back().value);
   1990 
   1991   // The remainder of the form should be filled as usual.
   1992   response_data.fields.pop_back();
   1993   ExpectFilledAddressFormElvis(
   1994       response_page_id, response_data, kDefaultPageID, false);
   1995 }
   1996 
   1997 // Test that we correctly fill a previously auto-filled form.
   1998 TEST_F(AutofillManagerTest, FillAutofilledForm) {
   1999   // Set up our form data.
   2000   FormData form;
   2001   test::CreateTestAddressFormData(&form);
   2002   // Mark one of the address fields as autofilled.
   2003   form.fields[4].is_autofilled = true;
   2004   CreateTestCreditCardFormData(&form, true, false);
   2005   std::vector<FormData> forms(1, form);
   2006   FormsSeen(forms);
   2007 
   2008   // First fill the address data.
   2009   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   2010   GUIDPair empty(std::string(), 0);
   2011   int response_page_id = 0;
   2012   FormData response_data;
   2013   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
   2014       PackGUIDs(empty, guid), &response_page_id, &response_data);
   2015   {
   2016     SCOPED_TRACE("Address");
   2017     ExpectFilledForm(response_page_id, response_data, kDefaultPageID,
   2018                      "Elvis", "", "", "", "", "", "", "", "", "", "", "", "",
   2019                      "", "", true, true, false);
   2020   }
   2021 
   2022   // Now fill the credit card data.
   2023   const int kPageID2 = 2;
   2024   GUIDPair guid2("00000000-0000-0000-0000-000000000004", 0);
   2025   response_page_id = 0;
   2026   FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields.back(),
   2027       PackGUIDs(guid2, empty), &response_page_id, &response_data);
   2028   {
   2029     SCOPED_TRACE("Credit card 1");
   2030     ExpectFilledCreditCardFormElvis(
   2031         response_page_id, response_data, kPageID2, true);
   2032   }
   2033 
   2034   // Now set the credit card fields to also be auto-filled, and try again to
   2035   // fill the credit card data
   2036   for (std::vector<FormFieldData>::iterator iter = form.fields.begin();
   2037        iter != form.fields.end();
   2038        ++iter) {
   2039     iter->is_autofilled = true;
   2040   }
   2041 
   2042   const int kPageID3 = 3;
   2043   response_page_id = 0;
   2044   FillAutofillFormDataAndSaveResults(kPageID3, form, *form.fields.rbegin(),
   2045       PackGUIDs(guid2, empty), &response_page_id, &response_data);
   2046   {
   2047     SCOPED_TRACE("Credit card 2");
   2048     ExpectFilledForm(response_page_id, response_data, kPageID3,
   2049                      "", "", "", "", "", "", "", "", "", "", "", "", "", "",
   2050                      "2012", true, true, false);
   2051   }
   2052 }
   2053 
   2054 // Test that we correctly fill an address form with a non-default variant for a
   2055 // multi-valued field.
   2056 TEST_F(AutofillManagerTest, FillAddressFormWithVariantType) {
   2057   // Set up our form data.
   2058   FormData form;
   2059   test::CreateTestAddressFormData(&form);
   2060   std::vector<FormData> forms(1, form);
   2061   FormsSeen(forms);
   2062 
   2063   // Add a name variant to the Elvis profile.
   2064   AutofillProfile* profile = autofill_manager_->GetProfileWithGUID(
   2065       "00000000-0000-0000-0000-000000000001");
   2066 
   2067   std::vector<base::string16> name_variants;
   2068   name_variants.push_back(ASCIIToUTF16("Some"));
   2069   name_variants.push_back(profile->GetRawInfo(NAME_FIRST));
   2070   profile->SetRawMultiInfo(NAME_FIRST, name_variants);
   2071 
   2072   name_variants.clear();
   2073   name_variants.push_back(ASCIIToUTF16("Other"));
   2074   name_variants.push_back(profile->GetRawInfo(NAME_MIDDLE));
   2075   profile->SetRawMultiInfo(NAME_MIDDLE, name_variants);
   2076 
   2077   name_variants.clear();
   2078   name_variants.push_back(ASCIIToUTF16("Guy"));
   2079   name_variants.push_back(profile->GetRawInfo(NAME_LAST));
   2080   profile->SetRawMultiInfo(NAME_LAST, name_variants);
   2081 
   2082   GUIDPair guid(profile->guid(), 1);
   2083   GUIDPair empty(std::string(), 0);
   2084   int response_page_id = 0;
   2085   FormData response_data1;
   2086   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   2087       PackGUIDs(empty, guid), &response_page_id, &response_data1);
   2088   {
   2089     SCOPED_TRACE("Valid variant");
   2090     ExpectFilledAddressFormElvis(
   2091         response_page_id, response_data1, kDefaultPageID, false);
   2092   }
   2093 
   2094   // Try filling with a variant that doesn't exist.  The fields to which this
   2095   // variant would normally apply should not be filled.
   2096   const int kPageID2 = 2;
   2097   GUIDPair guid2(profile->guid(), 2);
   2098   response_page_id = 0;
   2099   FormData response_data2;
   2100   FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields[0],
   2101       PackGUIDs(empty, guid2), &response_page_id, &response_data2);
   2102   {
   2103     SCOPED_TRACE("Invalid variant");
   2104     ExpectFilledForm(response_page_id, response_data2, kPageID2, "", "", "",
   2105                      "3734 Elvis Presley Blvd.", "Apt. 10", "Memphis",
   2106                      "Tennessee", "38116", "United States", "12345678901",
   2107                      "theking (at) gmail.com", "", "", "", "", true, false, false);
   2108   }
   2109 }
   2110 
   2111 // Test that we correctly fill a phone number split across multiple fields.
   2112 TEST_F(AutofillManagerTest, FillPhoneNumber) {
   2113   // In one form, rely on the maxlength attribute to imply phone number parts.
   2114   // In the other form, rely on the autocompletetype attribute.
   2115   FormData form_with_maxlength;
   2116   form_with_maxlength.name = ASCIIToUTF16("MyMaxlengthPhoneForm");
   2117   form_with_maxlength.origin = GURL("http://myform.com/phone_form.html");
   2118   form_with_maxlength.action = GURL("http://myform.com/phone_submit.html");
   2119   form_with_maxlength.user_submitted = true;
   2120   FormData form_with_autocompletetype = form_with_maxlength;
   2121   form_with_autocompletetype.name = ASCIIToUTF16("MyAutocompletetypePhoneForm");
   2122 
   2123   struct {
   2124     const char* label;
   2125     const char* name;
   2126     size_t max_length;
   2127     const char* autocomplete_attribute;
   2128   } test_fields[] = {
   2129     { "country code", "country_code", 1, "tel-country-code" },
   2130     { "area code", "area_code", 3, "tel-area-code" },
   2131     { "phone", "phone_prefix", 3, "tel-local-prefix" },
   2132     { "-", "phone_suffix", 4, "tel-local-suffix" },
   2133     { "Phone Extension", "ext", 3, "tel-extension" }
   2134   };
   2135 
   2136   FormFieldData field;
   2137   const size_t default_max_length = field.max_length;
   2138   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_fields); ++i) {
   2139     test::CreateTestFormField(
   2140         test_fields[i].label, test_fields[i].name, "", "text", &field);
   2141     field.max_length = test_fields[i].max_length;
   2142     field.autocomplete_attribute = std::string();
   2143     form_with_maxlength.fields.push_back(field);
   2144 
   2145     field.max_length = default_max_length;
   2146     field.autocomplete_attribute = test_fields[i].autocomplete_attribute;
   2147     form_with_autocompletetype.fields.push_back(field);
   2148   }
   2149 
   2150   std::vector<FormData> forms;
   2151   forms.push_back(form_with_maxlength);
   2152   forms.push_back(form_with_autocompletetype);
   2153   FormsSeen(forms);
   2154 
   2155   // We should be able to fill prefix and suffix fields for US numbers.
   2156   AutofillProfile* work_profile = autofill_manager_->GetProfileWithGUID(
   2157       "00000000-0000-0000-0000-000000000002");
   2158   ASSERT_TRUE(work_profile != NULL);
   2159   work_profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
   2160                            ASCIIToUTF16("16505554567"));
   2161 
   2162   GUIDPair guid(work_profile->guid(), 0);
   2163   GUIDPair empty(std::string(), 0);
   2164   int page_id = 1;
   2165   int response_page_id = 0;
   2166   FormData response_data1;
   2167   FillAutofillFormDataAndSaveResults(page_id, form_with_maxlength,
   2168       *form_with_maxlength.fields.begin(),
   2169       PackGUIDs(empty, guid), &response_page_id, &response_data1);
   2170   EXPECT_EQ(1, response_page_id);
   2171 
   2172   ASSERT_EQ(5U, response_data1.fields.size());
   2173   EXPECT_EQ(ASCIIToUTF16("1"), response_data1.fields[0].value);
   2174   EXPECT_EQ(ASCIIToUTF16("650"), response_data1.fields[1].value);
   2175   EXPECT_EQ(ASCIIToUTF16("555"), response_data1.fields[2].value);
   2176   EXPECT_EQ(ASCIIToUTF16("4567"), response_data1.fields[3].value);
   2177   EXPECT_EQ(base::string16(), response_data1.fields[4].value);
   2178 
   2179   page_id = 2;
   2180   response_page_id = 0;
   2181   FormData response_data2;
   2182   FillAutofillFormDataAndSaveResults(page_id, form_with_autocompletetype,
   2183       *form_with_autocompletetype.fields.begin(),
   2184       PackGUIDs(empty, guid), &response_page_id, &response_data2);
   2185   EXPECT_EQ(2, response_page_id);
   2186 
   2187   ASSERT_EQ(5U, response_data2.fields.size());
   2188   EXPECT_EQ(ASCIIToUTF16("1"), response_data2.fields[0].value);
   2189   EXPECT_EQ(ASCIIToUTF16("650"), response_data2.fields[1].value);
   2190   EXPECT_EQ(ASCIIToUTF16("555"), response_data2.fields[2].value);
   2191   EXPECT_EQ(ASCIIToUTF16("4567"), response_data2.fields[3].value);
   2192   EXPECT_EQ(base::string16(), response_data2.fields[4].value);
   2193 
   2194   // We should not be able to fill prefix and suffix fields for international
   2195   // numbers.
   2196   work_profile->SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("GB"));
   2197   work_profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
   2198                            ASCIIToUTF16("447700954321"));
   2199   page_id = 3;
   2200   response_page_id = 0;
   2201   FormData response_data3;
   2202   FillAutofillFormDataAndSaveResults(page_id, form_with_maxlength,
   2203       *form_with_maxlength.fields.begin(),
   2204       PackGUIDs(empty, guid), &response_page_id, &response_data3);
   2205   EXPECT_EQ(3, response_page_id);
   2206 
   2207   ASSERT_EQ(5U, response_data3.fields.size());
   2208   EXPECT_EQ(ASCIIToUTF16("44"), response_data3.fields[0].value);
   2209   EXPECT_EQ(ASCIIToUTF16("7700"), response_data3.fields[1].value);
   2210   EXPECT_EQ(ASCIIToUTF16("954321"), response_data3.fields[2].value);
   2211   EXPECT_EQ(ASCIIToUTF16("954321"), response_data3.fields[3].value);
   2212   EXPECT_EQ(base::string16(), response_data3.fields[4].value);
   2213 
   2214   page_id = 4;
   2215   response_page_id = 0;
   2216   FormData response_data4;
   2217   FillAutofillFormDataAndSaveResults(page_id, form_with_autocompletetype,
   2218       *form_with_autocompletetype.fields.begin(),
   2219       PackGUIDs(empty, guid), &response_page_id, &response_data4);
   2220   EXPECT_EQ(4, response_page_id);
   2221 
   2222   ASSERT_EQ(5U, response_data4.fields.size());
   2223   EXPECT_EQ(ASCIIToUTF16("44"), response_data4.fields[0].value);
   2224   EXPECT_EQ(ASCIIToUTF16("7700"), response_data4.fields[1].value);
   2225   EXPECT_EQ(ASCIIToUTF16("954321"), response_data4.fields[2].value);
   2226   EXPECT_EQ(ASCIIToUTF16("954321"), response_data4.fields[3].value);
   2227   EXPECT_EQ(base::string16(), response_data4.fields[4].value);
   2228 
   2229   // We should fill all phone fields with the same phone number variant.
   2230   std::vector<base::string16> phone_variants;
   2231   phone_variants.push_back(ASCIIToUTF16("16505554567"));
   2232   phone_variants.push_back(ASCIIToUTF16("18887771234"));
   2233   work_profile->SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
   2234   work_profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, phone_variants);
   2235 
   2236   page_id = 5;
   2237   response_page_id = 0;
   2238   FormData response_data5;
   2239   GUIDPair variant_guid(work_profile->guid(), 1);
   2240   FillAutofillFormDataAndSaveResults(page_id, form_with_maxlength,
   2241       *form_with_maxlength.fields.begin(),
   2242       PackGUIDs(empty, variant_guid), &response_page_id, &response_data5);
   2243   EXPECT_EQ(5, response_page_id);
   2244 
   2245   ASSERT_EQ(5U, response_data5.fields.size());
   2246   EXPECT_EQ(ASCIIToUTF16("1"), response_data5.fields[0].value);
   2247   EXPECT_EQ(ASCIIToUTF16("888"), response_data5.fields[1].value);
   2248   EXPECT_EQ(ASCIIToUTF16("777"), response_data5.fields[2].value);
   2249   EXPECT_EQ(ASCIIToUTF16("1234"), response_data5.fields[3].value);
   2250   EXPECT_EQ(base::string16(), response_data5.fields[4].value);
   2251 }
   2252 
   2253 // Test that we can still fill a form when a field has been removed from it.
   2254 TEST_F(AutofillManagerTest, FormChangesRemoveField) {
   2255   // Set up our form data.
   2256   FormData form;
   2257   test::CreateTestAddressFormData(&form);
   2258 
   2259   // Add a field -- we'll remove it again later.
   2260   FormFieldData field;
   2261   test::CreateTestFormField("Some", "field", "", "text", &field);
   2262   form.fields.insert(form.fields.begin() + 3, field);
   2263 
   2264   std::vector<FormData> forms(1, form);
   2265   FormsSeen(forms);
   2266 
   2267   // Now, after the call to |FormsSeen|, we remove the field before filling.
   2268   form.fields.erase(form.fields.begin() + 3);
   2269 
   2270   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   2271   GUIDPair empty(std::string(), 0);
   2272   int response_page_id = 0;
   2273   FormData response_data;
   2274   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   2275       PackGUIDs(empty, guid), &response_page_id, &response_data);
   2276   ExpectFilledAddressFormElvis(
   2277       response_page_id, response_data, kDefaultPageID, false);
   2278 }
   2279 
   2280 // Test that we can still fill a form when a field has been added to it.
   2281 TEST_F(AutofillManagerTest, FormChangesAddField) {
   2282   // The offset of the phone field in the address form.
   2283   const int kPhoneFieldOffset = 9;
   2284 
   2285   // Set up our form data.
   2286   FormData form;
   2287   test::CreateTestAddressFormData(&form);
   2288 
   2289   // Remove the phone field -- we'll add it back later.
   2290   std::vector<FormFieldData>::iterator pos =
   2291       form.fields.begin() + kPhoneFieldOffset;
   2292   FormFieldData field = *pos;
   2293   pos = form.fields.erase(pos);
   2294 
   2295   std::vector<FormData> forms(1, form);
   2296   FormsSeen(forms);
   2297 
   2298   // Now, after the call to |FormsSeen|, we restore the field before filling.
   2299   form.fields.insert(pos, field);
   2300 
   2301   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   2302   GUIDPair empty(std::string(), 0);
   2303   int response_page_id = 0;
   2304   FormData response_data;
   2305   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   2306       PackGUIDs(empty, guid), &response_page_id, &response_data);
   2307   ExpectFilledAddressFormElvis(
   2308       response_page_id, response_data, kDefaultPageID, false);
   2309 }
   2310 
   2311 // Test that we are able to save form data when forms are submitted.
   2312 TEST_F(AutofillManagerTest, FormSubmitted) {
   2313   // Set up our form data.
   2314   FormData form;
   2315   test::CreateTestAddressFormData(&form);
   2316   std::vector<FormData> forms(1, form);
   2317   FormsSeen(forms);
   2318 
   2319   // Fill the form.
   2320   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   2321   GUIDPair empty(std::string(), 0);
   2322   int response_page_id = 0;
   2323   FormData response_data;
   2324   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   2325       PackGUIDs(empty, guid), &response_page_id, &response_data);
   2326   ExpectFilledAddressFormElvis(
   2327       response_page_id, response_data, kDefaultPageID, false);
   2328 
   2329   // Simulate form submission. We should call into the PDM to try to save the
   2330   // filled data.
   2331   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
   2332   FormSubmitted(response_data);
   2333 }
   2334 
   2335 // Test that when Autocomplete is enabled and Autofill is disabled,
   2336 // form submissions are still received by AutocompleteHistoryManager.
   2337 TEST_F(AutofillManagerTest, FormSubmittedAutocompleteEnabled) {
   2338   TestAutofillClient client;
   2339   autofill_manager_.reset(
   2340       new TestAutofillManager(autofill_driver_.get(), &client, NULL));
   2341   autofill_manager_->set_autofill_enabled(false);
   2342   scoped_ptr<MockAutocompleteHistoryManager> autocomplete_history_manager;
   2343   autocomplete_history_manager.reset(
   2344       new MockAutocompleteHistoryManager(autofill_driver_.get(), &client));
   2345   autofill_manager_->autocomplete_history_manager_ =
   2346       autocomplete_history_manager.Pass();
   2347 
   2348   // Set up our form data.
   2349   FormData form;
   2350   test::CreateTestAddressFormData(&form);
   2351   MockAutocompleteHistoryManager* m = static_cast<
   2352       MockAutocompleteHistoryManager*>(
   2353           autofill_manager_->autocomplete_history_manager_.get());
   2354   EXPECT_CALL(*m,
   2355               OnFormSubmitted(_)).Times(1);
   2356   FormSubmitted(form);
   2357 }
   2358 
   2359 // Test that when Autocomplete is enabled and Autofill is disabled,
   2360 // Autocomplete suggestions are still received.
   2361 TEST_F(AutofillManagerTest, AutocompleteSuggestionsWhenAutofillDisabled) {
   2362   TestAutofillClient client;
   2363   autofill_manager_.reset(
   2364       new TestAutofillManager(autofill_driver_.get(), &client, NULL));
   2365   autofill_manager_->set_autofill_enabled(false);
   2366   autofill_manager_->SetExternalDelegate(external_delegate_.get());
   2367 
   2368   // Set up our form data.
   2369   FormData form;
   2370   test::CreateTestAddressFormData(&form);
   2371   std::vector<FormData> forms(1, form);
   2372   FormsSeen(forms);
   2373   const FormFieldData& field = form.fields[0];
   2374   GetAutofillSuggestions(form, field);
   2375 
   2376   // Add some Autocomplete suggestions. We should return the autocomplete
   2377   // suggestions, these will be culled by the renderer.
   2378   std::vector<base::string16> suggestions;
   2379   suggestions.push_back(ASCIIToUTF16("Jay"));
   2380   suggestions.push_back(ASCIIToUTF16("Jason"));
   2381   AutocompleteSuggestionsReturned(suggestions);
   2382 
   2383   base::string16 expected_values[] = {
   2384     ASCIIToUTF16("Jay"),
   2385     ASCIIToUTF16("Jason")
   2386   };
   2387   base::string16 expected_labels[] = { base::string16(), base::string16()};
   2388   base::string16 expected_icons[] = { base::string16(), base::string16()};
   2389   int expected_unique_ids[] = {0, 0};
   2390   external_delegate_->CheckSuggestions(
   2391       kDefaultPageID, arraysize(expected_values), expected_values,
   2392       expected_labels, expected_icons, expected_unique_ids);
   2393 }
   2394 
   2395 // Test that we are able to save form data when forms are submitted and we only
   2396 // have server data for the field types.
   2397 TEST_F(AutofillManagerTest, FormSubmittedServerTypes) {
   2398   // Set up our form data.
   2399   FormData form;
   2400   test::CreateTestAddressFormData(&form);
   2401 
   2402   // Simulate having seen this form on page load.
   2403   // |form_structure| will be owned by |autofill_manager_|.
   2404   TestFormStructure* form_structure = new TestFormStructure(form);
   2405   AutofillMetrics metrics_logger;  // ignored
   2406   form_structure->DetermineHeuristicTypes(metrics_logger);
   2407 
   2408   // Clear the heuristic types, and instead set the appropriate server types.
   2409   std::vector<ServerFieldType> heuristic_types, server_types;
   2410   for (size_t i = 0; i < form.fields.size(); ++i) {
   2411     heuristic_types.push_back(UNKNOWN_TYPE);
   2412     server_types.push_back(form_structure->field(i)->heuristic_type());
   2413   }
   2414   form_structure->SetFieldTypes(heuristic_types, server_types);
   2415   autofill_manager_->AddSeenForm(form_structure);
   2416 
   2417   // Fill the form.
   2418   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   2419   GUIDPair empty(std::string(), 0);
   2420   int response_page_id = 0;
   2421   FormData response_data;
   2422   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
   2423       PackGUIDs(empty, guid), &response_page_id, &response_data);
   2424   ExpectFilledAddressFormElvis(
   2425       response_page_id, response_data, kDefaultPageID, false);
   2426 
   2427   // Simulate form submission. We should call into the PDM to try to save the
   2428   // filled data.
   2429   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
   2430   FormSubmitted(response_data);
   2431 }
   2432 
   2433 // Test that the form signature for an uploaded form always matches the form
   2434 // signature from the query.
   2435 TEST_F(AutofillManagerTest, FormSubmittedWithDifferentFields) {
   2436   // Set up our form data.
   2437   FormData form;
   2438   test::CreateTestAddressFormData(&form);
   2439   std::vector<FormData> forms(1, form);
   2440   FormsSeen(forms);
   2441 
   2442   // Cache the expected form signature.
   2443   std::string signature = FormStructure(form).FormSignature();
   2444 
   2445   // Change the structure of the form prior to submission.
   2446   // Websites would typically invoke JavaScript either on page load or on form
   2447   // submit to achieve this.
   2448   form.fields.pop_back();
   2449   FormFieldData field = form.fields[3];
   2450   form.fields[3] = form.fields[7];
   2451   form.fields[7] = field;
   2452 
   2453   // Simulate form submission.
   2454   FormSubmitted(form);
   2455   EXPECT_EQ(signature, autofill_manager_->GetSubmittedFormSignature());
   2456 }
   2457 
   2458 // Test that we do not save form data when submitted fields contain default
   2459 // values.
   2460 TEST_F(AutofillManagerTest, FormSubmittedWithDefaultValues) {
   2461   // Set up our form data.
   2462   FormData form;
   2463   test::CreateTestAddressFormData(&form);
   2464   form.fields[3].value = ASCIIToUTF16("Enter your address");
   2465 
   2466   // Convert the state field to a <select> popup, to make sure that we only
   2467   // reject default values for text fields.
   2468   ASSERT_TRUE(form.fields[6].name == ASCIIToUTF16("state"));
   2469   form.fields[6].form_control_type = "select-one";
   2470   form.fields[6].value = ASCIIToUTF16("Tennessee");
   2471 
   2472   std::vector<FormData> forms(1, form);
   2473   FormsSeen(forms);
   2474 
   2475   // Fill the form.
   2476   GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
   2477   GUIDPair empty(std::string(), 0);
   2478   int response_page_id = 0;
   2479   FormData response_data;
   2480   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[3],
   2481       PackGUIDs(empty, guid), &response_page_id, &response_data);
   2482 
   2483   // Simulate form submission.  We should call into the PDM to try to save the
   2484   // filled data.
   2485   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(1);
   2486   FormSubmitted(response_data);
   2487 
   2488   // Set the address field's value back to the default value.
   2489   response_data.fields[3].value = ASCIIToUTF16("Enter your address");
   2490 
   2491   // Simulate form submission.  We should not call into the PDM to try to save
   2492   // the filled data, since the filled form is effectively missing an address.
   2493   EXPECT_CALL(personal_data_, SaveImportedProfile(::testing::_)).Times(0);
   2494   FormSubmitted(response_data);
   2495 }
   2496 
   2497 // Checks that resetting the auxiliary profile enabled preference does the right
   2498 // thing on all platforms.
   2499 TEST_F(AutofillManagerTest, AuxiliaryProfilesReset) {
   2500   PrefService* prefs = autofill_client_.GetPrefs();
   2501 #if defined(OS_MACOSX)
   2502   // Auxiliary profiles is implemented on Mac only.
   2503   // OSX: This preference exists for legacy reasons. It is no longer used.
   2504   ASSERT_TRUE(
   2505       prefs->GetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled));
   2506   prefs->SetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled,
   2507                     false);
   2508   prefs->ClearPref(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled);
   2509   ASSERT_TRUE(
   2510       prefs->GetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled));
   2511 #else
   2512   ASSERT_FALSE(
   2513       prefs->GetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled));
   2514   prefs->SetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled, true);
   2515   prefs->ClearPref(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled);
   2516   ASSERT_FALSE(
   2517       prefs->GetBoolean(::autofill::prefs::kAutofillAuxiliaryProfilesEnabled));
   2518 #endif  // defined(OS_MACOSX)
   2519 }
   2520 
   2521 TEST_F(AutofillManagerTest, DeterminePossibleFieldTypesForUpload) {
   2522   FormData form;
   2523   form.name = ASCIIToUTF16("MyForm");
   2524   form.origin = GURL("http://myform.com/form.html");
   2525   form.action = GURL("http://myform.com/submit.html");
   2526   form.user_submitted = true;
   2527 
   2528   std::vector<ServerFieldTypeSet> expected_types;
   2529 
   2530   // These fields should all match.
   2531   FormFieldData field;
   2532   ServerFieldTypeSet types;
   2533   test::CreateTestFormField("", "1", "Elvis", "text", &field);
   2534   types.clear();
   2535   types.insert(NAME_FIRST);
   2536   form.fields.push_back(field);
   2537   expected_types.push_back(types);
   2538 
   2539   test::CreateTestFormField("", "2", "Aaron", "text", &field);
   2540   types.clear();
   2541   types.insert(NAME_MIDDLE);
   2542   form.fields.push_back(field);
   2543   expected_types.push_back(types);
   2544 
   2545   test::CreateTestFormField("", "3", "A", "text", &field);
   2546   types.clear();
   2547   types.insert(NAME_MIDDLE_INITIAL);
   2548   form.fields.push_back(field);
   2549   expected_types.push_back(types);
   2550 
   2551   test::CreateTestFormField("", "4", "Presley", "text", &field);
   2552   types.clear();
   2553   types.insert(NAME_LAST);
   2554   form.fields.push_back(field);
   2555   expected_types.push_back(types);
   2556 
   2557   test::CreateTestFormField("", "5", "Elvis Presley", "text", &field);
   2558   types.clear();
   2559   types.insert(CREDIT_CARD_NAME);
   2560   form.fields.push_back(field);
   2561   expected_types.push_back(types);
   2562 
   2563   test::CreateTestFormField("", "6", "Elvis Aaron Presley", "text",
   2564                                      &field);
   2565   types.clear();
   2566   types.insert(NAME_FULL);
   2567   form.fields.push_back(field);
   2568   expected_types.push_back(types);
   2569 
   2570   test::CreateTestFormField("", "7", "theking (at) gmail.com", "email",
   2571                                      &field);
   2572   types.clear();
   2573   types.insert(EMAIL_ADDRESS);
   2574   form.fields.push_back(field);
   2575   expected_types.push_back(types);
   2576 
   2577   test::CreateTestFormField("", "8", "RCA", "text", &field);
   2578   types.clear();
   2579   types.insert(COMPANY_NAME);
   2580   form.fields.push_back(field);
   2581   expected_types.push_back(types);
   2582 
   2583   test::CreateTestFormField("", "9", "3734 Elvis Presley Blvd.",
   2584                                      "text", &field);
   2585   types.clear();
   2586   types.insert(ADDRESS_HOME_LINE1);
   2587   form.fields.push_back(field);
   2588   expected_types.push_back(types);
   2589 
   2590   test::CreateTestFormField("", "10", "Apt. 10", "text", &field);
   2591   types.clear();
   2592   types.insert(ADDRESS_HOME_LINE2);
   2593   form.fields.push_back(field);
   2594   expected_types.push_back(types);
   2595 
   2596   test::CreateTestFormField("", "11", "Memphis", "text", &field);
   2597   types.clear();
   2598   types.insert(ADDRESS_HOME_CITY);
   2599   form.fields.push_back(field);
   2600   expected_types.push_back(types);
   2601 
   2602   test::CreateTestFormField("", "12", "Tennessee", "text", &field);
   2603   types.clear();
   2604   types.insert(ADDRESS_HOME_STATE);
   2605   form.fields.push_back(field);
   2606   expected_types.push_back(types);
   2607 
   2608   test::CreateTestFormField("", "13", "38116", "text", &field);
   2609   types.clear();
   2610   types.insert(ADDRESS_HOME_ZIP);
   2611   form.fields.push_back(field);
   2612   expected_types.push_back(types);
   2613 
   2614   test::CreateTestFormField("", "14", "USA", "text", &field);
   2615   types.clear();
   2616   types.insert(ADDRESS_HOME_COUNTRY);
   2617   form.fields.push_back(field);
   2618   expected_types.push_back(types);
   2619 
   2620   test::CreateTestFormField("", "15", "United States", "text", &field);
   2621   types.clear();
   2622   types.insert(ADDRESS_HOME_COUNTRY);
   2623   form.fields.push_back(field);
   2624   expected_types.push_back(types);
   2625 
   2626   test::CreateTestFormField("", "16", "+1 (234) 567-8901", "text",
   2627                                      &field);
   2628   types.clear();
   2629   types.insert(PHONE_HOME_WHOLE_NUMBER);
   2630   form.fields.push_back(field);
   2631   expected_types.push_back(types);
   2632 
   2633   test::CreateTestFormField("", "17", "2345678901", "text", &field);
   2634   types.clear();
   2635   types.insert(PHONE_HOME_CITY_AND_NUMBER);
   2636   form.fields.push_back(field);
   2637   expected_types.push_back(types);
   2638 
   2639   test::CreateTestFormField("", "18", "1", "text", &field);
   2640   types.clear();
   2641   types.insert(PHONE_HOME_COUNTRY_CODE);
   2642   form.fields.push_back(field);
   2643   expected_types.push_back(types);
   2644 
   2645   test::CreateTestFormField("", "19", "234", "text", &field);
   2646   types.clear();
   2647   types.insert(PHONE_HOME_CITY_CODE);
   2648   form.fields.push_back(field);
   2649   expected_types.push_back(types);
   2650 
   2651   test::CreateTestFormField("", "20", "5678901", "text", &field);
   2652   types.clear();
   2653   types.insert(PHONE_HOME_NUMBER);
   2654   form.fields.push_back(field);
   2655   expected_types.push_back(types);
   2656 
   2657   test::CreateTestFormField("", "21", "567", "text", &field);
   2658   types.clear();
   2659   types.insert(PHONE_HOME_NUMBER);
   2660   form.fields.push_back(field);
   2661   expected_types.push_back(types);
   2662 
   2663   test::CreateTestFormField("", "22", "8901", "text", &field);
   2664   types.clear();
   2665   types.insert(PHONE_HOME_NUMBER);
   2666   form.fields.push_back(field);
   2667   expected_types.push_back(types);
   2668 
   2669   test::CreateTestFormField("", "23", "4234-5678-9012-3456", "text",
   2670                                      &field);
   2671   types.clear();
   2672   types.insert(CREDIT_CARD_NUMBER);
   2673   form.fields.push_back(field);
   2674   expected_types.push_back(types);
   2675 
   2676   test::CreateTestFormField("", "24", "04", "text", &field);
   2677   types.clear();
   2678   types.insert(CREDIT_CARD_EXP_MONTH);
   2679   form.fields.push_back(field);
   2680   expected_types.push_back(types);
   2681 
   2682   test::CreateTestFormField("", "25", "April", "text", &field);
   2683   types.clear();
   2684   types.insert(CREDIT_CARD_EXP_MONTH);
   2685   form.fields.push_back(field);
   2686   expected_types.push_back(types);
   2687 
   2688   test::CreateTestFormField("", "26", "2012", "text", &field);
   2689   types.clear();
   2690   types.insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
   2691   form.fields.push_back(field);
   2692   expected_types.push_back(types);
   2693 
   2694   test::CreateTestFormField("", "27", "12", "text", &field);
   2695   types.clear();
   2696   types.insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
   2697   form.fields.push_back(field);
   2698   expected_types.push_back(types);
   2699 
   2700   test::CreateTestFormField("", "28", "04/2012", "text", &field);
   2701   types.clear();
   2702   types.insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
   2703   form.fields.push_back(field);
   2704   expected_types.push_back(types);
   2705 
   2706   // Make sure that we trim whitespace properly.
   2707   test::CreateTestFormField("", "29", "", "text", &field);
   2708   types.clear();
   2709   types.insert(EMPTY_TYPE);
   2710   form.fields.push_back(field);
   2711   expected_types.push_back(types);
   2712 
   2713   test::CreateTestFormField("", "30", " ", "text", &field);
   2714   types.clear();
   2715   types.insert(EMPTY_TYPE);
   2716   form.fields.push_back(field);
   2717   expected_types.push_back(types);
   2718 
   2719   test::CreateTestFormField("", "31", " Elvis", "text", &field);
   2720   types.clear();
   2721   types.insert(NAME_FIRST);
   2722   form.fields.push_back(field);
   2723   expected_types.push_back(types);
   2724 
   2725   test::CreateTestFormField("", "32", "Elvis ", "text", &field);
   2726   types.clear();
   2727   types.insert(NAME_FIRST);
   2728   form.fields.push_back(field);
   2729   expected_types.push_back(types);
   2730 
   2731   // These fields should not match, as they differ by case.
   2732   test::CreateTestFormField("", "33", "elvis", "text", &field);
   2733   types.clear();
   2734   types.insert(UNKNOWN_TYPE);
   2735   form.fields.push_back(field);
   2736   expected_types.push_back(types);
   2737 
   2738   test::CreateTestFormField("", "34", "3734 Elvis Presley BLVD",
   2739                                      "text", &field);
   2740   types.clear();
   2741   types.insert(UNKNOWN_TYPE);
   2742   form.fields.push_back(field);
   2743   expected_types.push_back(types);
   2744 
   2745   // These fields should not match, as they are unsupported variants.
   2746   test::CreateTestFormField("", "35", "Elvis Aaron", "text", &field);
   2747   types.clear();
   2748   types.insert(UNKNOWN_TYPE);
   2749   form.fields.push_back(field);
   2750   expected_types.push_back(types);
   2751 
   2752   test::CreateTestFormField("", "36", "Mr. Presley", "text", &field);
   2753   types.clear();
   2754   types.insert(UNKNOWN_TYPE);
   2755   form.fields.push_back(field);
   2756   expected_types.push_back(types);
   2757 
   2758   test::CreateTestFormField("", "37", "3734 Elvis Presley", "text",
   2759                                      &field);
   2760   types.clear();
   2761   types.insert(UNKNOWN_TYPE);
   2762   form.fields.push_back(field);
   2763   expected_types.push_back(types);
   2764 
   2765   test::CreateTestFormField("", "38", "TN", "text", &field);
   2766   types.clear();
   2767   types.insert(UNKNOWN_TYPE);
   2768   form.fields.push_back(field);
   2769   expected_types.push_back(types);
   2770 
   2771   test::CreateTestFormField("", "39", "38116-1023", "text", &field);
   2772   types.clear();
   2773   types.insert(UNKNOWN_TYPE);
   2774   form.fields.push_back(field);
   2775   expected_types.push_back(types);
   2776 
   2777   test::CreateTestFormField("", "20", "5", "text", &field);
   2778   types.clear();
   2779   types.insert(UNKNOWN_TYPE);
   2780   form.fields.push_back(field);
   2781   expected_types.push_back(types);
   2782 
   2783   test::CreateTestFormField("", "20", "56", "text", &field);
   2784   types.clear();
   2785   types.insert(UNKNOWN_TYPE);
   2786   form.fields.push_back(field);
   2787   expected_types.push_back(types);
   2788 
   2789   test::CreateTestFormField("", "20", "901", "text", &field);
   2790   types.clear();
   2791   types.insert(UNKNOWN_TYPE);
   2792   form.fields.push_back(field);
   2793   expected_types.push_back(types);
   2794 
   2795   test::CreateTestFormField("", "40", "mypassword", "password", &field);
   2796   types.clear();
   2797   types.insert(PASSWORD);
   2798   form.fields.push_back(field);
   2799   expected_types.push_back(types);
   2800 
   2801   autofill_manager_->set_expected_submitted_field_types(expected_types);
   2802   FormSubmitted(form);
   2803 }
   2804 
   2805 TEST_F(AutofillManagerTest, RemoveProfile) {
   2806   // Add and remove an Autofill profile.
   2807   AutofillProfile* profile = new AutofillProfile;
   2808   std::string guid = "00000000-0000-0000-0000-000000000102";
   2809   profile->set_guid(guid.c_str());
   2810   autofill_manager_->AddProfile(profile);
   2811 
   2812   GUIDPair guid_pair(guid, 0);
   2813   GUIDPair empty(std::string(), 0);
   2814   int id = PackGUIDs(empty, guid_pair);
   2815 
   2816   autofill_manager_->RemoveAutofillProfileOrCreditCard(id);
   2817 
   2818   EXPECT_FALSE(autofill_manager_->GetProfileWithGUID(guid.c_str()));
   2819 }
   2820 
   2821 TEST_F(AutofillManagerTest, RemoveCreditCard){
   2822   // Add and remove an Autofill credit card.
   2823   CreditCard* credit_card = new CreditCard;
   2824   std::string guid = "00000000-0000-0000-0000-000000100007";
   2825   credit_card->set_guid(guid.c_str());
   2826   autofill_manager_->AddCreditCard(credit_card);
   2827 
   2828   GUIDPair guid_pair(guid, 0);
   2829   GUIDPair empty(std::string(), 0);
   2830   int id = PackGUIDs(guid_pair, empty);
   2831 
   2832   autofill_manager_->RemoveAutofillProfileOrCreditCard(id);
   2833 
   2834   EXPECT_FALSE(autofill_manager_->GetCreditCardWithGUID(guid.c_str()));
   2835 }
   2836 
   2837 TEST_F(AutofillManagerTest, RemoveProfileVariant) {
   2838   // Add and remove an Autofill profile.
   2839   AutofillProfile* profile = new AutofillProfile;
   2840   std::string guid = "00000000-0000-0000-0000-000000000102";
   2841   profile->set_guid(guid.c_str());
   2842   autofill_manager_->AddProfile(profile);
   2843 
   2844   GUIDPair guid_pair(guid, 1);
   2845   GUIDPair empty(std::string(), 0);
   2846   int id = PackGUIDs(empty, guid_pair);
   2847 
   2848   autofill_manager_->RemoveAutofillProfileOrCreditCard(id);
   2849 
   2850   // TODO(csharp): Currently variants should not be deleted, but once they are
   2851   // update these expectations.
   2852   // http://crbug.com/124211
   2853   EXPECT_TRUE(autofill_manager_->GetProfileWithGUID(guid.c_str()));
   2854 }
   2855 
   2856 #if defined(OS_MACOSX) && !defined(OS_IOS)
   2857 TEST_F(AutofillManagerTest, AccessAddressBookPrompt) {
   2858   FormData form;
   2859   test::CreateTestAddressFormData(&form);
   2860   std::vector<FormData> forms(1, form);
   2861   FormsSeen(forms);
   2862   FormFieldData& field = form.fields[0];
   2863   field.should_autocomplete = true;
   2864 
   2865   // A profile already exists.
   2866   EXPECT_FALSE(
   2867       autofill_manager_->ShouldShowAccessAddressBookSuggestion(form, field));
   2868 
   2869   // Remove all profiles.
   2870   personal_data_.ClearAutofillProfiles();
   2871   EXPECT_TRUE(
   2872       autofill_manager_->ShouldShowAccessAddressBookSuggestion(form, field));
   2873 
   2874   field.should_autocomplete = false;
   2875   EXPECT_FALSE(
   2876       autofill_manager_->ShouldShowAccessAddressBookSuggestion(form, field));
   2877 }
   2878 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
   2879 
   2880 namespace {
   2881 
   2882 class MockAutofillClient : public TestAutofillClient {
   2883  public:
   2884   MockAutofillClient() {}
   2885 
   2886   virtual ~MockAutofillClient() {}
   2887 
   2888   virtual void ShowRequestAutocompleteDialog(
   2889       const FormData& form,
   2890       const GURL& source_url,
   2891       const ResultCallback& callback) OVERRIDE {
   2892     callback.Run(user_supplied_data_ ? AutocompleteResultSuccess :
   2893                                        AutocompleteResultErrorDisabled,
   2894                  base::string16(),
   2895                  user_supplied_data_.get());
   2896   }
   2897 
   2898   void SetUserSuppliedData(scoped_ptr<FormStructure> user_supplied_data) {
   2899     user_supplied_data_.reset(user_supplied_data.release());
   2900   }
   2901 
   2902  private:
   2903   scoped_ptr<FormStructure> user_supplied_data_;
   2904 
   2905   DISALLOW_COPY_AND_ASSIGN(MockAutofillClient);
   2906 };
   2907 
   2908 }  // namespace
   2909 
   2910 // Test our external delegate is called at the right time.
   2911 TEST_F(AutofillManagerTest, TestExternalDelegate) {
   2912   FormData form;
   2913   test::CreateTestAddressFormData(&form);
   2914   std::vector<FormData> forms(1, form);
   2915   FormsSeen(forms);
   2916   const FormFieldData& field = form.fields[0];
   2917   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
   2918 
   2919   EXPECT_TRUE(external_delegate_->on_query_seen());
   2920 }
   2921 
   2922 }  // namespace autofill
   2923