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