1 // Copyright (c) 2012 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 <vector> 6 7 #include "base/format_macros.h" 8 #include "base/metrics/field_trial.h" 9 #include "base/strings/string16.h" 10 #include "base/strings/string_util.h" 11 #include "base/strings/stringprintf.h" 12 #include "base/strings/utf_string_conversions.h" 13 #include "chrome/test/base/chrome_render_view_test.h" 14 #include "components/autofill/content/renderer/form_autofill_util.h" 15 #include "components/autofill/content/renderer/form_cache.h" 16 #include "components/autofill/core/common/form_data.h" 17 #include "components/autofill/core/common/web_element_descriptor.h" 18 #include "components/variations/entropy_provider.h" 19 #include "testing/gtest/include/gtest/gtest.h" 20 #include "third_party/WebKit/public/platform/WebString.h" 21 #include "third_party/WebKit/public/platform/WebVector.h" 22 #include "third_party/WebKit/public/web/WebDocument.h" 23 #include "third_party/WebKit/public/web/WebElement.h" 24 #include "third_party/WebKit/public/web/WebFormControlElement.h" 25 #include "third_party/WebKit/public/web/WebFormElement.h" 26 #include "third_party/WebKit/public/web/WebInputElement.h" 27 #include "third_party/WebKit/public/web/WebNode.h" 28 #include "third_party/WebKit/public/web/WebSelectElement.h" 29 #include "third_party/WebKit/public/web/WebTextAreaElement.h" 30 31 using blink::WebDocument; 32 using blink::WebElement; 33 using blink::WebFormControlElement; 34 using blink::WebFormElement; 35 using blink::WebFrame; 36 using blink::WebInputElement; 37 using blink::WebNode; 38 using blink::WebSelectElement; 39 using blink::WebString; 40 using blink::WebTextAreaElement; 41 using blink::WebVector; 42 43 namespace { 44 45 struct AutofillFieldCase { 46 const char* const form_control_type; 47 const char* const name; 48 const char* const initial_value; 49 const char* const autocomplete_attribute; // The autocomplete attribute of 50 // the element. 51 bool should_be_autofilled; // Whether the filed should be autofilled. 52 const char* const autofill_value; // The value being used to fill the field. 53 const char* const expected_value; // The expected value after Autofill 54 // or Preview. 55 }; 56 57 static const char kFormHtml[] = 58 "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 59 " <INPUT type=\"text\" id=\"firstname\"/>" 60 " <INPUT type=\"text\" id=\"lastname\"/>" 61 " <INPUT type=\"hidden\" id=\"imhidden\"/>" 62 " <INPUT type=\"text\" id=\"notempty\" value=\"Hi\"/>" 63 " <INPUT type=\"text\" autocomplete=\"off\" id=\"noautocomplete\"/>" 64 " <INPUT type=\"text\" disabled=\"disabled\" id=\"notenabled\"/>" 65 " <INPUT type=\"text\" readonly id=\"readonly\"/>" 66 " <INPUT type=\"text\" style=\"visibility: hidden\"" 67 " id=\"invisible\"/>" 68 " <INPUT type=\"text\" style=\"display: none\" id=\"displaynone\"/>" 69 " <INPUT type=\"month\" id=\"month\"/>" 70 " <INPUT type=\"month\" id=\"month-nonempty\" value=\"2011-12\"/>" 71 " <SELECT id=\"select\">" 72 " <OPTION></OPTION>" 73 " <OPTION value=\"CA\">California</OPTION>" 74 " <OPTION value=\"TX\">Texas</OPTION>" 75 " </SELECT>" 76 " <SELECT id=\"select-nonempty\">" 77 " <OPTION value=\"CA\" selected>California</OPTION>" 78 " <OPTION value=\"TX\">Texas</OPTION>" 79 " </SELECT>" 80 " <TEXTAREA id=\"textarea\"></TEXTAREA>" 81 " <TEXTAREA id=\"textarea-nonempty\">Go away!</TEXTAREA>" 82 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 83 "</FORM>"; 84 85 } // namespace 86 87 namespace autofill { 88 89 class FormAutofillTest : public ChromeRenderViewTest { 90 public: 91 FormAutofillTest() : ChromeRenderViewTest() {} 92 virtual ~FormAutofillTest() {} 93 94 void ExpectLabels(const char* html, 95 const std::vector<base::string16>& labels, 96 const std::vector<base::string16>& names, 97 const std::vector<base::string16>& values) { 98 std::vector<std::string> control_types(labels.size(), "text"); 99 ExpectLabelsAndTypes(html, labels, names, values, control_types); 100 } 101 102 void ExpectLabelsAndTypes(const char* html, 103 const std::vector<base::string16>& labels, 104 const std::vector<base::string16>& names, 105 const std::vector<base::string16>& values, 106 const std::vector<std::string>& control_types) { 107 ASSERT_EQ(labels.size(), names.size()); 108 ASSERT_EQ(labels.size(), values.size()); 109 ASSERT_EQ(labels.size(), control_types.size()); 110 111 LoadHTML(html); 112 113 WebFrame* web_frame = GetMainFrame(); 114 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 115 116 FormCache form_cache; 117 std::vector<FormData> forms; 118 form_cache.ExtractForms(*web_frame, &forms); 119 ASSERT_EQ(1U, forms.size()); 120 121 const FormData& form = forms[0]; 122 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 123 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 124 EXPECT_EQ(GURL("http://cnn.com"), form.action); 125 126 const std::vector<FormFieldData>& fields = form.fields; 127 ASSERT_EQ(labels.size(), fields.size()); 128 for (size_t i = 0; i < labels.size(); ++i) { 129 int max_length = control_types[i] == "text" ? 130 WebInputElement::defaultMaxLength() : 0; 131 FormFieldData expected; 132 expected.label = labels[i]; 133 expected.name = names[i]; 134 expected.value = values[i]; 135 expected.form_control_type = control_types[i]; 136 expected.max_length = max_length; 137 SCOPED_TRACE(base::StringPrintf("i: %" PRIuS, i)); 138 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[i]); 139 } 140 } 141 142 void ExpectJohnSmithLabels(const char* html) { 143 std::vector<base::string16> labels, names, values; 144 145 labels.push_back(ASCIIToUTF16("First name:")); 146 names.push_back(ASCIIToUTF16("firstname")); 147 values.push_back(ASCIIToUTF16("John")); 148 149 labels.push_back(ASCIIToUTF16("Last name:")); 150 names.push_back(ASCIIToUTF16("lastname")); 151 values.push_back(ASCIIToUTF16("Smith")); 152 153 labels.push_back(ASCIIToUTF16("Email:")); 154 names.push_back(ASCIIToUTF16("email")); 155 values.push_back(ASCIIToUTF16("john (at) example.com")); 156 157 ExpectLabels(html, labels, names, values); 158 } 159 160 typedef void (*FillFormFunction)(const FormData& form, 161 const WebInputElement& element); 162 163 typedef WebString (WebInputElement::*GetValueFunction)(void) const; 164 165 // Test FormFillxxx functions. 166 void TestFormFillFunctions(const char* html, 167 const AutofillFieldCase* field_cases, 168 size_t number_of_field_cases, 169 FillFormFunction fill_form_function, 170 GetValueFunction get_value_function) { 171 LoadHTML(html); 172 173 WebFrame* web_frame = GetMainFrame(); 174 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 175 176 FormCache form_cache; 177 std::vector<FormData> forms; 178 form_cache.ExtractForms(*web_frame, &forms); 179 ASSERT_EQ(1U, forms.size()); 180 181 // Get the input element we want to find. 182 WebElement element = web_frame->document().getElementById("firstname"); 183 WebInputElement input_element = element.to<WebInputElement>(); 184 185 // Find the form that contains the input element. 186 FormData form_data; 187 FormFieldData field; 188 EXPECT_TRUE( 189 FindFormAndFieldForInputElement(input_element, 190 &form_data, 191 &field, 192 autofill::REQUIRE_AUTOCOMPLETE)); 193 EXPECT_EQ(ASCIIToUTF16("TestForm"), form_data.name); 194 EXPECT_EQ(GURL(web_frame->document().url()), form_data.origin); 195 EXPECT_EQ(GURL("http://buh.com"), form_data.action); 196 197 const std::vector<FormFieldData>& fields = form_data.fields; 198 ASSERT_EQ(number_of_field_cases, fields.size()); 199 200 FormFieldData expected; 201 // Verify field's initial value. 202 for (size_t i = 0; i < number_of_field_cases; ++i) { 203 SCOPED_TRACE(base::StringPrintf("Verify initial value for field %s", 204 field_cases[i].name)); 205 expected.form_control_type = field_cases[i].form_control_type; 206 expected.max_length = 207 expected.form_control_type == "text" ? 208 WebInputElement::defaultMaxLength() : 0; 209 expected.name = ASCIIToUTF16(field_cases[i].name); 210 expected.value = ASCIIToUTF16(field_cases[i].initial_value); 211 expected.autocomplete_attribute = field_cases[i].autocomplete_attribute; 212 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[i]); 213 // Fill the form_data for the field. 214 form_data.fields[i].value = ASCIIToUTF16(field_cases[i].autofill_value); 215 } 216 217 // Autofill the form using the given fill form function. 218 fill_form_function(form_data, input_element); 219 220 // Validate Autofill or Preview results. 221 for (size_t i = 0; i < number_of_field_cases; ++i) { 222 ValidteFilledField(field_cases[i], get_value_function); 223 } 224 } 225 226 // Validate an Autofilled field. 227 void ValidteFilledField(const AutofillFieldCase& field_case, 228 GetValueFunction get_value_function) { 229 SCOPED_TRACE(base::StringPrintf("Verify autofilled value for field %s", 230 field_case.name)); 231 WebString value; 232 WebFormControlElement element = GetMainFrame()->document().getElementById( 233 ASCIIToUTF16(field_case.name)).to<WebFormControlElement>(); 234 if (element.formControlType() == "select-one") { 235 value = element.to<WebSelectElement>().value(); 236 } else if (element.formControlType() == "textarea") { 237 value = element.to<WebTextAreaElement>().value(); 238 } else { 239 ASSERT_TRUE(element.formControlType() == "text" || 240 element.formControlType() == "month"); 241 WebInputElement input_element = GetMainFrame()->document().getElementById( 242 ASCIIToUTF16(field_case.name)).to<WebInputElement>(); 243 value = (input_element.*get_value_function)(); 244 } 245 246 const WebString expected_value = ASCIIToUTF16(field_case.expected_value); 247 if (expected_value.isEmpty()) 248 EXPECT_TRUE(value.isEmpty()); 249 else 250 EXPECT_EQ(expected_value, value); 251 252 EXPECT_EQ(field_case.should_be_autofilled, element.isAutofilled()); 253 } 254 255 static void FillFormForAllFieldsWrapper(const FormData& form, 256 const WebInputElement& element) { 257 FillFormForAllElements(form, element.form()); 258 } 259 260 static void FillFormIncludingNonFocusableElementsWrapper( 261 const FormData& form, 262 const WebInputElement& element) { 263 FillFormIncludingNonFocusableElements(form, element.form()); 264 } 265 266 private: 267 DISALLOW_COPY_AND_ASSIGN(FormAutofillTest); 268 }; 269 270 // We should be able to extract a normal text field. 271 TEST_F(FormAutofillTest, WebFormControlElementToFormField) { 272 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"/>"); 273 274 WebFrame* frame = GetMainFrame(); 275 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 276 277 WebElement web_element = frame->document().getElementById("element"); 278 WebFormControlElement element = web_element.to<WebFormControlElement>(); 279 FormFieldData result1; 280 WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result1); 281 282 FormFieldData expected; 283 expected.form_control_type = "text"; 284 expected.max_length = WebInputElement::defaultMaxLength(); 285 286 expected.name = ASCIIToUTF16("element"); 287 expected.value = base::string16(); 288 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1); 289 290 FormFieldData result2; 291 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result2); 292 293 expected.name = ASCIIToUTF16("element"); 294 expected.value = ASCIIToUTF16("value"); 295 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result2); 296 } 297 298 // We should be able to extract a text field with autocomplete="off". 299 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutocompleteOff) { 300 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"" 301 " autocomplete=\"off\"/>"); 302 303 WebFrame* frame = GetMainFrame(); 304 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 305 306 WebElement web_element = frame->document().getElementById("element"); 307 WebFormControlElement element = web_element.to<WebFormControlElement>(); 308 FormFieldData result; 309 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result); 310 311 FormFieldData expected; 312 expected.name = ASCIIToUTF16("element"); 313 expected.value = ASCIIToUTF16("value"); 314 expected.form_control_type = "text"; 315 expected.autocomplete_attribute = "off"; 316 expected.max_length = WebInputElement::defaultMaxLength(); 317 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result); 318 } 319 320 // We should be able to extract a text field with maxlength specified. 321 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldMaxLength) { 322 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"" 323 " maxlength=\"5\"/>"); 324 325 WebFrame* frame = GetMainFrame(); 326 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 327 328 WebElement web_element = frame->document().getElementById("element"); 329 WebFormControlElement element = web_element.to<WebFormControlElement>(); 330 FormFieldData result; 331 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result); 332 333 FormFieldData expected; 334 expected.name = ASCIIToUTF16("element"); 335 expected.value = ASCIIToUTF16("value"); 336 expected.form_control_type = "text"; 337 expected.max_length = 5; 338 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result); 339 } 340 341 // We should be able to extract a text field that has been autofilled. 342 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutofilled) { 343 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"/>"); 344 345 WebFrame* frame = GetMainFrame(); 346 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 347 348 WebElement web_element = frame->document().getElementById("element"); 349 WebInputElement element = web_element.to<WebInputElement>(); 350 element.setAutofilled(true); 351 FormFieldData result; 352 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result); 353 354 FormFieldData expected; 355 expected.name = ASCIIToUTF16("element"); 356 expected.value = ASCIIToUTF16("value"); 357 expected.form_control_type = "text"; 358 expected.max_length = WebInputElement::defaultMaxLength(); 359 expected.is_autofilled = true; 360 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result); 361 } 362 363 // We should be able to extract a radio or a checkbox field that has been 364 // autofilled. 365 TEST_F(FormAutofillTest, WebFormControlElementToClickableFormField) { 366 LoadHTML("<INPUT type=\"checkbox\" id=\"checkbox\" value=\"mail\" checked/>" 367 "<INPUT type=\"radio\" id=\"radio\" value=\"male\"/>"); 368 369 WebFrame* frame = GetMainFrame(); 370 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 371 372 WebElement web_element = frame->document().getElementById("checkbox"); 373 WebInputElement element = web_element.to<WebInputElement>(); 374 element.setAutofilled(true); 375 FormFieldData result; 376 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result); 377 378 FormFieldData expected; 379 expected.name = ASCIIToUTF16("checkbox"); 380 expected.value = ASCIIToUTF16("mail"); 381 expected.form_control_type = "checkbox"; 382 expected.is_autofilled = true; 383 expected.is_checkable = true; 384 expected.is_checked = true; 385 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result); 386 387 web_element = frame->document().getElementById("radio"); 388 element = web_element.to<WebInputElement>(); 389 element.setAutofilled(true); 390 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result); 391 expected.name = ASCIIToUTF16("radio"); 392 expected.value = ASCIIToUTF16("male"); 393 expected.form_control_type = "radio"; 394 expected.is_autofilled = true; 395 expected.is_checkable = true; 396 expected.is_checked = false; 397 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result); 398 } 399 400 // We should be able to extract a <select> field. 401 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldSelect) { 402 LoadHTML("<SELECT id=\"element\"/>" 403 " <OPTION value=\"CA\">California</OPTION>" 404 " <OPTION value=\"TX\">Texas</OPTION>" 405 "</SELECT>"); 406 407 WebFrame* frame = GetMainFrame(); 408 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 409 410 WebElement web_element = frame->document().getElementById("element"); 411 WebFormControlElement element = web_element.to<WebFormControlElement>(); 412 FormFieldData result1; 413 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result1); 414 415 FormFieldData expected; 416 expected.name = ASCIIToUTF16("element"); 417 expected.max_length = 0; 418 expected.form_control_type = "select-one"; 419 420 expected.value = ASCIIToUTF16("CA"); 421 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1); 422 423 FormFieldData result2; 424 WebFormControlElementToFormField( 425 element, 426 static_cast<autofill::ExtractMask>(autofill::EXTRACT_VALUE | 427 autofill::EXTRACT_OPTION_TEXT), 428 &result2); 429 expected.value = ASCIIToUTF16("California"); 430 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result2); 431 432 FormFieldData result3; 433 WebFormControlElementToFormField(element, autofill::EXTRACT_OPTIONS, 434 &result3); 435 expected.value = base::string16(); 436 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result3); 437 438 ASSERT_EQ(2U, result3.option_values.size()); 439 ASSERT_EQ(2U, result3.option_contents.size()); 440 EXPECT_EQ(ASCIIToUTF16("CA"), result3.option_values[0]); 441 EXPECT_EQ(ASCIIToUTF16("California"), result3.option_contents[0]); 442 EXPECT_EQ(ASCIIToUTF16("TX"), result3.option_values[1]); 443 EXPECT_EQ(ASCIIToUTF16("Texas"), result3.option_contents[1]); 444 } 445 446 // We should be able to extract a <textarea> field. 447 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldTextArea) { 448 LoadHTML("<TEXTAREA id=\"element\">" 449 "This element's value " 450 "spans multiple lines." 451 "</TEXTAREA>"); 452 453 WebFrame* frame = GetMainFrame(); 454 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 455 456 WebElement web_element = frame->document().getElementById("element"); 457 WebFormControlElement element = web_element.to<WebFormControlElement>(); 458 FormFieldData result_sans_value; 459 WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, 460 &result_sans_value); 461 462 FormFieldData expected; 463 expected.name = ASCIIToUTF16("element"); 464 expected.max_length = 0; 465 expected.form_control_type = "textarea"; 466 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_sans_value); 467 468 FormFieldData result_with_value; 469 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, 470 &result_with_value); 471 expected.value = ASCIIToUTF16("This element's value\n" 472 "spans multiple lines."); 473 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_with_value); 474 } 475 476 // We should be able to extract an <input type="month"> field. 477 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldMonthInput) { 478 LoadHTML("<INPUT type=\"month\" id=\"element\" value=\"2011-12\">"); 479 480 WebFrame* frame = GetMainFrame(); 481 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 482 483 WebElement web_element = frame->document().getElementById("element"); 484 WebFormControlElement element = web_element.to<WebFormControlElement>(); 485 FormFieldData result_sans_value; 486 WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, 487 &result_sans_value); 488 489 FormFieldData expected; 490 expected.name = ASCIIToUTF16("element"); 491 expected.max_length = 0; 492 expected.form_control_type = "month"; 493 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_sans_value); 494 495 FormFieldData result_with_value; 496 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, 497 &result_with_value); 498 expected.value = ASCIIToUTF16("2011-12"); 499 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_with_value); 500 } 501 502 // We should not extract the value for non-text and non-select fields. 503 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldInvalidType) { 504 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 505 " <INPUT type=\"hidden\" id=\"hidden\" value=\"apple\"/>" 506 " <INPUT type=\"submit\" id=\"submit\" value=\"Send\"/>" 507 "</FORM>"); 508 509 WebFrame* frame = GetMainFrame(); 510 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 511 512 WebElement web_element = frame->document().getElementById("hidden"); 513 WebFormControlElement element = web_element.to<WebFormControlElement>(); 514 FormFieldData result; 515 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result); 516 517 FormFieldData expected; 518 expected.max_length = 0; 519 520 expected.name = ASCIIToUTF16("hidden"); 521 expected.form_control_type = "hidden"; 522 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result); 523 524 web_element = frame->document().getElementById("submit"); 525 element = web_element.to<WebFormControlElement>(); 526 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result); 527 expected.name = ASCIIToUTF16("submit"); 528 expected.form_control_type = "submit"; 529 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result); 530 } 531 532 // We should be able to extract password fields. 533 TEST_F(FormAutofillTest, WebFormControlElementToPasswordFormField) { 534 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 535 " <INPUT type=\"password\" id=\"password\" value=\"secret\"/>" 536 "</FORM>"); 537 538 WebFrame* frame = GetMainFrame(); 539 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 540 541 WebElement web_element = frame->document().getElementById("password"); 542 WebFormControlElement element = web_element.to<WebFormControlElement>(); 543 FormFieldData result; 544 WebFormControlElementToFormField(element, autofill::EXTRACT_VALUE, &result); 545 546 FormFieldData expected; 547 expected.max_length = WebInputElement::defaultMaxLength(); 548 expected.name = ASCIIToUTF16("password"); 549 expected.form_control_type = "password"; 550 expected.value = ASCIIToUTF16("secret"); 551 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result); 552 } 553 554 // We should be able to extract the autocompletetype attribute. 555 TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutocompletetype) { 556 std::string html = 557 "<INPUT type=\"text\" id=\"absent\"/>" 558 "<INPUT type=\"text\" id=\"empty\" autocomplete=\"\"/>" 559 "<INPUT type=\"text\" id=\"off\" autocomplete=\"off\"/>" 560 "<INPUT type=\"text\" id=\"regular\" autocomplete=\"email\"/>" 561 "<INPUT type=\"text\" id=\"multi-valued\" " 562 " autocomplete=\"billing email\"/>" 563 "<INPUT type=\"text\" id=\"experimental\" x-autocompletetype=\"email\"/>" 564 "<INPUT type=\"month\" id=\"month\" autocomplete=\"cc-exp\"/>" 565 "<SELECT id=\"select\" autocomplete=\"state\"/>" 566 " <OPTION value=\"CA\">California</OPTION>" 567 " <OPTION value=\"TX\">Texas</OPTION>" 568 "</SELECT>" 569 "<TEXTAREA id=\"textarea\" autocomplete=\"street-address\">" 570 " Some multi-" 571 " lined value" 572 "</TEXTAREA>"; 573 html += 574 "<INPUT type=\"text\" id=\"malicious\" autocomplete=\"" + 575 std::string(10000, 'x') + "\"/>"; 576 LoadHTML(html.c_str()); 577 578 WebFrame* frame = GetMainFrame(); 579 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 580 581 struct TestCase { 582 const std::string element_id; 583 const std::string form_control_type; 584 const std::string autocomplete_attribute; 585 }; 586 TestCase test_cases[] = { 587 // An absent attribute is equivalent to an empty one. 588 { "absent", "text", "" }, 589 // Make sure there are no issues parsing an empty attribute. 590 { "empty", "text", "" }, 591 // Make sure there are no issues parsing an attribute value that isn't a 592 // type hint. 593 { "off", "text", "off" }, 594 // Common case: exactly one type specified. 595 { "regular", "text", "email" }, 596 // Verify that we correctly extract multiple tokens as well. 597 { "multi-valued", "text", "billing email" }, 598 // Verify that <input type="month"> fields are supported. 599 { "month", "month", "cc-exp" }, 600 // We previously extracted this data from the experimental 601 // 'x-autocompletetype' attribute. Now that the field type hints are part 602 // of the spec under the autocomplete attribute, we no longer support the 603 // experimental version. 604 { "experimental", "text", "" }, 605 // <select> elements should behave no differently from text fields here. 606 { "select", "select-one", "state" }, 607 // <textarea> elements should also behave no differently from text fields. 608 { "textarea", "textarea", "street-address" }, 609 // Very long attribute values should be replaced by a default string, to 610 // prevent malicious websites from DOSing the browser process. 611 { "malicious", "text", "x-max-data-length-exceeded" }, 612 }; 613 614 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) { 615 WebElement web_element = frame->document().getElementById( 616 ASCIIToUTF16(test_cases[i].element_id)); 617 WebFormControlElement element = web_element.to<WebFormControlElement>(); 618 FormFieldData result; 619 WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result); 620 621 FormFieldData expected; 622 expected.name = ASCIIToUTF16(test_cases[i].element_id); 623 expected.form_control_type = test_cases[i].form_control_type; 624 expected.autocomplete_attribute = test_cases[i].autocomplete_attribute; 625 if (test_cases[i].form_control_type == "text") 626 expected.max_length = WebInputElement::defaultMaxLength(); 627 else 628 expected.max_length = 0; 629 630 SCOPED_TRACE(test_cases[i].element_id); 631 EXPECT_FORM_FIELD_DATA_EQUALS(expected, result); 632 } 633 } 634 635 TEST_F(FormAutofillTest, WebFormElementToFormData) { 636 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 637 " <LABEL for=\"firstname\">First name:</LABEL>" 638 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 639 " <LABEL for=\"lastname\">Last name:</LABEL>" 640 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 641 " <LABEL for=\"street-address\">Address:</LABEL>" 642 " <TEXTAREA id=\"street-address\">" 643 "123 Fantasy Ln. " 644 "Apt. 42" 645 "</TEXTAREA>" 646 " <LABEL for=\"state\">State:</LABEL>" 647 " <SELECT id=\"state\"/>" 648 " <OPTION value=\"CA\">California</OPTION>" 649 " <OPTION value=\"TX\">Texas</OPTION>" 650 " </SELECT>" 651 " <LABEL for=\"password\">Password:</LABEL>" 652 " <INPUT type=\"password\" id=\"password\" value=\"secret\"/>" 653 " <LABEL for=\"month\">Card expiration:</LABEL>" 654 " <INPUT type=\"month\" id=\"month\" value=\"2011-12\"/>" 655 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 656 // The below inputs should be ignored 657 " <LABEL for=\"notvisible\">Hidden:</LABEL>" 658 " <INPUT type=\"hidden\" id=\"notvisible\" value=\"apple\"/>" 659 "</FORM>"); 660 661 WebFrame* frame = GetMainFrame(); 662 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 663 664 WebVector<WebFormElement> forms; 665 frame->document().forms(forms); 666 ASSERT_EQ(1U, forms.size()); 667 668 WebElement element = frame->document().getElementById("firstname"); 669 WebInputElement input_element = element.to<WebInputElement>(); 670 671 FormData form; 672 FormFieldData field; 673 EXPECT_TRUE(WebFormElementToFormData(forms[0], 674 input_element, 675 autofill::REQUIRE_NONE, 676 autofill::EXTRACT_VALUE, 677 &form, 678 &field)); 679 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 680 EXPECT_EQ(GURL(frame->document().url()), form.origin); 681 EXPECT_EQ(GURL("http://cnn.com"), form.action); 682 683 const std::vector<FormFieldData>& fields = form.fields; 684 ASSERT_EQ(6U, fields.size()); 685 686 FormFieldData expected; 687 expected.name = ASCIIToUTF16("firstname"); 688 expected.value = ASCIIToUTF16("John"); 689 expected.label = ASCIIToUTF16("First name:"); 690 expected.form_control_type = "text"; 691 expected.max_length = WebInputElement::defaultMaxLength(); 692 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 693 694 expected.name = ASCIIToUTF16("lastname"); 695 expected.value = ASCIIToUTF16("Smith"); 696 expected.label = ASCIIToUTF16("Last name:"); 697 expected.form_control_type = "text"; 698 expected.max_length = WebInputElement::defaultMaxLength(); 699 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 700 701 expected.name = ASCIIToUTF16("street-address"); 702 expected.value = ASCIIToUTF16("123 Fantasy Ln.\nApt. 42"); 703 expected.label = ASCIIToUTF16("Address:"); 704 expected.form_control_type = "textarea"; 705 expected.max_length = 0; 706 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 707 708 expected.name = ASCIIToUTF16("state"); 709 expected.value = ASCIIToUTF16("CA"); 710 expected.label = ASCIIToUTF16("State:"); 711 expected.form_control_type = "select-one"; 712 expected.max_length = 0; 713 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]); 714 715 expected.name = ASCIIToUTF16("password"); 716 expected.value = ASCIIToUTF16("secret"); 717 expected.label = ASCIIToUTF16("Password:"); 718 expected.form_control_type = "password"; 719 expected.max_length = WebInputElement::defaultMaxLength(); 720 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[4]); 721 722 expected.name = ASCIIToUTF16("month"); 723 expected.value = ASCIIToUTF16("2011-12"); 724 expected.label = ASCIIToUTF16("Card expiration:"); 725 expected.form_control_type = "month"; 726 expected.max_length = 0; 727 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[5]); 728 } 729 730 // We should not be able to serialize a form with too many fillable fields. 731 TEST_F(FormAutofillTest, WebFormElementToFormDataTooManyFields) { 732 std::string html = 733 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"; 734 for (size_t i = 0; i < (autofill::kMaxParseableFields + 1); ++i) { 735 html += "<INPUT type=\"text\"/>"; 736 } 737 html += "</FORM>"; 738 LoadHTML(html.c_str()); 739 740 WebFrame* frame = GetMainFrame(); 741 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 742 743 WebVector<WebFormElement> forms; 744 frame->document().forms(forms); 745 ASSERT_EQ(1U, forms.size()); 746 747 WebElement element = frame->document().getElementById("firstname"); 748 WebInputElement input_element = element.to<WebInputElement>(); 749 750 FormData form; 751 FormFieldData field; 752 EXPECT_FALSE(WebFormElementToFormData(forms[0], 753 input_element, 754 autofill::REQUIRE_NONE, 755 autofill::EXTRACT_VALUE, 756 &form, 757 &field)); 758 } 759 760 TEST_F(FormAutofillTest, ExtractForms) { 761 ExpectJohnSmithLabels( 762 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 763 " First name: <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 764 " Last name: <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 765 " Email: <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 766 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 767 "</FORM>"); 768 } 769 770 TEST_F(FormAutofillTest, ExtractMultipleForms) { 771 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 772 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 773 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 774 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 775 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 776 "</FORM>" 777 "<FORM name=\"TestForm2\" action=\"http://zoo.com\" method=\"post\">" 778 " <INPUT type=\"text\" id=\"firstname\" value=\"Jack\"/>" 779 " <INPUT type=\"text\" id=\"lastname\" value=\"Adams\"/>" 780 " <INPUT type=\"text\" id=\"email\" value=\"jack (at) example.com\"/>" 781 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 782 "</FORM>"); 783 784 WebFrame* web_frame = GetMainFrame(); 785 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 786 787 FormCache form_cache; 788 std::vector<FormData> forms; 789 form_cache.ExtractForms(*web_frame, &forms); 790 ASSERT_EQ(2U, forms.size()); 791 792 // First form. 793 const FormData& form = forms[0]; 794 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 795 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 796 EXPECT_EQ(GURL("http://cnn.com"), form.action); 797 798 const std::vector<FormFieldData>& fields = form.fields; 799 ASSERT_EQ(3U, fields.size()); 800 801 FormFieldData expected; 802 expected.form_control_type = "text"; 803 expected.max_length = WebInputElement::defaultMaxLength(); 804 805 expected.name = ASCIIToUTF16("firstname"); 806 expected.value = ASCIIToUTF16("John"); 807 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 808 809 expected.name = ASCIIToUTF16("lastname"); 810 expected.value = ASCIIToUTF16("Smith"); 811 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 812 813 expected.name = ASCIIToUTF16("email"); 814 expected.value = ASCIIToUTF16("john (at) example.com"); 815 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 816 817 // Second form. 818 const FormData& form2 = forms[1]; 819 EXPECT_EQ(ASCIIToUTF16("TestForm2"), form2.name); 820 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 821 EXPECT_EQ(GURL("http://zoo.com"), form2.action); 822 823 const std::vector<FormFieldData>& fields2 = form2.fields; 824 ASSERT_EQ(3U, fields2.size()); 825 826 expected.name = ASCIIToUTF16("firstname"); 827 expected.value = ASCIIToUTF16("Jack"); 828 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]); 829 830 expected.name = ASCIIToUTF16("lastname"); 831 expected.value = ASCIIToUTF16("Adams"); 832 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]); 833 834 expected.name = ASCIIToUTF16("email"); 835 expected.value = ASCIIToUTF16("jack (at) example.com"); 836 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]); 837 } 838 839 // We should not extract a form if it has too few fillable fields. 840 TEST_F(FormAutofillTest, ExtractFormsTooFewFields) { 841 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 842 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 843 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 844 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 845 "</FORM>"); 846 847 WebFrame* web_frame = GetMainFrame(); 848 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 849 850 FormCache form_cache; 851 std::vector<FormData> forms; 852 form_cache.ExtractForms(*web_frame, &forms); 853 EXPECT_EQ(0U, forms.size()); 854 } 855 856 // We should not report additional forms for empty forms. 857 TEST_F(FormAutofillTest, ExtractFormsSkippedForms) { 858 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 859 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 860 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 861 "</FORM>"); 862 863 WebFrame* web_frame = GetMainFrame(); 864 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 865 866 FormCache form_cache; 867 std::vector<FormData> forms; 868 bool has_skipped_forms = form_cache.ExtractFormsAndFormElements(*web_frame, 869 3, 870 &forms, 871 NULL); 872 EXPECT_EQ(0U, forms.size()); 873 EXPECT_TRUE(has_skipped_forms); 874 } 875 876 // We should not report additional forms for empty forms. 877 TEST_F(FormAutofillTest, ExtractFormsNoFields) { 878 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 879 "</FORM>"); 880 881 WebFrame* web_frame = GetMainFrame(); 882 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 883 884 FormCache form_cache; 885 std::vector<FormData> forms; 886 bool has_skipped_forms = form_cache.ExtractFormsAndFormElements(*web_frame, 887 3, 888 &forms, 889 NULL); 890 EXPECT_EQ(0U, forms.size()); 891 EXPECT_FALSE(has_skipped_forms); 892 } 893 894 // We should not extract a form if it has too few fillable fields. 895 // Make sure radio and checkbox fields don't count. 896 TEST_F(FormAutofillTest, ExtractFormsTooFewFieldsSkipsCheckable) { 897 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 898 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 899 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 900 " <INPUT type=\"radio\" id=\"a_radio\" value=\"0\"/>" 901 " <INPUT type=\"checkbox\" id=\"a_check\" value=\"1\"/>" 902 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 903 "</FORM>"); 904 905 WebFrame* web_frame = GetMainFrame(); 906 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 907 908 FormCache form_cache; 909 std::vector<FormData> forms; 910 form_cache.ExtractForms(*web_frame, &forms); 911 EXPECT_EQ(0U, forms.size()); 912 } 913 914 TEST_F(FormAutofillTest, WebFormElementToFormDataAutocomplete) { 915 { 916 // Form is not auto-completable due to autocomplete=off. 917 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\"" 918 " autocomplete=off>" 919 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 920 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 921 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 922 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 923 "</FORM>"); 924 925 WebFrame* web_frame = GetMainFrame(); 926 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 927 928 WebVector<WebFormElement> web_forms; 929 web_frame->document().forms(web_forms); 930 ASSERT_EQ(1U, web_forms.size()); 931 WebFormElement web_form = web_forms[0]; 932 933 FormData form; 934 EXPECT_TRUE(WebFormElementToFormData( 935 web_form, WebFormControlElement(), autofill::REQUIRE_NONE, 936 autofill::EXTRACT_NONE, &form, NULL)); 937 EXPECT_FALSE(WebFormElementToFormData( 938 web_form, WebFormControlElement(), autofill::REQUIRE_AUTOCOMPLETE, 939 autofill::EXTRACT_NONE, &form, NULL)); 940 } 941 942 { 943 // The firstname element is not auto-completable due to autocomplete=off. 944 LoadHTML("<FORM name=\"TestForm\" action=\"http://abc.com\" " 945 " method=\"post\">" 946 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"" 947 " autocomplete=off>" 948 " <INPUT type=\"text\" id=\"middlename\" value=\"Jack\"/>" 949 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 950 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 951 " <INPUT type=\"submit\" name=\"reply\" value=\"Send\"/>" 952 "</FORM>"); 953 954 WebFrame* web_frame = GetMainFrame(); 955 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 956 957 WebVector<WebFormElement> web_forms; 958 web_frame->document().forms(web_forms); 959 ASSERT_EQ(1U, web_forms.size()); 960 WebFormElement web_form = web_forms[0]; 961 962 FormData form; 963 EXPECT_TRUE(WebFormElementToFormData( 964 web_form, WebFormControlElement(), autofill::REQUIRE_AUTOCOMPLETE, 965 autofill::EXTRACT_VALUE, &form, NULL)); 966 967 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 968 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 969 EXPECT_EQ(GURL("http://abc.com"), form.action); 970 971 const std::vector<FormFieldData>& fields = form.fields; 972 ASSERT_EQ(3U, fields.size()); 973 974 FormFieldData expected; 975 expected.form_control_type = "text"; 976 expected.max_length = WebInputElement::defaultMaxLength(); 977 978 expected.name = ASCIIToUTF16("middlename"); 979 expected.value = ASCIIToUTF16("Jack"); 980 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 981 982 expected.name = ASCIIToUTF16("lastname"); 983 expected.value = ASCIIToUTF16("Smith"); 984 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 985 986 expected.name = ASCIIToUTF16("email"); 987 expected.value = ASCIIToUTF16("john (at) example.com"); 988 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 989 } 990 } 991 992 TEST_F(FormAutofillTest, FindForm) { 993 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 994 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 995 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 996 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"" 997 "autocomplete=\"off\" />" 998 " <INPUT type=\"text\" id=\"phone\" value=\"1.800.555.1234\"/>" 999 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1000 "</FORM>"); 1001 1002 WebFrame* web_frame = GetMainFrame(); 1003 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 1004 1005 FormCache form_cache; 1006 std::vector<FormData> forms; 1007 form_cache.ExtractForms(*web_frame, &forms); 1008 ASSERT_EQ(1U, forms.size()); 1009 1010 // Get the input element we want to find. 1011 WebElement element = web_frame->document().getElementById("firstname"); 1012 WebInputElement input_element = element.to<WebInputElement>(); 1013 1014 // Find the form and verify it's the correct form. 1015 FormData form; 1016 FormFieldData field; 1017 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form, &field, 1018 autofill::REQUIRE_NONE)); 1019 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 1020 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 1021 EXPECT_EQ(GURL("http://buh.com"), form.action); 1022 1023 const std::vector<FormFieldData>& fields = form.fields; 1024 ASSERT_EQ(4U, fields.size()); 1025 1026 FormFieldData expected; 1027 expected.form_control_type = "text"; 1028 expected.max_length = WebInputElement::defaultMaxLength(); 1029 1030 expected.name = ASCIIToUTF16("firstname"); 1031 expected.value = ASCIIToUTF16("John"); 1032 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 1033 EXPECT_FORM_FIELD_DATA_EQUALS(expected, field); 1034 1035 expected.name = ASCIIToUTF16("lastname"); 1036 expected.value = ASCIIToUTF16("Smith"); 1037 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 1038 1039 expected.name = ASCIIToUTF16("email"); 1040 expected.value = ASCIIToUTF16("john (at) example.com"); 1041 expected.autocomplete_attribute = "off"; 1042 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 1043 expected.autocomplete_attribute = std::string(); // reset 1044 1045 expected.name = ASCIIToUTF16("phone"); 1046 expected.value = ASCIIToUTF16("1.800.555.1234"); 1047 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]); 1048 1049 // Try again, but require autocomplete. 1050 FormData form2; 1051 FormFieldData field2; 1052 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form2, &field2, 1053 autofill::REQUIRE_AUTOCOMPLETE)); 1054 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 1055 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 1056 EXPECT_EQ(GURL("http://buh.com"), form2.action); 1057 1058 const std::vector<FormFieldData>& fields2 = form2.fields; 1059 ASSERT_EQ(3U, fields2.size()); 1060 1061 expected.form_control_type = "text"; 1062 expected.max_length = WebInputElement::defaultMaxLength(); 1063 1064 expected.name = ASCIIToUTF16("firstname"); 1065 expected.value = ASCIIToUTF16("John"); 1066 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]); 1067 EXPECT_FORM_FIELD_DATA_EQUALS(expected, field); 1068 1069 expected.name = ASCIIToUTF16("lastname"); 1070 expected.value = ASCIIToUTF16("Smith"); 1071 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]); 1072 1073 expected.name = ASCIIToUTF16("phone"); 1074 expected.value = ASCIIToUTF16("1.800.555.1234"); 1075 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]); 1076 } 1077 1078 // Test regular FillForm function. 1079 TEST_F(FormAutofillTest, FillForm) { 1080 static const AutofillFieldCase field_cases[] = { 1081 // fields: form_control_type, name, initial_value, autocomplete_attribute, 1082 // should_be_autofilled, autofill_value, expected_value 1083 1084 // Regular empty fields (firstname & lastname) should be autofilled. 1085 {"text", "firstname", "", "", true, "filled firstname", 1086 "filled firstname"}, 1087 {"text", "lastname", "", "", true, "filled lastname", "filled lastname"}, 1088 // hidden fields should not be extracted to form_data. 1089 // Non empty fields should not be autofilled. 1090 {"text", "notempty", "Hi", "", false, "filled notempty", "Hi"}, 1091 // "noautocomplete" should not be extracted to form_data. 1092 // Disabled fields should not be autofilled. 1093 {"text", "notenabled", "", "", false, "filled notenabled", ""}, 1094 // Readonly fields should not be autofilled. 1095 {"text", "readonly", "", "", false, "filled readonly", ""}, 1096 // Fields with "visibility: hidden" should not be autofilled. 1097 {"text", "invisible", "", "", false, "filled invisible", ""}, 1098 // Fields with "display:none" should not be autofilled. 1099 {"text", "displaynone", "", "", false, "filled displaynone", ""}, 1100 // Regular <input type="month"> should be autofilled. 1101 {"month", "month", "", "", true, "2017-11", "2017-11"}, 1102 // Non-empty <input type="month"> should not be autofilled. 1103 {"month", "month-nonempty", "2011-12", "", false, "2017-11", "2011-12"}, 1104 // Regular select fields should be autofilled. 1105 {"select-one", "select", "", "", true, "TX", "TX"}, 1106 // Select fields should be autofilled even if they already have a 1107 // non-empty value. 1108 {"select-one", "select-nonempty", "CA", "", true, "TX", "TX"}, 1109 // Regular textarea elements should be autofilled. 1110 {"textarea", "textarea", "", "", true, "some multi-\nline value", 1111 "some multi-\nline value"}, 1112 // Non-empty textarea elements should not be autofilled. 1113 {"textarea", "textarea-nonempty", "Go\naway!", "", false, 1114 "some multi-\nline value", "Go\naway!"}, 1115 }; 1116 TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases), 1117 FillForm, &WebInputElement::value); 1118 // Verify preview selection. 1119 WebInputElement firstname = GetMainFrame()->document(). 1120 getElementById("firstname").to<WebInputElement>(); 1121 EXPECT_EQ(16, firstname.selectionStart()); 1122 EXPECT_EQ(16, firstname.selectionEnd()); 1123 } 1124 1125 TEST_F(FormAutofillTest, FillFormIncludingNonFocusableElements) { 1126 static const AutofillFieldCase field_cases[] = { 1127 // fields: form_control_type, name, initial_value, autocomplete_attribute, 1128 // should_be_autofilled, autofill_value, expected_value 1129 1130 // Regular empty fields (firstname & lastname) should be autofilled. 1131 {"text", "firstname", "", "", true, "filled firstname", 1132 "filled firstname"}, 1133 {"text", "lastname", "", "", true, "filled lastname", "filled lastname"}, 1134 // hidden fields should not be extracted to form_data. 1135 // Non empty fields should be overriden. 1136 {"text", "notempty", "Hi", "", true, "filled notempty", 1137 "filled notempty"}, 1138 // "noautocomplete" should not be extracted to form_data. 1139 // Disabled fields should not be autofilled. 1140 {"text", "notenabled", "", "", false, "filled notenabled", ""}, 1141 // Readonly fields should not be autofilled. 1142 {"text", "readonly", "", "", false, "filled readonly", ""}, 1143 // Fields with "visibility: hidden" should also be autofilled. 1144 {"text", "invisible", "", "", true, "filled invisible", 1145 "filled invisible"}, 1146 // Fields with "display:none" should also be autofilled. 1147 {"text", "displaynone", "", "", true, "filled displaynone", 1148 "filled displaynone"}, 1149 // Regular <input type="month"> should be autofilled. 1150 {"month", "month", "", "", true, "2017-11", "2017-11"}, 1151 // Non-empty <input type="month"> should be overridden. 1152 {"month", "month-nonempty", "2011-12", "", true, "2017-11", "2017-11"}, 1153 // Regular select fields should be autofilled. 1154 {"select-one", "select", "", "", true, "TX", "TX"}, 1155 // Select fields should be autofilled even if they already have a 1156 // non-empty value. 1157 {"select-one", "select-nonempty", "CA", "", true, "TX", "TX"}, 1158 // Regular textarea elements should be autofilled. 1159 {"textarea", "textarea", "", "", true, "some multi-\nline value", 1160 "some multi-\nline value"}, 1161 // Nonempty textarea elements should be overridden. 1162 {"textarea", "textarea-nonempty", "Go\naway!", "", true, 1163 "some multi-\nline value", "some multi-\nline value"}, 1164 }; 1165 TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases), 1166 &FillFormIncludingNonFocusableElementsWrapper, 1167 &WebInputElement::value); 1168 } 1169 1170 TEST_F(FormAutofillTest, PreviewForm) { 1171 static const char* html = 1172 "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 1173 " <INPUT type=\"text\" id=\"firstname\"/>" 1174 " <INPUT type=\"text\" id=\"lastname\"/>" 1175 " <INPUT type=\"text\" id=\"notempty\" value=\"Hi\"/>" 1176 " <INPUT type=\"text\" autocomplete=\"off\" id=\"noautocomplete\"/>" 1177 " <INPUT type=\"text\" disabled=\"disabled\" id=\"notenabled\"/>" 1178 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1179 "</FORM>"; 1180 1181 static const AutofillFieldCase field_cases[] = { 1182 // Normal empty fields should be previewed. 1183 {"text", "firstname", "", "", true, "suggested firstname", 1184 "suggested firstname"}, 1185 {"text", "lastname", "", "", true, "suggested lastname", 1186 "suggested lastname"}, 1187 // Non empty fields should not be previewed. 1188 {"text", "notempty", "Hi", "", false, "filled notempty", ""}, 1189 // "noautocomplete" should not be extracted to form_data. 1190 // Disabled fields should not be previewed. 1191 {"text", "notenabled", "", "", false, "filled notenabled", ""}, 1192 }; 1193 TestFormFillFunctions(html, field_cases, arraysize(field_cases), &PreviewForm, 1194 &WebInputElement::suggestedValue); 1195 1196 // Verify preview selection. 1197 WebInputElement firstname = GetMainFrame()->document(). 1198 getElementById("firstname").to<WebInputElement>(); 1199 EXPECT_EQ(0, firstname.selectionStart()); 1200 EXPECT_EQ(19, firstname.selectionEnd()); 1201 } 1202 1203 TEST_F(FormAutofillTest, Labels) { 1204 ExpectJohnSmithLabels( 1205 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1206 " <LABEL for=\"firstname\"> First name: </LABEL>" 1207 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1208 " <LABEL for=\"lastname\"> Last name: </LABEL>" 1209 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1210 " <LABEL for=\"email\"> Email: </LABEL>" 1211 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1212 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1213 "</FORM>"); 1214 } 1215 1216 TEST_F(FormAutofillTest, LabelsWithSpans) { 1217 ExpectJohnSmithLabels( 1218 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1219 " <LABEL for=\"firstname\"><span>First name: </span></LABEL>" 1220 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1221 " <LABEL for=\"lastname\"><span>Last name: </span></LABEL>" 1222 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1223 " <LABEL for=\"email\"><span>Email: </span></LABEL>" 1224 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1225 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1226 "</FORM>"); 1227 } 1228 1229 // This test is different from FormAutofillTest.Labels in that the label 1230 // elements for= attribute is set to the name of the form control element it is 1231 // a label for instead of the id of the form control element. This is invalid 1232 // because the for= attribute must be set to the id of the form control element; 1233 // however, current label parsing code will extract the text from the previous 1234 // label element and apply it to the following input field. 1235 TEST_F(FormAutofillTest, InvalidLabels) { 1236 ExpectJohnSmithLabels( 1237 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1238 " <LABEL for=\"firstname\"> First name: </LABEL>" 1239 " <INPUT type=\"text\" name=\"firstname\" value=\"John\"/>" 1240 " <LABEL for=\"lastname\"> Last name: </LABEL>" 1241 " <INPUT type=\"text\" name=\"lastname\" value=\"Smith\"/>" 1242 " <LABEL for=\"email\"> Email: </LABEL>" 1243 " <INPUT type=\"text\" name=\"email\" value=\"john (at) example.com\"/>" 1244 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1245 "</FORM>"); 1246 } 1247 1248 // This test has three form control elements, only one of which has a label 1249 // element associated with it. 1250 TEST_F(FormAutofillTest, OneLabelElement) { 1251 ExpectJohnSmithLabels( 1252 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1253 " First name:" 1254 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1255 " <LABEL for=\"lastname\">Last name: </LABEL>" 1256 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1257 " Email:" 1258 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1259 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1260 "</FORM>"); 1261 } 1262 1263 TEST_F(FormAutofillTest, LabelsInferredFromText) { 1264 ExpectJohnSmithLabels( 1265 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1266 " First name:" 1267 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1268 " Last name:" 1269 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1270 " Email:" 1271 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1272 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1273 "</FORM>"); 1274 } 1275 1276 TEST_F(FormAutofillTest, LabelsInferredFromParagraph) { 1277 ExpectJohnSmithLabels( 1278 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1279 " <P>First name:</P><INPUT type=\"text\" " 1280 " id=\"firstname\" value=\"John\"/>" 1281 " <P>Last name:</P>" 1282 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1283 " <P>Email:</P>" 1284 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1285 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1286 "</FORM>"); 1287 } 1288 1289 TEST_F(FormAutofillTest, LabelsInferredFromBold) { 1290 ExpectJohnSmithLabels( 1291 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1292 " <B>First name:</B><INPUT type=\"text\" " 1293 " id=\"firstname\" value=\"John\"/>" 1294 " <B>Last name:</B>" 1295 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1296 " <B>Email:</B>" 1297 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1298 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1299 "</FORM>"); 1300 } 1301 1302 TEST_F(FormAutofillTest, LabelsInferredPriorToImgOrBr) { 1303 ExpectJohnSmithLabels( 1304 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1305 " First name:<IMG/><INPUT type=\"text\" " 1306 " id=\"firstname\" value=\"John\"/>" 1307 " Last name:<IMG/>" 1308 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1309 " Email:<BR/>" 1310 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1311 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1312 "</FORM>"); 1313 } 1314 1315 TEST_F(FormAutofillTest, LabelsInferredFromTableCell) { 1316 ExpectJohnSmithLabels( 1317 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1318 "<TABLE>" 1319 " <TR>" 1320 " <TD>First name:</TD>" 1321 " <TD><INPUT type=\"text\" id=\"firstname\" value=\"John\"/></TD>" 1322 " </TR>" 1323 " <TR>" 1324 " <TD>Last name:</TD>" 1325 " <TD><INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/></TD>" 1326 " </TR>" 1327 " <TR>" 1328 " <TD>Email:</TD>" 1329 " <TD><INPUT type=\"text\" id=\"email\"" 1330 " value=\"john (at) example.com\"/></TD>" 1331 " </TR>" 1332 " <TR>" 1333 " <TD></TD>" 1334 " <TD>" 1335 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1336 " </TD>" 1337 " </TR>" 1338 "</TABLE>" 1339 "</FORM>"); 1340 } 1341 1342 TEST_F(FormAutofillTest, LabelsInferredFromTableCellTH) { 1343 ExpectJohnSmithLabels( 1344 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1345 "<TABLE>" 1346 " <TR>" 1347 " <TH>First name:</TH>" 1348 " <TD><INPUT type=\"text\" id=\"firstname\" value=\"John\"/></TD>" 1349 " </TR>" 1350 " <TR>" 1351 " <TH>Last name:</TH>" 1352 " <TD><INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/></TD>" 1353 " </TR>" 1354 " <TR>" 1355 " <TH>Email:</TH>" 1356 " <TD><INPUT type=\"text\" id=\"email\"" 1357 " value=\"john (at) example.com\"/></TD>" 1358 " </TR>" 1359 " <TR>" 1360 " <TD></TD>" 1361 " <TD>" 1362 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1363 " </TD>" 1364 " </TR>" 1365 "</TABLE>" 1366 "</FORM>"); 1367 } 1368 1369 TEST_F(FormAutofillTest, LabelsInferredFromTableCellNested) { 1370 std::vector<base::string16> labels, names, values; 1371 1372 labels.push_back(ASCIIToUTF16("First name: Bogus")); 1373 names.push_back(ASCIIToUTF16("firstname")); 1374 values.push_back(ASCIIToUTF16("John")); 1375 1376 labels.push_back(ASCIIToUTF16("Last name:")); 1377 names.push_back(ASCIIToUTF16("lastname")); 1378 values.push_back(ASCIIToUTF16("Smith")); 1379 1380 labels.push_back(ASCIIToUTF16("Email:")); 1381 names.push_back(ASCIIToUTF16("email")); 1382 values.push_back(ASCIIToUTF16("john (at) example.com")); 1383 1384 ExpectLabels( 1385 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1386 "<TABLE>" 1387 " <TR>" 1388 " <TD>" 1389 " <FONT>" 1390 " First name:" 1391 " </FONT>" 1392 " <FONT>" 1393 " Bogus" 1394 " </FONT>" 1395 " </TD>" 1396 " <TD>" 1397 " <FONT>" 1398 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1399 " </FONT>" 1400 " </TD>" 1401 " </TR>" 1402 " <TR>" 1403 " <TD>" 1404 " <FONT>" 1405 " Last name:" 1406 " </FONT>" 1407 " </TD>" 1408 " <TD>" 1409 " <FONT>" 1410 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1411 " </FONT>" 1412 " </TD>" 1413 " </TR>" 1414 " <TR>" 1415 " <TD>" 1416 " <FONT>" 1417 " Email:" 1418 " </FONT>" 1419 " </TD>" 1420 " <TD>" 1421 " <FONT>" 1422 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1423 " </FONT>" 1424 " </TD>" 1425 " </TR>" 1426 " <TR>" 1427 " <TD></TD>" 1428 " <TD>" 1429 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1430 " </TD>" 1431 " </TR>" 1432 "</TABLE>" 1433 "</FORM>", 1434 labels, names, values); 1435 } 1436 1437 TEST_F(FormAutofillTest, LabelsInferredFromTableEmptyTDs) { 1438 std::vector<base::string16> labels, names, values; 1439 1440 labels.push_back(ASCIIToUTF16("* First Name")); 1441 names.push_back(ASCIIToUTF16("firstname")); 1442 values.push_back(ASCIIToUTF16("John")); 1443 1444 labels.push_back(ASCIIToUTF16("* Last Name")); 1445 names.push_back(ASCIIToUTF16("lastname")); 1446 values.push_back(ASCIIToUTF16("Smith")); 1447 1448 labels.push_back(ASCIIToUTF16("* Email")); 1449 names.push_back(ASCIIToUTF16("email")); 1450 values.push_back(ASCIIToUTF16("john (at) example.com")); 1451 1452 ExpectLabels( 1453 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1454 "<TABLE>" 1455 " <TR>" 1456 " <TD>" 1457 " <SPAN>*</SPAN>" 1458 " <B>First Name</B>" 1459 " </TD>" 1460 " <TD></TD>" 1461 " <TD>" 1462 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1463 " </TD>" 1464 " </TR>" 1465 " <TR>" 1466 " <TD>" 1467 " <SPAN>*</SPAN>" 1468 " <B>Last Name</B>" 1469 " </TD>" 1470 " <TD></TD>" 1471 " <TD>" 1472 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1473 " </TD>" 1474 " </TR>" 1475 " <TR>" 1476 " <TD>" 1477 " <SPAN>*</SPAN>" 1478 " <B>Email</B>" 1479 " </TD>" 1480 " <TD></TD>" 1481 " <TD>" 1482 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1483 " </TD>" 1484 " </TR>" 1485 " <TR>" 1486 " <TD></TD>" 1487 " <TD>" 1488 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1489 " </TD>" 1490 " </TR>" 1491 "</TABLE>" 1492 "</FORM>", 1493 labels, names, values); 1494 } 1495 1496 TEST_F(FormAutofillTest, LabelsInferredFromPreviousTD) { 1497 std::vector<base::string16> labels, names, values; 1498 1499 labels.push_back(ASCIIToUTF16("* First Name")); 1500 names.push_back(ASCIIToUTF16("firstname")); 1501 values.push_back(ASCIIToUTF16("John")); 1502 1503 labels.push_back(ASCIIToUTF16("* Last Name")); 1504 names.push_back(ASCIIToUTF16("lastname")); 1505 values.push_back(ASCIIToUTF16("Smith")); 1506 1507 labels.push_back(ASCIIToUTF16("* Email")); 1508 names.push_back(ASCIIToUTF16("email")); 1509 values.push_back(ASCIIToUTF16("john (at) example.com")); 1510 1511 ExpectLabels( 1512 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1513 "<TABLE>" 1514 " <TR>" 1515 " <TD>* First Name</TD>" 1516 " <TD>" 1517 " Bogus" 1518 " <INPUT type=\"hidden\"/>" 1519 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1520 " </TD>" 1521 " </TR>" 1522 " <TR>" 1523 " <TD>* Last Name</TD>" 1524 " <TD>" 1525 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1526 " </TD>" 1527 " </TR>" 1528 " <TR>" 1529 " <TD>* Email</TD>" 1530 " <TD>" 1531 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1532 " </TD>" 1533 " </TR>" 1534 " <TR>" 1535 " <TD></TD>" 1536 " <TD>" 1537 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1538 " </TD>" 1539 " </TR>" 1540 "</TABLE>" 1541 "</FORM>", 1542 labels, names, values); 1543 } 1544 1545 // <script>, <noscript> and <option> tags are excluded when the labels are 1546 // inferred. 1547 // Also <!-- comment --> is excluded. 1548 TEST_F(FormAutofillTest, LabelsInferredFromTableWithSpecialElements) { 1549 std::vector<base::string16> labels, names, values; 1550 std::vector<std::string> control_types; 1551 1552 labels.push_back(ASCIIToUTF16("* First Name")); 1553 names.push_back(ASCIIToUTF16("firstname")); 1554 values.push_back(ASCIIToUTF16("John")); 1555 control_types.push_back("text"); 1556 1557 labels.push_back(ASCIIToUTF16("* Middle Name")); 1558 names.push_back(ASCIIToUTF16("middlename")); 1559 values.push_back(ASCIIToUTF16("Joe")); 1560 control_types.push_back("text"); 1561 1562 labels.push_back(ASCIIToUTF16("* Last Name")); 1563 names.push_back(ASCIIToUTF16("lastname")); 1564 values.push_back(ASCIIToUTF16("Smith")); 1565 control_types.push_back("text"); 1566 1567 labels.push_back(ASCIIToUTF16("* Country")); 1568 names.push_back(ASCIIToUTF16("country")); 1569 values.push_back(ASCIIToUTF16("US")); 1570 control_types.push_back("select-one"); 1571 1572 labels.push_back(ASCIIToUTF16("* Email")); 1573 names.push_back(ASCIIToUTF16("email")); 1574 values.push_back(ASCIIToUTF16("john (at) example.com")); 1575 control_types.push_back("text"); 1576 1577 ExpectLabelsAndTypes( 1578 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1579 "<TABLE>" 1580 " <TR>" 1581 " <TD>" 1582 " <SPAN>*</SPAN>" 1583 " <B>First Name</B>" 1584 " </TD>" 1585 " <TD>" 1586 " <SCRIPT> <!-- function test() { alert('ignored as label'); } -->" 1587 " </SCRIPT>" 1588 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1589 " </TD>" 1590 " </TR>" 1591 " <TR>" 1592 " <TD>" 1593 " <SPAN>*</SPAN>" 1594 " <B>Middle Name</B>" 1595 " </TD>" 1596 " <TD>" 1597 " <NOSCRIPT>" 1598 " <P>Bad</P>" 1599 " </NOSCRIPT>" 1600 " <INPUT type=\"text\" id=\"middlename\" value=\"Joe\"/>" 1601 " </TD>" 1602 " </TR>" 1603 " <TR>" 1604 " <TD>" 1605 " <SPAN>*</SPAN>" 1606 " <B>Last Name</B>" 1607 " </TD>" 1608 " <TD>" 1609 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1610 " </TD>" 1611 " </TR>" 1612 " <TR>" 1613 " <TD>" 1614 " <SPAN>*</SPAN>" 1615 " <B>Country</B>" 1616 " </TD>" 1617 " <TD>" 1618 " <SELECT id=\"country\">" 1619 " <OPTION VALUE=\"US\">The value should be ignored as label." 1620 " </OPTION>" 1621 " <OPTION VALUE=\"JP\">JAPAN</OPTION>" 1622 " </SELECT>" 1623 " </TD>" 1624 " </TR>" 1625 " <TR>" 1626 " <TD>" 1627 " <SPAN>*</SPAN>" 1628 " <B>Email</B>" 1629 " </TD>" 1630 " <TD>" 1631 " <!-- This comment should be ignored as inferred label.-->" 1632 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1633 " </TD>" 1634 " </TR>" 1635 " <TR>" 1636 " <TD></TD>" 1637 " <TD>" 1638 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1639 " </TD>" 1640 " </TR>" 1641 "</TABLE>" 1642 "</FORM>", 1643 labels, names, values, control_types); 1644 } 1645 1646 TEST_F(FormAutofillTest, LabelsInferredFromTableLabels) { 1647 ExpectJohnSmithLabels( 1648 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1649 "<TABLE>" 1650 " <TR>" 1651 " <TD>" 1652 " <LABEL>First name:</LABEL>" 1653 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1654 " </TD>" 1655 " </TR>" 1656 " <TR>" 1657 " <TD>" 1658 " <LABEL>Last name:</LABEL>" 1659 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1660 " </TD>" 1661 " </TR>" 1662 " <TR>" 1663 " <TD>" 1664 " <LABEL>Email:</LABEL>" 1665 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1666 " </TD>" 1667 " </TR>" 1668 "</TABLE>" 1669 "<INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1670 "</FORM>"); 1671 } 1672 1673 TEST_F(FormAutofillTest, LabelsInferredFromTableTDInterveningElements) { 1674 ExpectJohnSmithLabels( 1675 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1676 "<TABLE>" 1677 " <TR>" 1678 " <TD>" 1679 " First name:" 1680 " <BR>" 1681 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1682 " </TD>" 1683 " </TR>" 1684 " <TR>" 1685 " <TD>" 1686 " Last name:" 1687 " <BR>" 1688 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1689 " </TD>" 1690 " </TR>" 1691 " <TR>" 1692 " <TD>" 1693 " Email:" 1694 " <BR>" 1695 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1696 " </TD>" 1697 " </TR>" 1698 "</TABLE>" 1699 "<INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1700 "</FORM>"); 1701 } 1702 1703 // Verify that we correctly infer labels when the label text spans multiple 1704 // adjacent HTML elements, not separated by whitespace. 1705 TEST_F(FormAutofillTest, LabelsInferredFromTableAdjacentElements) { 1706 std::vector<base::string16> labels, names, values; 1707 1708 labels.push_back(ASCIIToUTF16("*First Name")); 1709 names.push_back(ASCIIToUTF16("firstname")); 1710 values.push_back(ASCIIToUTF16("John")); 1711 1712 labels.push_back(ASCIIToUTF16("*Last Name")); 1713 names.push_back(ASCIIToUTF16("lastname")); 1714 values.push_back(ASCIIToUTF16("Smith")); 1715 1716 labels.push_back(ASCIIToUTF16("*Email")); 1717 names.push_back(ASCIIToUTF16("email")); 1718 values.push_back(ASCIIToUTF16("john (at) example.com")); 1719 1720 ExpectLabels( 1721 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1722 "<TABLE>" 1723 " <TR>" 1724 " <TD>" 1725 " <SPAN>*</SPAN><B>First Name</B>" 1726 " </TD>" 1727 " <TD>" 1728 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1729 " </TD>" 1730 " </TR>" 1731 " <TR>" 1732 " <TD>" 1733 " <SPAN>*</SPAN><B>Last Name</B>" 1734 " </TD>" 1735 " <TD>" 1736 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1737 " </TD>" 1738 " </TR>" 1739 " <TR>" 1740 " <TD>" 1741 " <SPAN>*</SPAN><B>Email</B>" 1742 " </TD>" 1743 " <TD>" 1744 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1745 " </TD>" 1746 " </TR>" 1747 " <TR>" 1748 " <TD>" 1749 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1750 " </TD>" 1751 " </TR>" 1752 "</TABLE>" 1753 "</FORM>", 1754 labels, names, values); 1755 } 1756 1757 // Verify that we correctly infer labels when the label text resides in the 1758 // previous row. 1759 TEST_F(FormAutofillTest, LabelsInferredFromTableRow) { 1760 std::vector<base::string16> labels, names, values; 1761 1762 labels.push_back(ASCIIToUTF16("*First Name *Last Name *Email")); 1763 names.push_back(ASCIIToUTF16("firstname")); 1764 values.push_back(ASCIIToUTF16("John")); 1765 1766 labels.push_back(ASCIIToUTF16("*First Name *Last Name *Email")); 1767 names.push_back(ASCIIToUTF16("lastname")); 1768 values.push_back(ASCIIToUTF16("Smith")); 1769 1770 labels.push_back(ASCIIToUTF16("*First Name *Last Name *Email")); 1771 names.push_back(ASCIIToUTF16("email")); 1772 values.push_back(ASCIIToUTF16("john (at) example.com")); 1773 1774 ExpectLabels( 1775 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1776 "<TABLE>" 1777 " <TR>" 1778 " <TD>*First Name</TD>" 1779 " <TD>*Last Name</TD>" 1780 " <TD>*Email</TD>" 1781 " </TR>" 1782 " <TR>" 1783 " <TD>" 1784 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1785 " </TD>" 1786 " <TD>" 1787 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1788 " </TD>" 1789 " <TD>" 1790 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1791 " </TD>" 1792 " </TR>" 1793 " <TR>" 1794 " <TD>" 1795 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1796 " </TD>" 1797 " </TR>" 1798 "</TABLE>", 1799 labels, names, values); 1800 } 1801 1802 // Verify that we correctly infer labels when enclosed within a list item. 1803 TEST_F(FormAutofillTest, LabelsInferredFromListItem) { 1804 std::vector<base::string16> labels, names, values; 1805 1806 labels.push_back(ASCIIToUTF16("* Home Phone")); 1807 names.push_back(ASCIIToUTF16("areacode")); 1808 values.push_back(ASCIIToUTF16("415")); 1809 1810 labels.push_back(ASCIIToUTF16("* Home Phone")); 1811 names.push_back(ASCIIToUTF16("prefix")); 1812 values.push_back(ASCIIToUTF16("555")); 1813 1814 labels.push_back(ASCIIToUTF16("* Home Phone")); 1815 names.push_back(ASCIIToUTF16("suffix")); 1816 values.push_back(ASCIIToUTF16("1212")); 1817 1818 ExpectLabels( 1819 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1820 "<DIV>" 1821 " <LI>" 1822 " <SPAN>Bogus</SPAN>" 1823 " </LI>" 1824 " <LI>" 1825 " <LABEL><EM>*</EM> Home Phone</LABEL>" 1826 " <INPUT type=\"text\" id=\"areacode\" value=\"415\"/>" 1827 " <INPUT type=\"text\" id=\"prefix\" value=\"555\"/>" 1828 " <INPUT type=\"text\" id=\"suffix\" value=\"1212\"/>" 1829 " </LI>" 1830 " <LI>" 1831 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1832 " </LI>" 1833 "</DIV>" 1834 "</FORM>", 1835 labels, names, values); 1836 } 1837 1838 TEST_F(FormAutofillTest, LabelsInferredFromDefinitionList) { 1839 std::vector<base::string16> labels, names, values; 1840 1841 labels.push_back(ASCIIToUTF16("* First name: Bogus")); 1842 names.push_back(ASCIIToUTF16("firstname")); 1843 values.push_back(ASCIIToUTF16("John")); 1844 1845 labels.push_back(ASCIIToUTF16("Last name:")); 1846 names.push_back(ASCIIToUTF16("lastname")); 1847 values.push_back(ASCIIToUTF16("Smith")); 1848 1849 labels.push_back(ASCIIToUTF16("Email:")); 1850 names.push_back(ASCIIToUTF16("email")); 1851 values.push_back(ASCIIToUTF16("john (at) example.com")); 1852 1853 ExpectLabels( 1854 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1855 "<DL>" 1856 " <DT>" 1857 " <SPAN>" 1858 " *" 1859 " </SPAN>" 1860 " <SPAN>" 1861 " First name:" 1862 " </SPAN>" 1863 " <SPAN>" 1864 " Bogus" 1865 " </SPAN>" 1866 " </DT>" 1867 " <DD>" 1868 " <FONT>" 1869 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 1870 " </FONT>" 1871 " </DD>" 1872 " <DT>" 1873 " <SPAN>" 1874 " Last name:" 1875 " </SPAN>" 1876 " </DT>" 1877 " <DD>" 1878 " <FONT>" 1879 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 1880 " </FONT>" 1881 " </DD>" 1882 " <DT>" 1883 " <SPAN>" 1884 " Email:" 1885 " </SPAN>" 1886 " </DT>" 1887 " <DD>" 1888 " <FONT>" 1889 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 1890 " </FONT>" 1891 " </DD>" 1892 " <DT></DT>" 1893 " <DD>" 1894 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1895 " </DD>" 1896 "</DL>" 1897 "</FORM>", 1898 labels, names, values); 1899 } 1900 1901 TEST_F(FormAutofillTest, LabelsInferredWithSameName) { 1902 std::vector<base::string16> labels, names, values; 1903 1904 labels.push_back(ASCIIToUTF16("Address Line 1:")); 1905 names.push_back(ASCIIToUTF16("Address")); 1906 values.push_back(base::string16()); 1907 1908 labels.push_back(ASCIIToUTF16("Address Line 2:")); 1909 names.push_back(ASCIIToUTF16("Address")); 1910 values.push_back(base::string16()); 1911 1912 labels.push_back(ASCIIToUTF16("Address Line 3:")); 1913 names.push_back(ASCIIToUTF16("Address")); 1914 values.push_back(base::string16()); 1915 1916 ExpectLabels( 1917 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1918 " Address Line 1:" 1919 " <INPUT type=\"text\" name=\"Address\"/>" 1920 " Address Line 2:" 1921 " <INPUT type=\"text\" name=\"Address\"/>" 1922 " Address Line 3:" 1923 " <INPUT type=\"text\" name=\"Address\"/>" 1924 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1925 "</FORM>", 1926 labels, names, values); 1927 } 1928 1929 TEST_F(FormAutofillTest, LabelsInferredWithImageTags) { 1930 std::vector<base::string16> labels, names, values; 1931 1932 labels.push_back(ASCIIToUTF16("Phone:")); 1933 names.push_back(ASCIIToUTF16("dayphone1")); 1934 values.push_back(base::string16()); 1935 1936 labels.push_back(ASCIIToUTF16("-")); 1937 names.push_back(ASCIIToUTF16("dayphone2")); 1938 values.push_back(base::string16()); 1939 1940 labels.push_back(ASCIIToUTF16("-")); 1941 names.push_back(ASCIIToUTF16("dayphone3")); 1942 values.push_back(base::string16()); 1943 1944 labels.push_back(ASCIIToUTF16("ext.:")); 1945 names.push_back(ASCIIToUTF16("dayphone4")); 1946 values.push_back(base::string16()); 1947 1948 labels.push_back(base::string16()); 1949 names.push_back(ASCIIToUTF16("dummy")); 1950 values.push_back(base::string16()); 1951 1952 ExpectLabels( 1953 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1954 " Phone:" 1955 " <input type=\"text\" name=\"dayphone1\">" 1956 " <img/>" 1957 " -" 1958 " <img/>" 1959 " <input type=\"text\" name=\"dayphone2\">" 1960 " <img/>" 1961 " -" 1962 " <img/>" 1963 " <input type=\"text\" name=\"dayphone3\">" 1964 " ext.:" 1965 " <input type=\"text\" name=\"dayphone4\">" 1966 " <input type=\"text\" name=\"dummy\">" 1967 " <input type=\"submit\" name=\"reply-send\" value=\"Send\">" 1968 "</FORM>", 1969 labels, names, values); 1970 } 1971 1972 TEST_F(FormAutofillTest, LabelsInferredFromDivTable) { 1973 ExpectJohnSmithLabels( 1974 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1975 "<DIV>First name:<BR>" 1976 " <SPAN>" 1977 " <INPUT type=\"text\" name=\"firstname\" value=\"John\">" 1978 " </SPAN>" 1979 "</DIV>" 1980 "<DIV>Last name:<BR>" 1981 " <SPAN>" 1982 " <INPUT type=\"text\" name=\"lastname\" value=\"Smith\">" 1983 " </SPAN>" 1984 "</DIV>" 1985 "<DIV>Email:<BR>" 1986 " <SPAN>" 1987 " <INPUT type=\"text\" name=\"email\" value=\"john (at) example.com\">" 1988 " </SPAN>" 1989 "</DIV>" 1990 "<input type=\"submit\" name=\"reply-send\" value=\"Send\">" 1991 "</FORM>"); 1992 } 1993 1994 TEST_F(FormAutofillTest, LabelsInferredFromDivSiblingTable) { 1995 ExpectJohnSmithLabels( 1996 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 1997 "<DIV>First name:</DIV>" 1998 "<DIV>" 1999 " <SPAN>" 2000 " <INPUT type=\"text\" name=\"firstname\" value=\"John\">" 2001 " </SPAN>" 2002 "</DIV>" 2003 "<DIV>Last name:</DIV>" 2004 "<DIV>" 2005 " <SPAN>" 2006 " <INPUT type=\"text\" name=\"lastname\" value=\"Smith\">" 2007 " </SPAN>" 2008 "</DIV>" 2009 "<DIV>Email:</DIV>" 2010 "<DIV>" 2011 " <SPAN>" 2012 " <INPUT type=\"text\" name=\"email\" value=\"john (at) example.com\">" 2013 " </SPAN>" 2014 "</DIV>" 2015 "<input type=\"submit\" name=\"reply-send\" value=\"Send\">" 2016 "</FORM>"); 2017 } 2018 2019 TEST_F(FormAutofillTest, LabelsInferredFromDefinitionListRatherThanDivTable) { 2020 ExpectJohnSmithLabels( 2021 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 2022 "<DIV>This is not a label.<BR>" 2023 "<DL>" 2024 " <DT>" 2025 " <SPAN>" 2026 " First name:" 2027 " </SPAN>" 2028 " </DT>" 2029 " <DD>" 2030 " <FONT>" 2031 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 2032 " </FONT>" 2033 " </DD>" 2034 " <DT>" 2035 " <SPAN>" 2036 " Last name:" 2037 " </SPAN>" 2038 " </DT>" 2039 " <DD>" 2040 " <FONT>" 2041 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 2042 " </FONT>" 2043 " </DD>" 2044 " <DT>" 2045 " <SPAN>" 2046 " Email:" 2047 " </SPAN>" 2048 " </DT>" 2049 " <DD>" 2050 " <FONT>" 2051 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 2052 " </FONT>" 2053 " </DD>" 2054 " <DT></DT>" 2055 " <DD>" 2056 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 2057 " </DD>" 2058 "</DL>" 2059 "</DIV>" 2060 "</FORM>"); 2061 } 2062 2063 TEST_F(FormAutofillTest, FillFormMaxLength) { 2064 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2065 " <INPUT type=\"text\" id=\"firstname\" maxlength=\"5\"/>" 2066 " <INPUT type=\"text\" id=\"lastname\" maxlength=\"7\"/>" 2067 " <INPUT type=\"text\" id=\"email\" maxlength=\"9\"/>" 2068 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 2069 "</FORM>"); 2070 2071 WebFrame* web_frame = GetMainFrame(); 2072 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2073 2074 FormCache form_cache; 2075 std::vector<FormData> forms; 2076 form_cache.ExtractForms(*web_frame, &forms); 2077 ASSERT_EQ(1U, forms.size()); 2078 2079 // Get the input element we want to find. 2080 WebElement element = web_frame->document().getElementById("firstname"); 2081 WebInputElement input_element = element.to<WebInputElement>(); 2082 2083 // Find the form that contains the input element. 2084 FormData form; 2085 FormFieldData field; 2086 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form, &field, 2087 autofill::REQUIRE_NONE)); 2088 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2089 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 2090 EXPECT_EQ(GURL("http://buh.com"), form.action); 2091 2092 const std::vector<FormFieldData>& fields = form.fields; 2093 ASSERT_EQ(3U, fields.size()); 2094 2095 FormFieldData expected; 2096 expected.form_control_type = "text"; 2097 2098 expected.name = ASCIIToUTF16("firstname"); 2099 expected.max_length = 5; 2100 expected.is_autofilled = false; 2101 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 2102 2103 expected.name = ASCIIToUTF16("lastname"); 2104 expected.max_length = 7; 2105 expected.is_autofilled = false; 2106 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 2107 2108 expected.name = ASCIIToUTF16("email"); 2109 expected.max_length = 9; 2110 expected.is_autofilled = false; 2111 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 2112 2113 // Fill the form. 2114 form.fields[0].value = ASCIIToUTF16("Brother"); 2115 form.fields[1].value = ASCIIToUTF16("Jonathan"); 2116 form.fields[2].value = ASCIIToUTF16("brotherj (at) example.com"); 2117 FillForm(form, input_element); 2118 2119 // Find the newly-filled form that contains the input element. 2120 FormData form2; 2121 FormFieldData field2; 2122 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form2, &field2, 2123 autofill::REQUIRE_NONE)); 2124 2125 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2126 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2127 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2128 2129 const std::vector<FormFieldData>& fields2 = form2.fields; 2130 ASSERT_EQ(3U, fields2.size()); 2131 2132 expected.form_control_type = "text"; 2133 2134 expected.name = ASCIIToUTF16("firstname"); 2135 expected.value = ASCIIToUTF16("Broth"); 2136 expected.max_length = 5; 2137 expected.is_autofilled = true; 2138 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]); 2139 2140 expected.name = ASCIIToUTF16("lastname"); 2141 expected.value = ASCIIToUTF16("Jonatha"); 2142 expected.max_length = 7; 2143 expected.is_autofilled = true; 2144 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]); 2145 2146 expected.name = ASCIIToUTF16("email"); 2147 expected.value = ASCIIToUTF16("brotherj@"); 2148 expected.max_length = 9; 2149 expected.is_autofilled = true; 2150 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]); 2151 } 2152 2153 // This test uses negative values of the maxlength attribute for input elements. 2154 // In this case, the maxlength of the input elements is set to the default 2155 // maxlength (defined in WebKit.) 2156 TEST_F(FormAutofillTest, FillFormNegativeMaxLength) { 2157 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2158 " <INPUT type=\"text\" id=\"firstname\" maxlength=\"-1\"/>" 2159 " <INPUT type=\"text\" id=\"lastname\" maxlength=\"-10\"/>" 2160 " <INPUT type=\"text\" id=\"email\" maxlength=\"-13\"/>" 2161 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 2162 "</FORM>"); 2163 2164 WebFrame* web_frame = GetMainFrame(); 2165 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2166 2167 FormCache form_cache; 2168 std::vector<FormData> forms; 2169 form_cache.ExtractForms(*web_frame, &forms); 2170 ASSERT_EQ(1U, forms.size()); 2171 2172 // Get the input element we want to find. 2173 WebElement element = web_frame->document().getElementById("firstname"); 2174 WebInputElement input_element = element.to<WebInputElement>(); 2175 2176 // Find the form that contains the input element. 2177 FormData form; 2178 FormFieldData field; 2179 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form, &field, 2180 autofill::REQUIRE_NONE)); 2181 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2182 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 2183 EXPECT_EQ(GURL("http://buh.com"), form.action); 2184 2185 const std::vector<FormFieldData>& fields = form.fields; 2186 ASSERT_EQ(3U, fields.size()); 2187 2188 FormFieldData expected; 2189 expected.form_control_type = "text"; 2190 expected.max_length = WebInputElement::defaultMaxLength(); 2191 2192 expected.name = ASCIIToUTF16("firstname"); 2193 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 2194 2195 expected.name = ASCIIToUTF16("lastname"); 2196 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 2197 2198 expected.name = ASCIIToUTF16("email"); 2199 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 2200 2201 // Fill the form. 2202 form.fields[0].value = ASCIIToUTF16("Brother"); 2203 form.fields[1].value = ASCIIToUTF16("Jonathan"); 2204 form.fields[2].value = ASCIIToUTF16("brotherj (at) example.com"); 2205 FillForm(form, input_element); 2206 2207 // Find the newly-filled form that contains the input element. 2208 FormData form2; 2209 FormFieldData field2; 2210 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form2, &field2, 2211 autofill::REQUIRE_NONE)); 2212 2213 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2214 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2215 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2216 2217 const std::vector<FormFieldData>& fields2 = form2.fields; 2218 ASSERT_EQ(3U, fields2.size()); 2219 2220 expected.name = ASCIIToUTF16("firstname"); 2221 expected.value = ASCIIToUTF16("Brother"); 2222 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 2223 2224 expected.name = ASCIIToUTF16("lastname"); 2225 expected.value = ASCIIToUTF16("Jonathan"); 2226 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 2227 2228 expected.name = ASCIIToUTF16("email"); 2229 expected.value = ASCIIToUTF16("brotherj (at) example.com"); 2230 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 2231 } 2232 2233 TEST_F(FormAutofillTest, FillFormEmptyName) { 2234 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2235 " <INPUT type=\"text\" id=\"firstname\"/>" 2236 " <INPUT type=\"text\" id=\"lastname\"/>" 2237 " <INPUT type=\"text\" id=\"email\"/>" 2238 " <INPUT type=\"submit\" value=\"Send\"/>" 2239 "</FORM>"); 2240 2241 WebFrame* web_frame = GetMainFrame(); 2242 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2243 2244 FormCache form_cache; 2245 std::vector<FormData> forms; 2246 form_cache.ExtractForms(*web_frame, &forms); 2247 ASSERT_EQ(1U, forms.size()); 2248 2249 // Get the input element we want to find. 2250 WebElement element = web_frame->document().getElementById("firstname"); 2251 WebInputElement input_element = element.to<WebInputElement>(); 2252 2253 // Find the form that contains the input element. 2254 FormData form; 2255 FormFieldData field; 2256 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form, &field, 2257 autofill::REQUIRE_NONE)); 2258 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2259 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 2260 EXPECT_EQ(GURL("http://buh.com"), form.action); 2261 2262 const std::vector<FormFieldData>& fields = form.fields; 2263 ASSERT_EQ(3U, fields.size()); 2264 2265 FormFieldData expected; 2266 expected.form_control_type = "text"; 2267 expected.max_length = WebInputElement::defaultMaxLength(); 2268 2269 expected.name = ASCIIToUTF16("firstname"); 2270 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 2271 2272 expected.name = ASCIIToUTF16("lastname"); 2273 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 2274 2275 expected.name = ASCIIToUTF16("email"); 2276 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 2277 2278 // Fill the form. 2279 form.fields[0].value = ASCIIToUTF16("Wyatt"); 2280 form.fields[1].value = ASCIIToUTF16("Earp"); 2281 form.fields[2].value = ASCIIToUTF16("wyatt (at) example.com"); 2282 FillForm(form, input_element); 2283 2284 // Find the newly-filled form that contains the input element. 2285 FormData form2; 2286 FormFieldData field2; 2287 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form2, &field2, 2288 autofill::REQUIRE_NONE)); 2289 2290 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2291 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2292 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2293 2294 const std::vector<FormFieldData>& fields2 = form2.fields; 2295 ASSERT_EQ(3U, fields2.size()); 2296 2297 expected.form_control_type = "text"; 2298 expected.max_length = WebInputElement::defaultMaxLength(); 2299 2300 expected.name = ASCIIToUTF16("firstname"); 2301 expected.value = ASCIIToUTF16("Wyatt"); 2302 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 2303 2304 expected.name = ASCIIToUTF16("lastname"); 2305 expected.value = ASCIIToUTF16("Earp"); 2306 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 2307 2308 expected.name = ASCIIToUTF16("email"); 2309 expected.value = ASCIIToUTF16("wyatt (at) example.com"); 2310 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 2311 } 2312 2313 TEST_F(FormAutofillTest, FillFormEmptyFormNames) { 2314 LoadHTML("<FORM action=\"http://buh.com\" method=\"post\">" 2315 " <INPUT type=\"text\" id=\"firstname\"/>" 2316 " <INPUT type=\"text\" id=\"middlename\"/>" 2317 " <INPUT type=\"text\" id=\"lastname\"/>" 2318 " <INPUT type=\"submit\" value=\"Send\"/>" 2319 "</FORM>" 2320 "<FORM action=\"http://abc.com\" method=\"post\">" 2321 " <INPUT type=\"text\" id=\"apple\"/>" 2322 " <INPUT type=\"text\" id=\"banana\"/>" 2323 " <INPUT type=\"text\" id=\"cantelope\"/>" 2324 " <INPUT type=\"submit\" value=\"Send\"/>" 2325 "</FORM>"); 2326 2327 WebFrame* web_frame = GetMainFrame(); 2328 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2329 2330 FormCache form_cache; 2331 std::vector<FormData> forms; 2332 form_cache.ExtractForms(*web_frame, &forms); 2333 ASSERT_EQ(2U, forms.size()); 2334 2335 // Get the input element we want to find. 2336 WebElement element = web_frame->document().getElementById("apple"); 2337 WebInputElement input_element = element.to<WebInputElement>(); 2338 2339 // Find the form that contains the input element. 2340 FormData form; 2341 FormFieldData field; 2342 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form, &field, 2343 autofill::REQUIRE_NONE)); 2344 EXPECT_EQ(base::string16(), form.name); 2345 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 2346 EXPECT_EQ(GURL("http://abc.com"), form.action); 2347 2348 const std::vector<FormFieldData>& fields = form.fields; 2349 ASSERT_EQ(3U, fields.size()); 2350 2351 FormFieldData expected; 2352 expected.form_control_type = "text"; 2353 expected.max_length = WebInputElement::defaultMaxLength(); 2354 2355 expected.name = ASCIIToUTF16("apple"); 2356 expected.is_autofilled = false; 2357 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 2358 2359 expected.name = ASCIIToUTF16("banana"); 2360 expected.is_autofilled = false; 2361 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 2362 2363 expected.name = ASCIIToUTF16("cantelope"); 2364 expected.is_autofilled = false; 2365 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 2366 2367 // Fill the form. 2368 form.fields[0].value = ASCIIToUTF16("Red"); 2369 form.fields[1].value = ASCIIToUTF16("Yellow"); 2370 form.fields[2].value = ASCIIToUTF16("Also Yellow"); 2371 FillForm(form, input_element); 2372 2373 // Find the newly-filled form that contains the input element. 2374 FormData form2; 2375 FormFieldData field2; 2376 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form2, &field2, 2377 autofill::REQUIRE_NONE)); 2378 2379 EXPECT_EQ(base::string16(), form2.name); 2380 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2381 EXPECT_EQ(GURL("http://abc.com"), form2.action); 2382 2383 const std::vector<FormFieldData>& fields2 = form2.fields; 2384 ASSERT_EQ(3U, fields2.size()); 2385 2386 expected.name = ASCIIToUTF16("apple"); 2387 expected.value = ASCIIToUTF16("Red"); 2388 expected.is_autofilled = true; 2389 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]); 2390 2391 expected.name = ASCIIToUTF16("banana"); 2392 expected.value = ASCIIToUTF16("Yellow"); 2393 expected.is_autofilled = true; 2394 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]); 2395 2396 expected.name = ASCIIToUTF16("cantelope"); 2397 expected.value = ASCIIToUTF16("Also Yellow"); 2398 expected.is_autofilled = true; 2399 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]); 2400 } 2401 2402 TEST_F(FormAutofillTest, ThreePartPhone) { 2403 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 2404 " Phone:" 2405 " <input type=\"text\" name=\"dayphone1\">" 2406 " -" 2407 " <input type=\"text\" name=\"dayphone2\">" 2408 " -" 2409 " <input type=\"text\" name=\"dayphone3\">" 2410 " ext.:" 2411 " <input type=\"text\" name=\"dayphone4\">" 2412 " <input type=\"submit\" name=\"reply-send\" value=\"Send\">" 2413 "</FORM>"); 2414 2415 2416 WebFrame* frame = GetMainFrame(); 2417 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 2418 2419 WebVector<WebFormElement> forms; 2420 frame->document().forms(forms); 2421 ASSERT_EQ(1U, forms.size()); 2422 2423 FormData form; 2424 EXPECT_TRUE(WebFormElementToFormData(forms[0], 2425 WebFormControlElement(), 2426 autofill::REQUIRE_NONE, 2427 autofill::EXTRACT_VALUE, 2428 &form, 2429 NULL)); 2430 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2431 EXPECT_EQ(GURL(frame->document().url()), form.origin); 2432 EXPECT_EQ(GURL("http://cnn.com"), form.action); 2433 2434 const std::vector<FormFieldData>& fields = form.fields; 2435 ASSERT_EQ(4U, fields.size()); 2436 2437 FormFieldData expected; 2438 expected.form_control_type = "text"; 2439 expected.max_length = WebInputElement::defaultMaxLength(); 2440 2441 expected.label = ASCIIToUTF16("Phone:"); 2442 expected.name = ASCIIToUTF16("dayphone1"); 2443 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 2444 2445 expected.label = ASCIIToUTF16("-"); 2446 expected.name = ASCIIToUTF16("dayphone2"); 2447 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 2448 2449 expected.label = ASCIIToUTF16("-"); 2450 expected.name = ASCIIToUTF16("dayphone3"); 2451 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 2452 2453 expected.label = ASCIIToUTF16("ext.:"); 2454 expected.name = ASCIIToUTF16("dayphone4"); 2455 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]); 2456 } 2457 2458 2459 TEST_F(FormAutofillTest, MaxLengthFields) { 2460 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 2461 " Phone:" 2462 " <input type=\"text\" maxlength=\"3\" name=\"dayphone1\">" 2463 " -" 2464 " <input type=\"text\" maxlength=\"3\" name=\"dayphone2\">" 2465 " -" 2466 " <input type=\"text\" maxlength=\"4\" size=\"5\"" 2467 " name=\"dayphone3\">" 2468 " ext.:" 2469 " <input type=\"text\" maxlength=\"5\" name=\"dayphone4\">" 2470 " <input type=\"text\" name=\"default1\">" 2471 " <input type=\"text\" maxlength=\"-1\" name=\"invalid1\">" 2472 " <input type=\"submit\" name=\"reply-send\" value=\"Send\">" 2473 "</FORM>"); 2474 2475 WebFrame* frame = GetMainFrame(); 2476 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 2477 2478 WebVector<WebFormElement> forms; 2479 frame->document().forms(forms); 2480 ASSERT_EQ(1U, forms.size()); 2481 2482 FormData form; 2483 EXPECT_TRUE(WebFormElementToFormData(forms[0], 2484 WebFormControlElement(), 2485 autofill::REQUIRE_NONE, 2486 autofill::EXTRACT_VALUE, 2487 &form, 2488 NULL)); 2489 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2490 EXPECT_EQ(GURL(frame->document().url()), form.origin); 2491 EXPECT_EQ(GURL("http://cnn.com"), form.action); 2492 2493 const std::vector<FormFieldData>& fields = form.fields; 2494 ASSERT_EQ(6U, fields.size()); 2495 2496 FormFieldData expected; 2497 expected.form_control_type = "text"; 2498 2499 expected.label = ASCIIToUTF16("Phone:"); 2500 expected.name = ASCIIToUTF16("dayphone1"); 2501 expected.max_length = 3; 2502 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 2503 2504 expected.label = ASCIIToUTF16("-"); 2505 expected.name = ASCIIToUTF16("dayphone2"); 2506 expected.max_length = 3; 2507 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 2508 2509 expected.label = ASCIIToUTF16("-"); 2510 expected.name = ASCIIToUTF16("dayphone3"); 2511 expected.max_length = 4; 2512 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 2513 2514 expected.label = ASCIIToUTF16("ext.:"); 2515 expected.name = ASCIIToUTF16("dayphone4"); 2516 expected.max_length = 5; 2517 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]); 2518 2519 // When unspecified |size|, default is returned. 2520 expected.label = base::string16(); 2521 expected.name = ASCIIToUTF16("default1"); 2522 expected.max_length = WebInputElement::defaultMaxLength(); 2523 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[4]); 2524 2525 // When invalid |size|, default is returned. 2526 expected.label = base::string16(); 2527 expected.name = ASCIIToUTF16("invalid1"); 2528 expected.max_length = WebInputElement::defaultMaxLength(); 2529 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[5]); 2530 } 2531 2532 // This test re-creates the experience of typing in a field then selecting a 2533 // profile from the Autofill suggestions popup. The field that is being typed 2534 // into should be filled even though it's not technically empty. 2535 TEST_F(FormAutofillTest, FillFormNonEmptyField) { 2536 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2537 " <INPUT type=\"text\" id=\"firstname\"/>" 2538 " <INPUT type=\"text\" id=\"lastname\"/>" 2539 " <INPUT type=\"text\" id=\"email\"/>" 2540 " <INPUT type=\"submit\" value=\"Send\"/>" 2541 "</FORM>"); 2542 2543 WebFrame* web_frame = GetMainFrame(); 2544 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2545 2546 FormCache form_cache; 2547 std::vector<FormData> forms; 2548 form_cache.ExtractForms(*web_frame, &forms); 2549 ASSERT_EQ(1U, forms.size()); 2550 2551 // Get the input element we want to find. 2552 WebElement element = web_frame->document().getElementById("firstname"); 2553 WebInputElement input_element = element.to<WebInputElement>(); 2554 2555 // Simulate typing by modifying the field value. 2556 input_element.setValue(ASCIIToUTF16("Wy")); 2557 2558 // Find the form that contains the input element. 2559 FormData form; 2560 FormFieldData field; 2561 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form, &field, 2562 autofill::REQUIRE_NONE)); 2563 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2564 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 2565 EXPECT_EQ(GURL("http://buh.com"), form.action); 2566 2567 const std::vector<FormFieldData>& fields = form.fields; 2568 ASSERT_EQ(3U, fields.size()); 2569 2570 FormFieldData expected; 2571 expected.form_control_type = "text"; 2572 expected.max_length = WebInputElement::defaultMaxLength(); 2573 2574 expected.name = ASCIIToUTF16("firstname"); 2575 expected.value = ASCIIToUTF16("Wy"); 2576 expected.is_autofilled = false; 2577 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 2578 2579 expected.name = ASCIIToUTF16("lastname"); 2580 expected.value = base::string16(); 2581 expected.is_autofilled = false; 2582 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 2583 2584 expected.name = ASCIIToUTF16("email"); 2585 expected.value = base::string16(); 2586 expected.is_autofilled = false; 2587 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 2588 2589 // Preview the form and verify that the cursor position has been updated. 2590 form.fields[0].value = ASCIIToUTF16("Wyatt"); 2591 form.fields[1].value = ASCIIToUTF16("Earp"); 2592 form.fields[2].value = ASCIIToUTF16("wyatt (at) example.com"); 2593 PreviewForm(form, input_element); 2594 EXPECT_EQ(2, input_element.selectionStart()); 2595 EXPECT_EQ(5, input_element.selectionEnd()); 2596 2597 // Fill the form. 2598 FillForm(form, input_element); 2599 2600 // Find the newly-filled form that contains the input element. 2601 FormData form2; 2602 FormFieldData field2; 2603 EXPECT_TRUE(FindFormAndFieldForInputElement(input_element, &form2, &field2, 2604 autofill::REQUIRE_NONE)); 2605 2606 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2607 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2608 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2609 2610 const std::vector<FormFieldData>& fields2 = form2.fields; 2611 ASSERT_EQ(3U, fields2.size()); 2612 2613 expected.name = ASCIIToUTF16("firstname"); 2614 expected.value = ASCIIToUTF16("Wyatt"); 2615 expected.is_autofilled = true; 2616 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]); 2617 2618 expected.name = ASCIIToUTF16("lastname"); 2619 expected.value = ASCIIToUTF16("Earp"); 2620 expected.is_autofilled = true; 2621 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]); 2622 2623 expected.name = ASCIIToUTF16("email"); 2624 expected.value = ASCIIToUTF16("wyatt (at) example.com"); 2625 expected.is_autofilled = true; 2626 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]); 2627 2628 // Verify that the cursor position has been updated. 2629 EXPECT_EQ(5, input_element.selectionStart()); 2630 EXPECT_EQ(5, input_element.selectionEnd()); 2631 } 2632 2633 TEST_F(FormAutofillTest, ClearFormWithNode) { 2634 LoadHTML( 2635 "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2636 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>" 2637 " <INPUT type=\"text\" id=\"lastname\" value=\"Earp\"/>" 2638 " <INPUT type=\"text\" autocomplete=\"off\" id=\"noAC\" value=\"one\"/>" 2639 " <INPUT type=\"text\" id=\"notenabled\" disabled=\"disabled\">" 2640 " <INPUT type=\"month\" id=\"month\" value=\"2012-11\">" 2641 " <INPUT type=\"month\" id=\"month-disabled\" value=\"2012-11\"" 2642 " disabled=\"disabled\">" 2643 " <TEXTAREA id=\"textarea\">Apple.</TEXTAREA>" 2644 " <TEXTAREA id=\"textarea-disabled\" disabled=\"disabled\">" 2645 " Banana!" 2646 " </TEXTAREA>" 2647 " <TEXTAREA id=\"textarea-noAC\" autocomplete=\"off\">Carrot?</TEXTAREA>" 2648 " <INPUT type=\"submit\" value=\"Send\"/>" 2649 "</FORM>"); 2650 2651 WebFrame* web_frame = GetMainFrame(); 2652 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2653 2654 FormCache form_cache; 2655 std::vector<FormData> forms; 2656 form_cache.ExtractForms(*web_frame, &forms); 2657 ASSERT_EQ(1U, forms.size()); 2658 2659 // Set the auto-filled attribute on the firstname element. 2660 WebInputElement firstname = 2661 web_frame->document().getElementById("firstname").to<WebInputElement>(); 2662 firstname.setAutofilled(true); 2663 2664 // Set the value of the disabled text input element. 2665 WebInputElement notenabled = 2666 web_frame->document().getElementById("notenabled").to<WebInputElement>(); 2667 notenabled.setValue(WebString::fromUTF8("no clear")); 2668 2669 // Clear the form. 2670 EXPECT_TRUE(form_cache.ClearFormWithElement(firstname)); 2671 2672 // Verify that the auto-filled attribute has been turned off. 2673 EXPECT_FALSE(firstname.isAutofilled()); 2674 2675 // Verify the form is cleared. 2676 FormData form2; 2677 FormFieldData field2; 2678 EXPECT_TRUE(FindFormAndFieldForInputElement(firstname, &form2, &field2, 2679 autofill::REQUIRE_NONE)); 2680 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2681 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2682 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2683 2684 const std::vector<FormFieldData>& fields2 = form2.fields; 2685 ASSERT_EQ(9U, fields2.size()); 2686 2687 FormFieldData expected; 2688 expected.form_control_type = "text"; 2689 expected.max_length = WebInputElement::defaultMaxLength(); 2690 2691 expected.name = ASCIIToUTF16("firstname"); 2692 expected.value = base::string16(); 2693 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]); 2694 2695 expected.name = ASCIIToUTF16("lastname"); 2696 expected.value = base::string16(); 2697 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]); 2698 2699 expected.name = ASCIIToUTF16("noAC"); 2700 expected.value = base::string16(); 2701 expected.autocomplete_attribute = "off"; 2702 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]); 2703 expected.autocomplete_attribute = std::string(); // reset 2704 2705 expected.name = ASCIIToUTF16("notenabled"); 2706 expected.value = ASCIIToUTF16("no clear"); 2707 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[3]); 2708 2709 expected.form_control_type = "month"; 2710 expected.max_length = 0; 2711 expected.name = ASCIIToUTF16("month"); 2712 expected.value = base::string16(); 2713 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[4]); 2714 2715 expected.name = ASCIIToUTF16("month-disabled"); 2716 expected.value = ASCIIToUTF16("2012-11"); 2717 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[5]); 2718 2719 expected.form_control_type = "textarea"; 2720 expected.name = ASCIIToUTF16("textarea"); 2721 expected.value = base::string16(); 2722 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[6]); 2723 2724 expected.name = ASCIIToUTF16("textarea-disabled"); 2725 expected.value = ASCIIToUTF16(" Banana! "); 2726 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[7]); 2727 2728 expected.name = ASCIIToUTF16("textarea-noAC"); 2729 expected.value = base::string16(); 2730 expected.autocomplete_attribute = "off"; 2731 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[8]); 2732 expected.autocomplete_attribute = std::string(); // reset 2733 2734 // Verify that the cursor position has been updated. 2735 EXPECT_EQ(0, firstname.selectionStart()); 2736 EXPECT_EQ(0, firstname.selectionEnd()); 2737 } 2738 2739 TEST_F(FormAutofillTest, ClearFormWithNodeContainingSelectOne) { 2740 LoadHTML( 2741 "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2742 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>" 2743 " <INPUT type=\"text\" id=\"lastname\" value=\"Earp\"/>" 2744 " <SELECT id=\"state\" name=\"state\">" 2745 " <OPTION selected>?</OPTION>" 2746 " <OPTION>AA</OPTION>" 2747 " <OPTION>AE</OPTION>" 2748 " <OPTION>AK</OPTION>" 2749 " </SELECT>" 2750 " <INPUT type=\"submit\" value=\"Send\"/>" 2751 "</FORM>"); 2752 2753 WebFrame* web_frame = GetMainFrame(); 2754 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2755 2756 FormCache form_cache; 2757 std::vector<FormData> forms; 2758 form_cache.ExtractForms(*web_frame, &forms); 2759 ASSERT_EQ(1U, forms.size()); 2760 2761 // Set the auto-filled attribute on the firstname element. 2762 WebInputElement firstname = 2763 web_frame->document().getElementById("firstname").to<WebInputElement>(); 2764 firstname.setAutofilled(true); 2765 2766 // Set the value of the select-one. 2767 WebSelectElement select_element = 2768 web_frame->document().getElementById("state").to<WebSelectElement>(); 2769 select_element.setValue(WebString::fromUTF8("AK")); 2770 2771 // Clear the form. 2772 EXPECT_TRUE(form_cache.ClearFormWithElement(firstname)); 2773 2774 // Verify that the auto-filled attribute has been turned off. 2775 EXPECT_FALSE(firstname.isAutofilled()); 2776 2777 // Verify the form is cleared. 2778 FormData form2; 2779 FormFieldData field2; 2780 EXPECT_TRUE(FindFormAndFieldForInputElement(firstname, &form2, &field2, 2781 autofill::REQUIRE_NONE)); 2782 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2783 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2784 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2785 2786 const std::vector<FormFieldData>& fields2 = form2.fields; 2787 ASSERT_EQ(3U, fields2.size()); 2788 2789 FormFieldData expected; 2790 2791 expected.name = ASCIIToUTF16("firstname"); 2792 expected.value = base::string16(); 2793 expected.form_control_type = "text"; 2794 expected.max_length = WebInputElement::defaultMaxLength(); 2795 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]); 2796 2797 expected.name = ASCIIToUTF16("lastname"); 2798 expected.value = base::string16(); 2799 expected.form_control_type = "text"; 2800 expected.max_length = WebInputElement::defaultMaxLength(); 2801 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]); 2802 2803 expected.name = ASCIIToUTF16("state"); 2804 expected.value = ASCIIToUTF16("?"); 2805 expected.form_control_type = "select-one"; 2806 expected.max_length = 0; 2807 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]); 2808 2809 // Verify that the cursor position has been updated. 2810 EXPECT_EQ(0, firstname.selectionStart()); 2811 EXPECT_EQ(0, firstname.selectionEnd()); 2812 } 2813 2814 TEST_F(FormAutofillTest, ClearPreviewedFormWithElement) { 2815 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2816 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>" 2817 " <INPUT type=\"text\" id=\"lastname\"/>" 2818 " <INPUT type=\"text\" id=\"email\"/>" 2819 " <INPUT type=\"email\" id=\"email2\"/>" 2820 " <INPUT type=\"tel\" id=\"phone\"/>" 2821 " <INPUT type=\"submit\" value=\"Send\"/>" 2822 "</FORM>"); 2823 2824 WebFrame* web_frame = GetMainFrame(); 2825 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2826 2827 FormCache form_cache; 2828 std::vector<FormData> forms; 2829 form_cache.ExtractForms(*web_frame, &forms); 2830 ASSERT_EQ(1U, forms.size()); 2831 2832 // Set the auto-filled attribute. 2833 WebInputElement firstname = 2834 web_frame->document().getElementById("firstname").to<WebInputElement>(); 2835 firstname.setAutofilled(true); 2836 WebInputElement lastname = 2837 web_frame->document().getElementById("lastname").to<WebInputElement>(); 2838 lastname.setAutofilled(true); 2839 WebInputElement email = 2840 web_frame->document().getElementById("email").to<WebInputElement>(); 2841 email.setAutofilled(true); 2842 WebInputElement email2 = 2843 web_frame->document().getElementById("email2").to<WebInputElement>(); 2844 email2.setAutofilled(true); 2845 WebInputElement phone = 2846 web_frame->document().getElementById("phone").to<WebInputElement>(); 2847 phone.setAutofilled(true); 2848 2849 // Set the suggested values on two of the elements. 2850 lastname.setSuggestedValue(ASCIIToUTF16("Earp")); 2851 email.setSuggestedValue(ASCIIToUTF16("wyatt (at) earp.com")); 2852 email2.setSuggestedValue(ASCIIToUTF16("wyatt (at) earp.com")); 2853 phone.setSuggestedValue(ASCIIToUTF16("650-777-9999")); 2854 2855 // Clear the previewed fields. 2856 EXPECT_TRUE(ClearPreviewedFormWithElement(lastname, false)); 2857 2858 // Fields with empty suggestions suggestions are not modified. 2859 EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.value()); 2860 EXPECT_TRUE(firstname.suggestedValue().isEmpty()); 2861 EXPECT_TRUE(firstname.isAutofilled()); 2862 2863 // Verify the previewed fields are cleared. 2864 EXPECT_TRUE(lastname.value().isEmpty()); 2865 EXPECT_TRUE(lastname.suggestedValue().isEmpty()); 2866 EXPECT_FALSE(lastname.isAutofilled()); 2867 EXPECT_TRUE(email.value().isEmpty()); 2868 EXPECT_TRUE(email.suggestedValue().isEmpty()); 2869 EXPECT_FALSE(email.isAutofilled()); 2870 EXPECT_TRUE(email2.value().isEmpty()); 2871 EXPECT_TRUE(email2.suggestedValue().isEmpty()); 2872 EXPECT_FALSE(email2.isAutofilled()); 2873 EXPECT_TRUE(phone.value().isEmpty()); 2874 EXPECT_TRUE(phone.suggestedValue().isEmpty()); 2875 EXPECT_FALSE(phone.isAutofilled()); 2876 2877 // Verify that the cursor position has been updated. 2878 EXPECT_EQ(0, lastname.selectionStart()); 2879 EXPECT_EQ(0, lastname.selectionEnd()); 2880 } 2881 2882 TEST_F(FormAutofillTest, ClearPreviewedFormWithNonEmptyInitiatingNode) { 2883 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2884 " <INPUT type=\"text\" id=\"firstname\" value=\"W\"/>" 2885 " <INPUT type=\"text\" id=\"lastname\"/>" 2886 " <INPUT type=\"text\" id=\"email\"/>" 2887 " <INPUT type=\"email\" id=\"email2\"/>" 2888 " <INPUT type=\"tel\" id=\"phone\"/>" 2889 " <INPUT type=\"submit\" value=\"Send\"/>" 2890 "</FORM>"); 2891 2892 WebFrame* web_frame = GetMainFrame(); 2893 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2894 2895 FormCache form_cache; 2896 std::vector<FormData> forms; 2897 form_cache.ExtractForms(*web_frame, &forms); 2898 ASSERT_EQ(1U, forms.size()); 2899 2900 // Set the auto-filled attribute. 2901 WebInputElement firstname = 2902 web_frame->document().getElementById("firstname").to<WebInputElement>(); 2903 firstname.setAutofilled(true); 2904 WebInputElement lastname = 2905 web_frame->document().getElementById("lastname").to<WebInputElement>(); 2906 lastname.setAutofilled(true); 2907 WebInputElement email = 2908 web_frame->document().getElementById("email").to<WebInputElement>(); 2909 email.setAutofilled(true); 2910 WebInputElement email2 = 2911 web_frame->document().getElementById("email2").to<WebInputElement>(); 2912 email2.setAutofilled(true); 2913 WebInputElement phone = 2914 web_frame->document().getElementById("phone").to<WebInputElement>(); 2915 phone.setAutofilled(true); 2916 2917 2918 // Set the suggested values on all of the elements. 2919 firstname.setSuggestedValue(ASCIIToUTF16("Wyatt")); 2920 lastname.setSuggestedValue(ASCIIToUTF16("Earp")); 2921 email.setSuggestedValue(ASCIIToUTF16("wyatt (at) earp.com")); 2922 email2.setSuggestedValue(ASCIIToUTF16("wyatt (at) earp.com")); 2923 phone.setSuggestedValue(ASCIIToUTF16("650-777-9999")); 2924 2925 // Clear the previewed fields. 2926 EXPECT_TRUE(ClearPreviewedFormWithElement(firstname, false)); 2927 2928 // Fields with non-empty values are restored. 2929 EXPECT_EQ(ASCIIToUTF16("W"), firstname.value()); 2930 EXPECT_TRUE(firstname.suggestedValue().isEmpty()); 2931 EXPECT_FALSE(firstname.isAutofilled()); 2932 EXPECT_EQ(1, firstname.selectionStart()); 2933 EXPECT_EQ(1, firstname.selectionEnd()); 2934 2935 // Verify the previewed fields are cleared. 2936 EXPECT_TRUE(lastname.value().isEmpty()); 2937 EXPECT_TRUE(lastname.suggestedValue().isEmpty()); 2938 EXPECT_FALSE(lastname.isAutofilled()); 2939 EXPECT_TRUE(email.value().isEmpty()); 2940 EXPECT_TRUE(email.suggestedValue().isEmpty()); 2941 EXPECT_FALSE(email.isAutofilled()); 2942 EXPECT_TRUE(email2.value().isEmpty()); 2943 EXPECT_TRUE(email2.suggestedValue().isEmpty()); 2944 EXPECT_FALSE(email2.isAutofilled()); 2945 EXPECT_TRUE(phone.value().isEmpty()); 2946 EXPECT_TRUE(phone.suggestedValue().isEmpty()); 2947 EXPECT_FALSE(phone.isAutofilled()); 2948 } 2949 2950 TEST_F(FormAutofillTest, ClearPreviewedFormWithAutofilledInitiatingNode) { 2951 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2952 " <INPUT type=\"text\" id=\"firstname\" value=\"W\"/>" 2953 " <INPUT type=\"text\" id=\"lastname\"/>" 2954 " <INPUT type=\"text\" id=\"email\"/>" 2955 " <INPUT type=\"email\" id=\"email2\"/>" 2956 " <INPUT type=\"tel\" id=\"phone\"/>" 2957 " <INPUT type=\"submit\" value=\"Send\"/>" 2958 "</FORM>"); 2959 2960 WebFrame* web_frame = GetMainFrame(); 2961 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 2962 2963 FormCache form_cache; 2964 std::vector<FormData> forms; 2965 form_cache.ExtractForms(*web_frame, &forms); 2966 ASSERT_EQ(1U, forms.size()); 2967 2968 // Set the auto-filled attribute. 2969 WebInputElement firstname = 2970 web_frame->document().getElementById("firstname").to<WebInputElement>(); 2971 firstname.setAutofilled(true); 2972 WebInputElement lastname = 2973 web_frame->document().getElementById("lastname").to<WebInputElement>(); 2974 lastname.setAutofilled(true); 2975 WebInputElement email = 2976 web_frame->document().getElementById("email").to<WebInputElement>(); 2977 email.setAutofilled(true); 2978 WebInputElement email2 = 2979 web_frame->document().getElementById("email2").to<WebInputElement>(); 2980 email2.setAutofilled(true); 2981 WebInputElement phone = 2982 web_frame->document().getElementById("phone").to<WebInputElement>(); 2983 phone.setAutofilled(true); 2984 2985 // Set the suggested values on all of the elements. 2986 firstname.setSuggestedValue(ASCIIToUTF16("Wyatt")); 2987 lastname.setSuggestedValue(ASCIIToUTF16("Earp")); 2988 email.setSuggestedValue(ASCIIToUTF16("wyatt (at) earp.com")); 2989 email2.setSuggestedValue(ASCIIToUTF16("wyatt (at) earp.com")); 2990 phone.setSuggestedValue(ASCIIToUTF16("650-777-9999")); 2991 2992 // Clear the previewed fields. 2993 EXPECT_TRUE(ClearPreviewedFormWithElement(firstname, true)); 2994 2995 // Fields with non-empty values are restored. 2996 EXPECT_EQ(ASCIIToUTF16("W"), firstname.value()); 2997 EXPECT_TRUE(firstname.suggestedValue().isEmpty()); 2998 EXPECT_TRUE(firstname.isAutofilled()); 2999 EXPECT_EQ(1, firstname.selectionStart()); 3000 EXPECT_EQ(1, firstname.selectionEnd()); 3001 3002 // Verify the previewed fields are cleared. 3003 EXPECT_TRUE(lastname.value().isEmpty()); 3004 EXPECT_TRUE(lastname.suggestedValue().isEmpty()); 3005 EXPECT_FALSE(lastname.isAutofilled()); 3006 EXPECT_TRUE(email.value().isEmpty()); 3007 EXPECT_TRUE(email.suggestedValue().isEmpty()); 3008 EXPECT_FALSE(email.isAutofilled()); 3009 EXPECT_TRUE(email2.value().isEmpty()); 3010 EXPECT_TRUE(email2.suggestedValue().isEmpty()); 3011 EXPECT_FALSE(email2.isAutofilled()); 3012 EXPECT_TRUE(phone.value().isEmpty()); 3013 EXPECT_TRUE(phone.suggestedValue().isEmpty()); 3014 EXPECT_FALSE(phone.isAutofilled()); 3015 } 3016 3017 TEST_F(FormAutofillTest, FormWithNodeIsAutofilled) { 3018 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 3019 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>" 3020 " <INPUT type=\"text\" id=\"lastname\"/>" 3021 " <INPUT type=\"text\" id=\"email\"/>" 3022 " <INPUT type=\"email\" id=\"email2\"/>" 3023 " <INPUT type=\"tel\" id=\"phone\"/>" 3024 " <INPUT type=\"submit\" value=\"Send\"/>" 3025 "</FORM>"); 3026 3027 WebFrame* web_frame = GetMainFrame(); 3028 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 3029 3030 FormCache form_cache; 3031 std::vector<FormData> forms; 3032 form_cache.ExtractForms(*web_frame, &forms); 3033 ASSERT_EQ(1U, forms.size()); 3034 3035 WebInputElement firstname = 3036 web_frame->document().getElementById("firstname").to<WebInputElement>(); 3037 3038 // Auto-filled attribute not set yet. 3039 EXPECT_FALSE(FormWithElementIsAutofilled(firstname)); 3040 3041 // Set the auto-filled attribute. 3042 firstname.setAutofilled(true); 3043 3044 EXPECT_TRUE(FormWithElementIsAutofilled(firstname)); 3045 } 3046 3047 // If we have multiple labels per id, the labels concatenated into label string. 3048 TEST_F(FormAutofillTest, MultipleLabelsPerElement) { 3049 std::vector<base::string16> labels, names, values; 3050 3051 labels.push_back(ASCIIToUTF16("First Name:")); 3052 names.push_back(ASCIIToUTF16("firstname")); 3053 values.push_back(ASCIIToUTF16("John")); 3054 3055 labels.push_back(ASCIIToUTF16("Last Name:")); 3056 names.push_back(ASCIIToUTF16("lastname")); 3057 values.push_back(ASCIIToUTF16("Smith")); 3058 3059 labels.push_back(ASCIIToUTF16("Email: xxx (at) yyy.com")); 3060 names.push_back(ASCIIToUTF16("email")); 3061 values.push_back(ASCIIToUTF16("john (at) example.com")); 3062 3063 ExpectLabels( 3064 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 3065 " <LABEL for=\"firstname\"> First Name: </LABEL>" 3066 " <LABEL for=\"firstname\"></LABEL>" 3067 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 3068 " <LABEL for=\"lastname\"></LABEL>" 3069 " <LABEL for=\"lastname\"> Last Name: </LABEL>" 3070 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 3071 " <LABEL for=\"email\"> Email: </LABEL>" 3072 " <LABEL for=\"email\"> xxx (at) yyy.com </LABEL>" 3073 " <INPUT type=\"text\" id=\"email\" value=\"john (at) example.com\"/>" 3074 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 3075 "</FORM>", 3076 labels, names, values); 3077 } 3078 3079 TEST_F(FormAutofillTest, ClickElement) { 3080 LoadHTML("<BUTTON id=\"link\">Button</BUTTON>" 3081 "<BUTTON name=\"button\">Button</BUTTON>"); 3082 WebFrame* frame = GetMainFrame(); 3083 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 3084 3085 // Successful retrieval by id. 3086 autofill::WebElementDescriptor clicker; 3087 clicker.retrieval_method = autofill::WebElementDescriptor::ID; 3088 clicker.descriptor = "link"; 3089 EXPECT_TRUE(ClickElement(frame->document(), clicker)); 3090 3091 // Successful retrieval by css selector. 3092 clicker.retrieval_method = autofill::WebElementDescriptor::CSS_SELECTOR; 3093 clicker.descriptor = "button[name=\"button\"]"; 3094 EXPECT_TRUE(ClickElement(frame->document(), clicker)); 3095 3096 // Unsuccessful retrieval due to invalid CSS selector. 3097 clicker.descriptor = "^*&"; 3098 EXPECT_FALSE(ClickElement(frame->document(), clicker)); 3099 3100 // Unsuccessful retrieval because element does not exist. 3101 clicker.descriptor = "#junk"; 3102 EXPECT_FALSE(ClickElement(frame->document(), clicker)); 3103 } 3104 3105 TEST_F(FormAutofillTest, SelectOneAsText) { 3106 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 3107 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 3108 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 3109 " <SELECT id=\"country\">" 3110 " <OPTION value=\"AF\">Afghanistan</OPTION>" 3111 " <OPTION value=\"AL\">Albania</OPTION>" 3112 " <OPTION value=\"DZ\">Algeria</OPTION>" 3113 " </SELECT>" 3114 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 3115 "</FORM>"); 3116 3117 WebFrame* frame = GetMainFrame(); 3118 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 3119 3120 // Set the value of the select-one. 3121 WebSelectElement select_element = 3122 frame->document().getElementById("country").to<WebSelectElement>(); 3123 select_element.setValue(WebString::fromUTF8("AL")); 3124 3125 WebVector<WebFormElement> forms; 3126 frame->document().forms(forms); 3127 ASSERT_EQ(1U, forms.size()); 3128 3129 FormData form; 3130 3131 // Extract the country select-one value as text. 3132 EXPECT_TRUE(WebFormElementToFormData( 3133 forms[0], WebFormControlElement(), autofill::REQUIRE_NONE, 3134 static_cast<autofill::ExtractMask>( 3135 autofill::EXTRACT_VALUE | autofill::EXTRACT_OPTION_TEXT), 3136 &form, NULL)); 3137 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 3138 EXPECT_EQ(GURL(frame->document().url()), form.origin); 3139 EXPECT_EQ(GURL("http://cnn.com"), form.action); 3140 3141 const std::vector<FormFieldData>& fields = form.fields; 3142 ASSERT_EQ(3U, fields.size()); 3143 3144 FormFieldData expected; 3145 3146 expected.name = ASCIIToUTF16("firstname"); 3147 expected.value = ASCIIToUTF16("John"); 3148 expected.form_control_type = "text"; 3149 expected.max_length = WebInputElement::defaultMaxLength(); 3150 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 3151 3152 expected.name = ASCIIToUTF16("lastname"); 3153 expected.value = ASCIIToUTF16("Smith"); 3154 expected.form_control_type = "text"; 3155 expected.max_length = WebInputElement::defaultMaxLength(); 3156 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 3157 3158 expected.name = ASCIIToUTF16("country"); 3159 expected.value = ASCIIToUTF16("Albania"); 3160 expected.form_control_type = "select-one"; 3161 expected.max_length = 0; 3162 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 3163 3164 form.fields.clear(); 3165 // Extract the country select-one value as value. 3166 EXPECT_TRUE(WebFormElementToFormData(forms[0], 3167 WebFormControlElement(), 3168 autofill::REQUIRE_NONE, 3169 autofill::EXTRACT_VALUE, 3170 &form, 3171 NULL)); 3172 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 3173 EXPECT_EQ(GURL(frame->document().url()), form.origin); 3174 EXPECT_EQ(GURL("http://cnn.com"), form.action); 3175 3176 ASSERT_EQ(3U, fields.size()); 3177 3178 expected.name = ASCIIToUTF16("firstname"); 3179 expected.value = ASCIIToUTF16("John"); 3180 expected.form_control_type = "text"; 3181 expected.max_length = WebInputElement::defaultMaxLength(); 3182 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]); 3183 3184 expected.name = ASCIIToUTF16("lastname"); 3185 expected.value = ASCIIToUTF16("Smith"); 3186 expected.form_control_type = "text"; 3187 expected.max_length = WebInputElement::defaultMaxLength(); 3188 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]); 3189 3190 expected.name = ASCIIToUTF16("country"); 3191 expected.value = ASCIIToUTF16("AL"); 3192 expected.form_control_type = "select-one"; 3193 expected.max_length = 0; 3194 EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]); 3195 } 3196 3197 } // namespace autofill 3198
