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