blob: 88d8994a424f5ce991acf4459c8ecd983fcbbb7b [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <vector>
#include "base/format_macros.h"
#include "base/strings/string16.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "chrome/test/base/chrome_render_view_test.h"
#include "components/autofill/content/renderer/form_autofill_util.h"
#include "components/autofill/content/renderer/form_cache.h"
#include "components/autofill/core/common/autofill_data_validation.h"
#include "components/autofill/core/common/form_data.h"
#include "components/autofill/core/common/web_element_descriptor.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/WebKit/public/platform/WebString.h"
#include "third_party/WebKit/public/platform/WebVector.h"
#include "third_party/WebKit/public/web/WebDocument.h"
#include "third_party/WebKit/public/web/WebElement.h"
#include "third_party/WebKit/public/web/WebElementCollection.h"
#include "third_party/WebKit/public/web/WebExceptionCode.h"
#include "third_party/WebKit/public/web/WebFormControlElement.h"
#include "third_party/WebKit/public/web/WebFormElement.h"
#include "third_party/WebKit/public/web/WebInputElement.h"
#include "third_party/WebKit/public/web/WebLocalFrame.h"
#include "third_party/WebKit/public/web/WebSelectElement.h"
#include "third_party/WebKit/public/web/WebTextAreaElement.h"
using base::ASCIIToUTF16;
using blink::WebDocument;
using blink::WebElement;
using blink::WebExceptionCode;
using blink::WebFormControlElement;
using blink::WebFormElement;
using blink::WebFrame;
using blink::WebInputElement;
using blink::WebSelectElement;
using blink::WebString;
using blink::WebTextAreaElement;
using blink::WebVector;
namespace autofill {
namespace {
struct AutofillFieldCase {
const char* const form_control_type;
const char* const name;
const char* const initial_value;
const char* const autocomplete_attribute; // The autocomplete attribute of
// the element.
bool should_be_autofilled; // Whether the filed should be autofilled.
const char* const autofill_value; // The value being used to fill the field.
const char* const expected_value; // The expected value after Autofill
// or Preview.
};
const char kFormHtml[] =
"<FORM name='TestForm' action='http://buh.com' method='post'>"
" <INPUT type='text' id='firstname'/>"
" <INPUT type='text' id='lastname'/>"
" <INPUT type='hidden' id='imhidden'/>"
" <INPUT type='text' id='notempty' value='Hi'/>"
" <INPUT type='text' autocomplete='off' id='noautocomplete'/>"
" <INPUT type='text' disabled='disabled' id='notenabled'/>"
" <INPUT type='text' readonly id='readonly'/>"
" <INPUT type='text' style='visibility: hidden'"
" id='invisible'/>"
" <INPUT type='text' style='display: none' id='displaynone'/>"
" <INPUT type='month' id='month'/>"
" <INPUT type='month' id='month-nonempty' value='2011-12'/>"
" <SELECT id='select'>"
" <OPTION></OPTION>"
" <OPTION value='CA'>California</OPTION>"
" <OPTION value='TX'>Texas</OPTION>"
" </SELECT>"
" <SELECT id='select-nonempty'>"
" <OPTION value='CA' selected>California</OPTION>"
" <OPTION value='TX'>Texas</OPTION>"
" </SELECT>"
" <SELECT id='select-unchanged'>"
" <OPTION value='CA' selected>California</OPTION>"
" <OPTION value='TX'>Texas</OPTION>"
" </SELECT>"
" <TEXTAREA id='textarea'></TEXTAREA>"
" <TEXTAREA id='textarea-nonempty'>Go&#10;away!</TEXTAREA>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>";
const char kUnownedFormHtml[] =
"<HEAD><TITLE>enter shipping info</TITLE></HEAD>"
"<INPUT type='text' id='firstname'/>"
"<INPUT type='text' id='lastname'/>"
"<INPUT type='hidden' id='imhidden'/>"
"<INPUT type='text' id='notempty' value='Hi'/>"
"<INPUT type='text' autocomplete='off' id='noautocomplete'/>"
"<INPUT type='text' disabled='disabled' id='notenabled'/>"
"<INPUT type='text' readonly id='readonly'/>"
"<INPUT type='text' style='visibility: hidden'"
" id='invisible'/>"
"<INPUT type='text' style='display: none' id='displaynone'/>"
"<INPUT type='month' id='month'/>"
"<INPUT type='month' id='month-nonempty' value='2011-12'/>"
"<SELECT id='select'>"
" <OPTION></OPTION>"
" <OPTION value='CA'>California</OPTION>"
" <OPTION value='TX'>Texas</OPTION>"
"</SELECT>"
"<SELECT id='select-nonempty'>"
" <OPTION value='CA' selected>California</OPTION>"
" <OPTION value='TX'>Texas</OPTION>"
"</SELECT>"
"<SELECT id='select-unchanged'>"
" <OPTION value='CA' selected>California</OPTION>"
" <OPTION value='TX'>Texas</OPTION>"
"</SELECT>"
"<TEXTAREA id='textarea'></TEXTAREA>"
"<TEXTAREA id='textarea-nonempty'>Go&#10;away!</TEXTAREA>"
"<INPUT type='submit' name='reply-send' value='Send'/>";
std::string RetrievalMethodToString(
const WebElementDescriptor::RetrievalMethod& method) {
switch (method) {
case WebElementDescriptor::CSS_SELECTOR:
return "CSS_SELECTOR";
case WebElementDescriptor::ID:
return "ID";
case WebElementDescriptor::NONE:
return "NONE";
}
NOTREACHED();
return "UNKNOWN";
}
bool ClickElement(const WebDocument& document,
const WebElementDescriptor& element_descriptor) {
WebString web_descriptor = WebString::fromUTF8(element_descriptor.descriptor);
blink::WebElement element;
switch (element_descriptor.retrieval_method) {
case WebElementDescriptor::CSS_SELECTOR: {
WebExceptionCode ec = 0;
element = document.querySelector(web_descriptor, ec);
if (ec)
DVLOG(1) << "Query selector failed. Error code: " << ec << ".";
break;
}
case WebElementDescriptor::ID:
element = document.getElementById(web_descriptor);
break;
case WebElementDescriptor::NONE:
return true;
}
if (element.isNull()) {
DVLOG(1) << "Could not find "
<< element_descriptor.descriptor
<< " by "
<< RetrievalMethodToString(element_descriptor.retrieval_method)
<< ".";
return false;
}
element.simulateClick();
return true;
}
} // namespace
class FormAutofillTest : public ChromeRenderViewTest {
public:
FormAutofillTest() : ChromeRenderViewTest() {}
~FormAutofillTest() override {}
void ExpectLabels(const char* html,
const std::vector<base::string16>& labels,
const std::vector<base::string16>& names,
const std::vector<base::string16>& values) {
std::vector<std::string> control_types(labels.size(), "text");
ExpectLabelsAndTypes(html, labels, names, values, control_types);
}
void ExpectLabelsAndTypes(const char* html,
const std::vector<base::string16>& labels,
const std::vector<base::string16>& names,
const std::vector<base::string16>& values,
const std::vector<std::string>& control_types) {
ASSERT_EQ(labels.size(), names.size());
ASSERT_EQ(labels.size(), values.size());
ASSERT_EQ(labels.size(), control_types.size());
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
const FormData& form = forms[0];
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
EXPECT_EQ(GURL("http://cnn.com"), form.action);
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(labels.size(), fields.size());
for (size_t i = 0; i < labels.size(); ++i) {
int max_length = control_types[i] == "text" ?
WebInputElement::defaultMaxLength() : 0;
FormFieldData expected;
expected.label = labels[i];
expected.name = names[i];
expected.value = values[i];
expected.form_control_type = control_types[i];
expected.max_length = max_length;
SCOPED_TRACE(base::StringPrintf("i: %" PRIuS, i));
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[i]);
}
}
void ExpectJohnSmithLabels(const char* html) {
std::vector<base::string16> labels, names, values;
labels.push_back(ASCIIToUTF16("First name:"));
names.push_back(ASCIIToUTF16("firstname"));
values.push_back(ASCIIToUTF16("John"));
labels.push_back(ASCIIToUTF16("Last name:"));
names.push_back(ASCIIToUTF16("lastname"));
values.push_back(ASCIIToUTF16("Smith"));
labels.push_back(ASCIIToUTF16("Email:"));
names.push_back(ASCIIToUTF16("email"));
values.push_back(ASCIIToUTF16("john@example.com"));
ExpectLabels(html, labels, names, values);
}
typedef void (*FillFormFunction)(const FormData& form,
const WebFormControlElement& element);
typedef WebString (*GetValueFunction)(WebFormControlElement element);
// Test FormFillxxx functions.
void TestFormFillFunctions(const char* html,
bool unowned,
const AutofillFieldCase* field_cases,
size_t number_of_field_cases,
FillFormFunction fill_form_function,
GetValueFunction get_value_function) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Get the input element we want to find.
WebInputElement input_element = GetInputElementById("firstname");
// Find the form that contains the input element.
FormData form_data;
FormFieldData field;
EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element, &form_data,
&field));
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form_data.name);
EXPECT_EQ(GURL("http://buh.com"), form_data.action);
}
const std::vector<FormFieldData>& fields = form_data.fields;
ASSERT_EQ(number_of_field_cases, fields.size());
FormFieldData expected;
// Verify field's initial value.
for (size_t i = 0; i < number_of_field_cases; ++i) {
SCOPED_TRACE(base::StringPrintf("Verify initial value for field %s",
field_cases[i].name));
expected.form_control_type = field_cases[i].form_control_type;
expected.max_length =
expected.form_control_type == "text" ?
WebInputElement::defaultMaxLength() : 0;
expected.name = ASCIIToUTF16(field_cases[i].name);
expected.value = ASCIIToUTF16(field_cases[i].initial_value);
expected.autocomplete_attribute = field_cases[i].autocomplete_attribute;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[i]);
// Fill the form_data for the field.
form_data.fields[i].value = ASCIIToUTF16(field_cases[i].autofill_value);
// Set the is_autofilled property for the field.
form_data.fields[i].is_autofilled = field_cases[i].should_be_autofilled;
}
// Autofill the form using the given fill form function.
fill_form_function(form_data, input_element);
// Validate Autofill or Preview results.
for (size_t i = 0; i < number_of_field_cases; ++i) {
ValidateFilledField(field_cases[i], get_value_function);
}
}
// Validate an Autofilled field.
void ValidateFilledField(const AutofillFieldCase& field_case,
GetValueFunction get_value_function) {
SCOPED_TRACE(base::StringPrintf("Verify autofilled value for field %s",
field_case.name));
WebString value;
WebFormControlElement element =
GetFormControlElementById(ASCIIToUTF16(field_case.name));
if ((element.formControlType() == "select-one") ||
(element.formControlType() == "textarea")) {
value = get_value_function(element);
} else {
ASSERT_TRUE(element.formControlType() == "text" ||
element.formControlType() == "month");
value = get_value_function(element);
}
const WebString expected_value = ASCIIToUTF16(field_case.expected_value);
if (expected_value.isEmpty())
EXPECT_TRUE(value.isEmpty());
else
EXPECT_EQ(expected_value.utf8(), value.utf8());
EXPECT_EQ(field_case.should_be_autofilled, element.isAutofilled());
}
WebFormControlElement GetFormControlElementById(const WebString& id) {
return GetMainFrame()->document().getElementById(
id).to<WebFormControlElement>();
}
WebInputElement GetInputElementById(const WebString& id) {
return GetMainFrame()->document().getElementById(
id).to<WebInputElement>();
}
void TestFillForm(const char* html, bool unowned) {
static const AutofillFieldCase field_cases[] = {
// fields: form_control_type, name, initial_value, autocomplete_attribute,
// should_be_autofilled, autofill_value, expected_value
// Regular empty fields (firstname & lastname) should be autofilled.
{"text",
"firstname",
"",
"",
true,
"filled firstname",
"filled firstname"},
{"text", "lastname", "", "", true, "filled lastname", "filled lastname"},
// hidden fields should not be extracted to form_data.
// Non empty fields should not be autofilled.
{"text", "notempty", "Hi", "", false, "filled notempty", "Hi"},
{"text",
"noautocomplete",
"",
"off",
true,
"filled noautocomplete",
"filled noautocomplete"},
// Disabled fields should not be autofilled.
{"text", "notenabled", "", "", false, "filled notenabled", ""},
// Readonly fields should not be autofilled.
{"text", "readonly", "", "", false, "filled readonly", ""},
// Fields with "visibility: hidden" should not be autofilled.
{"text", "invisible", "", "", false, "filled invisible", ""},
// Fields with "display:none" should not be autofilled.
{"text", "displaynone", "", "", false, "filled displaynone", ""},
// Regular <input type="month"> should be autofilled.
{"month", "month", "", "", true, "2017-11", "2017-11"},
// Non-empty <input type="month"> should not be autofilled.
{"month", "month-nonempty", "2011-12", "", false, "2017-11", "2011-12"},
// Regular select fields should be autofilled.
{"select-one", "select", "", "", true, "TX", "TX"},
// Select fields should be autofilled even if they already have a
// non-empty value.
{"select-one", "select-nonempty", "CA", "", true, "TX", "TX"},
// Select fields should not be autofilled if no new value is passed from
// autofill profile. The existing value should not be overriden.
{"select-one", "select-unchanged", "CA", "", false, "CA", "CA"},
// Regular textarea elements should be autofilled.
{"textarea",
"textarea",
"",
"",
true,
"some multi-\nline value",
"some multi-\nline value"},
// Non-empty textarea elements should not be autofilled.
{"textarea",
"textarea-nonempty",
"Go\naway!",
"",
false,
"some multi-\nline value",
"Go\naway!"},
};
TestFormFillFunctions(html, unowned, field_cases, arraysize(field_cases),
FillForm, &GetValueWrapper);
// Verify preview selection.
WebInputElement firstname = GetInputElementById("firstname");
EXPECT_EQ(16, firstname.selectionStart());
EXPECT_EQ(16, firstname.selectionEnd());
}
void TestPreviewForm(const char* html, bool unowned) {
static const AutofillFieldCase field_cases[] = {
// Normal empty fields should be previewed.
{"text",
"firstname",
"",
"",
true,
"suggested firstname",
"suggested firstname"},
{"text",
"lastname",
"",
"",
true,
"suggested lastname",
"suggested lastname"},
// Hidden fields should not be extracted to form_data.
// Non empty fields should not be previewed.
{"text", "notempty", "Hi", "", false, "suggested notempty", ""},
{"text",
"noautocomplete",
"",
"off",
true,
"filled noautocomplete",
"filled noautocomplete"},
// Disabled fields should not be previewed.
{"text", "notenabled", "", "", false, "suggested notenabled", ""},
// Readonly fields should not be previewed.
{"text", "readonly", "", "", false, "suggested readonly", ""},
// Fields with "visibility: hidden" should not be previewed.
{"text", "invisible", "", "", false, "suggested invisible", ""},
// Fields with "display:none" should not previewed.
{"text", "displaynone", "", "", false, "suggested displaynone", ""},
// Regular <input type="month"> should be previewed.
{"month", "month", "", "", true, "2017-11", "2017-11"},
// Non-empty <input type="month"> should not be previewed.
{"month", "month-nonempty", "2011-12", "", false, "2017-11", ""},
// Regular select fields should be previewed.
{"select-one", "select", "", "", true, "TX", "TX"},
// Select fields should be previewed even if they already have a
// non-empty value.
{"select-one", "select-nonempty", "CA", "", true, "TX", "TX"},
// Select fields should not be previewed if no suggestion is passed from
// autofill profile.
{"select-one", "select-unchanged", "CA", "", false, "", ""},
// Normal textarea elements should be previewed.
{"textarea",
"textarea",
"",
"",
true,
"suggested multi-\nline value",
"suggested multi-\nline value"},
// Nonempty textarea elements should not be previewed.
{"textarea",
"textarea-nonempty",
"Go\naway!",
"",
false,
"suggested multi-\nline value",
""},
};
TestFormFillFunctions(html, unowned, field_cases, arraysize(field_cases),
&PreviewForm, &GetSuggestedValueWrapper);
// Verify preview selection.
WebInputElement firstname = GetInputElementById("firstname");
EXPECT_EQ(0, firstname.selectionStart());
EXPECT_EQ(19, firstname.selectionEnd());
}
void TestFindFormForInputElement(const char* html, bool unowned) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Get the input element we want to find.
WebInputElement input_element = GetInputElementById("firstname");
// Find the form and verify it's the correct form.
FormData form;
FormFieldData field;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form, &field));
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL("http://buh.com"), form.action);
}
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(4U, fields.size());
FormFieldData expected;
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("John");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Smith");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
expected.value = ASCIIToUTF16("john@example.com");
expected.autocomplete_attribute = "off";
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
expected.autocomplete_attribute.clear();
expected.name = ASCIIToUTF16("phone");
expected.value = ASCIIToUTF16("1.800.555.1234");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
}
void TestFindFormForTextAreaElement(const char* html, bool unowned) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Get the textarea element we want to find.
WebElement element = web_frame->document().getElementById("street-address");
WebTextAreaElement textarea_element = element.to<WebTextAreaElement>();
// Find the form and verify it's the correct form.
FormData form;
FormFieldData field;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(textarea_element, &form, &field));
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL("http://buh.com"), form.action);
}
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(4U, fields.size());
FormFieldData expected;
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("John");
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Smith");
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
expected.value = ASCIIToUTF16("john@example.com");
expected.autocomplete_attribute = "off";
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
expected.autocomplete_attribute.clear();
expected.name = ASCIIToUTF16("street-address");
expected.value = ASCIIToUTF16("123 Fantasy Ln.\nApt. 42");
expected.form_control_type = "textarea";
expected.max_length = 0;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
}
void TestFillFormMaxLength(const char* html, bool unowned) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Get the input element we want to find.
WebInputElement input_element = GetInputElementById("firstname");
// Find the form that contains the input element.
FormData form;
FormFieldData field;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form, &field));
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL("http://buh.com"), form.action);
}
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(3U, fields.size());
FormFieldData expected;
expected.form_control_type = "text";
expected.name = ASCIIToUTF16("firstname");
expected.max_length = 5;
expected.is_autofilled = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.max_length = 7;
expected.is_autofilled = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
expected.max_length = 9;
expected.is_autofilled = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
// Fill the form.
form.fields[0].value = ASCIIToUTF16("Brother");
form.fields[1].value = ASCIIToUTF16("Jonathan");
form.fields[2].value = ASCIIToUTF16("brotherj@example.com");
form.fields[0].is_autofilled = true;
form.fields[1].is_autofilled = true;
form.fields[2].is_autofilled = true;
FillForm(form, input_element);
// Find the newly-filled form that contains the input element.
FormData form2;
FormFieldData field2;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form2, &field2));
EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
EXPECT_EQ(GURL("http://buh.com"), form2.action);
}
const std::vector<FormFieldData>& fields2 = form2.fields;
ASSERT_EQ(3U, fields2.size());
expected.form_control_type = "text";
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("Broth");
expected.max_length = 5;
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Jonatha");
expected.max_length = 7;
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
expected.name = ASCIIToUTF16("email");
expected.value = ASCIIToUTF16("brotherj@");
expected.max_length = 9;
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
}
void TestFillFormNegativeMaxLength(const char* html, bool unowned) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Get the input element we want to find.
WebInputElement input_element = GetInputElementById("firstname");
// Find the form that contains the input element.
FormData form;
FormFieldData field;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form, &field));
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL("http://buh.com"), form.action);
}
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(3U, fields.size());
FormFieldData expected;
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("firstname");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
// Fill the form.
form.fields[0].value = ASCIIToUTF16("Brother");
form.fields[1].value = ASCIIToUTF16("Jonathan");
form.fields[2].value = ASCIIToUTF16("brotherj@example.com");
FillForm(form, input_element);
// Find the newly-filled form that contains the input element.
FormData form2;
FormFieldData field2;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form2, &field2));
EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
EXPECT_EQ(GURL("http://buh.com"), form2.action);
}
const std::vector<FormFieldData>& fields2 = form2.fields;
ASSERT_EQ(3U, fields2.size());
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("Brother");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Jonathan");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
expected.value = ASCIIToUTF16("brotherj@example.com");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
}
void TestFillFormEmptyName(const char* html, bool unowned) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Get the input element we want to find.
WebInputElement input_element = GetInputElementById("firstname");
// Find the form that contains the input element.
FormData form;
FormFieldData field;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form, &field));
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL("http://buh.com"), form.action);
}
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(3U, fields.size());
FormFieldData expected;
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("firstname");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
// Fill the form.
form.fields[0].value = ASCIIToUTF16("Wyatt");
form.fields[1].value = ASCIIToUTF16("Earp");
form.fields[2].value = ASCIIToUTF16("wyatt@example.com");
FillForm(form, input_element);
// Find the newly-filled form that contains the input element.
FormData form2;
FormFieldData field2;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form2, &field2));
EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
EXPECT_EQ(GURL("http://buh.com"), form2.action);
}
const std::vector<FormFieldData>& fields2 = form2.fields;
ASSERT_EQ(3U, fields2.size());
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("Wyatt");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Earp");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
expected.value = ASCIIToUTF16("wyatt@example.com");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
}
void TestFillFormEmptyFormNames(const char* html, bool unowned) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
const size_t expected_size = unowned ? 1 : 2;
ASSERT_EQ(expected_size, forms.size());
// Get the input element we want to find.
WebInputElement input_element = GetInputElementById("apple");
// Find the form that contains the input element.
FormData form;
FormFieldData field;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form, &field));
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
if (!unowned) {
EXPECT_TRUE(form.name.empty());
EXPECT_EQ(GURL("http://abc.com"), form.action);
}
const std::vector<FormFieldData>& fields = form.fields;
const size_t unowned_offset = unowned ? 3 : 0;
ASSERT_EQ(unowned_offset + 3, fields.size());
FormFieldData expected;
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("apple");
expected.is_autofilled = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[unowned_offset]);
expected.name = ASCIIToUTF16("banana");
expected.is_autofilled = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[unowned_offset + 1]);
expected.name = ASCIIToUTF16("cantelope");
expected.is_autofilled = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[unowned_offset + 2]);
// Fill the form.
form.fields[unowned_offset + 0].value = ASCIIToUTF16("Red");
form.fields[unowned_offset + 1].value = ASCIIToUTF16("Yellow");
form.fields[unowned_offset + 2].value = ASCIIToUTF16("Also Yellow");
form.fields[unowned_offset + 0].is_autofilled = true;
form.fields[unowned_offset + 1].is_autofilled = true;
form.fields[unowned_offset + 2].is_autofilled = true;
FillForm(form, input_element);
// Find the newly-filled form that contains the input element.
FormData form2;
FormFieldData field2;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form2, &field2));
EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
if (!unowned) {
EXPECT_TRUE(form2.name.empty());
EXPECT_EQ(GURL("http://abc.com"), form2.action);
}
const std::vector<FormFieldData>& fields2 = form2.fields;
ASSERT_EQ(unowned_offset + 3, fields2.size());
expected.name = ASCIIToUTF16("apple");
expected.value = ASCIIToUTF16("Red");
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[unowned_offset + 0]);
expected.name = ASCIIToUTF16("banana");
expected.value = ASCIIToUTF16("Yellow");
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[unowned_offset + 1]);
expected.name = ASCIIToUTF16("cantelope");
expected.value = ASCIIToUTF16("Also Yellow");
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[unowned_offset + 2]);
}
void TestFillFormNonEmptyField(const char* html, bool unowned) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Get the input element we want to find.
WebInputElement input_element = GetInputElementById("firstname");
// Simulate typing by modifying the field value.
input_element.setValue(ASCIIToUTF16("Wy"));
// Find the form that contains the input element.
FormData form;
FormFieldData field;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form, &field));
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL("http://buh.com"), form.action);
}
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(3U, fields.size());
FormFieldData expected;
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("Wy");
expected.is_autofilled = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value.clear();
expected.is_autofilled = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
expected.value.clear();
expected.is_autofilled = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
// Preview the form and verify that the cursor position has been updated.
form.fields[0].value = ASCIIToUTF16("Wyatt");
form.fields[1].value = ASCIIToUTF16("Earp");
form.fields[2].value = ASCIIToUTF16("wyatt@example.com");
form.fields[0].is_autofilled = true;
form.fields[1].is_autofilled = true;
form.fields[2].is_autofilled = true;
PreviewForm(form, input_element);
EXPECT_EQ(2, input_element.selectionStart());
EXPECT_EQ(5, input_element.selectionEnd());
// Fill the form.
FillForm(form, input_element);
// Find the newly-filled form that contains the input element.
FormData form2;
FormFieldData field2;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(input_element, &form2, &field2));
EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
EXPECT_EQ(GURL("http://buh.com"), form2.action);
}
const std::vector<FormFieldData>& fields2 = form2.fields;
ASSERT_EQ(3U, fields2.size());
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("Wyatt");
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Earp");
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
expected.name = ASCIIToUTF16("email");
expected.value = ASCIIToUTF16("wyatt@example.com");
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
// Verify that the cursor position has been updated.
EXPECT_EQ(5, input_element.selectionStart());
EXPECT_EQ(5, input_element.selectionEnd());
}
void TestClearFormWithNode(const char* html, bool unowned) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Set the auto-filled attribute.
WebInputElement firstname = GetInputElementById("firstname");
firstname.setAutofilled(true);
WebInputElement lastname = GetInputElementById("lastname");
lastname.setAutofilled(true);
WebInputElement month = GetInputElementById("month");
month.setAutofilled(true);
WebInputElement textarea = GetInputElementById("textarea");
textarea.setAutofilled(true);
// Set the value of the disabled text input element.
WebInputElement notenabled = GetInputElementById("notenabled");
notenabled.setValue(WebString::fromUTF8("no clear"));
// Clear the form.
EXPECT_TRUE(form_cache.ClearFormWithElement(firstname));
// Verify that the auto-filled attribute has been turned off.
EXPECT_FALSE(firstname.isAutofilled());
// Verify the form is cleared.
FormData form;
FormFieldData field;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(firstname, &form, &field));
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
EXPECT_FALSE(form.origin.is_empty());
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL("http://buh.com"), form.action);
}
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(9U, fields.size());
FormFieldData expected;
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("firstname");
expected.value.clear();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value.clear();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("noAC");
expected.value = ASCIIToUTF16("one");
expected.autocomplete_attribute = "off";
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
expected.autocomplete_attribute.clear();
expected.name = ASCIIToUTF16("notenabled");
expected.value = ASCIIToUTF16("no clear");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
expected.form_control_type = "month";
expected.max_length = 0;
expected.name = ASCIIToUTF16("month");
expected.value.clear();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[4]);
expected.name = ASCIIToUTF16("month-disabled");
expected.value = ASCIIToUTF16("2012-11");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[5]);
expected.form_control_type = "textarea";
expected.name = ASCIIToUTF16("textarea");
expected.value.clear();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[6]);
expected.name = ASCIIToUTF16("textarea-disabled");
expected.value = ASCIIToUTF16(" Banana! ");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[7]);
expected.name = ASCIIToUTF16("textarea-noAC");
expected.value = ASCIIToUTF16("Carrot?");
expected.autocomplete_attribute = "off";
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[8]);
expected.autocomplete_attribute.clear();
// Verify that the cursor position has been updated.
EXPECT_EQ(0, firstname.selectionStart());
EXPECT_EQ(0, firstname.selectionEnd());
}
void TestClearFormWithNodeContainingSelectOne(const char* html,
bool unowned) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Set the auto-filled attribute.
WebInputElement firstname = GetInputElementById("firstname");
firstname.setAutofilled(true);
WebInputElement lastname = GetInputElementById("lastname");
lastname.setAutofilled(true);
// Set the value and auto-filled attribute of the state element.
WebSelectElement state =
web_frame->document().getElementById("state").to<WebSelectElement>();
state.setValue(WebString::fromUTF8("AK"));
state.setAutofilled(true);
// Clear the form.
EXPECT_TRUE(form_cache.ClearFormWithElement(firstname));
// Verify that the auto-filled attribute has been turned off.
EXPECT_FALSE(firstname.isAutofilled());
// Verify the form is cleared.
FormData form;
FormFieldData field;
EXPECT_TRUE(
FindFormAndFieldForFormControlElement(firstname, &form, &field));
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
EXPECT_FALSE(form.origin.is_empty());
if (!unowned) {
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL("http://buh.com"), form.action);
}
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(3U, fields.size());
FormFieldData expected;
expected.name = ASCIIToUTF16("firstname");
expected.value.clear();
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value.clear();
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("state");
expected.value = ASCIIToUTF16("?");
expected.form_control_type = "select-one";
expected.max_length = 0;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
// Verify that the cursor position has been updated.
EXPECT_EQ(0, firstname.selectionStart());
EXPECT_EQ(0, firstname.selectionEnd());
}
void TestClearPreviewedFormWithElement(const char* html) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Set the auto-filled attribute.
WebInputElement firstname = GetInputElementById("firstname");
firstname.setAutofilled(true);
WebInputElement lastname = GetInputElementById("lastname");
lastname.setAutofilled(true);
WebInputElement email = GetInputElementById("email");
email.setAutofilled(true);
WebInputElement email2 = GetInputElementById("email2");
email2.setAutofilled(true);
WebInputElement phone = GetInputElementById("phone");
phone.setAutofilled(true);
// Set the suggested values on two of the elements.
lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
email2.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
phone.setSuggestedValue(ASCIIToUTF16("650-777-9999"));
// Clear the previewed fields.
EXPECT_TRUE(ClearPreviewedFormWithElement(lastname, false));
// Fields with empty suggestions suggestions are not modified.
EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.value());
EXPECT_TRUE(firstname.suggestedValue().isEmpty());
EXPECT_TRUE(firstname.isAutofilled());
// Verify the previewed fields are cleared.
EXPECT_TRUE(lastname.value().isEmpty());
EXPECT_TRUE(lastname.suggestedValue().isEmpty());
EXPECT_FALSE(lastname.isAutofilled());
EXPECT_TRUE(email.value().isEmpty());
EXPECT_TRUE(email.suggestedValue().isEmpty());
EXPECT_FALSE(email.isAutofilled());
EXPECT_TRUE(email2.value().isEmpty());
EXPECT_TRUE(email2.suggestedValue().isEmpty());
EXPECT_FALSE(email2.isAutofilled());
EXPECT_TRUE(phone.value().isEmpty());
EXPECT_TRUE(phone.suggestedValue().isEmpty());
EXPECT_FALSE(phone.isAutofilled());
// Verify that the cursor position has been updated.
EXPECT_EQ(0, lastname.selectionStart());
EXPECT_EQ(0, lastname.selectionEnd());
}
void TestClearPreviewedFormWithNonEmptyInitiatingNode(const char* html) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Set the auto-filled attribute.
WebInputElement firstname = GetInputElementById("firstname");
firstname.setAutofilled(true);
WebInputElement lastname = GetInputElementById("lastname");
lastname.setAutofilled(true);
WebInputElement email = GetInputElementById("email");
email.setAutofilled(true);
WebInputElement email2 = GetInputElementById("email2");
email2.setAutofilled(true);
WebInputElement phone = GetInputElementById("phone");
phone.setAutofilled(true);
// Set the suggested values on all of the elements.
firstname.setSuggestedValue(ASCIIToUTF16("Wyatt"));
lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
email2.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
phone.setSuggestedValue(ASCIIToUTF16("650-777-9999"));
// Clear the previewed fields.
EXPECT_TRUE(ClearPreviewedFormWithElement(firstname, false));
// Fields with non-empty values are restored.
EXPECT_EQ(ASCIIToUTF16("W"), firstname.value());
EXPECT_TRUE(firstname.suggestedValue().isEmpty());
EXPECT_FALSE(firstname.isAutofilled());
EXPECT_EQ(1, firstname.selectionStart());
EXPECT_EQ(1, firstname.selectionEnd());
// Verify the previewed fields are cleared.
EXPECT_TRUE(lastname.value().isEmpty());
EXPECT_TRUE(lastname.suggestedValue().isEmpty());
EXPECT_FALSE(lastname.isAutofilled());
EXPECT_TRUE(email.value().isEmpty());
EXPECT_TRUE(email.suggestedValue().isEmpty());
EXPECT_FALSE(email.isAutofilled());
EXPECT_TRUE(email2.value().isEmpty());
EXPECT_TRUE(email2.suggestedValue().isEmpty());
EXPECT_FALSE(email2.isAutofilled());
EXPECT_TRUE(phone.value().isEmpty());
EXPECT_TRUE(phone.suggestedValue().isEmpty());
EXPECT_FALSE(phone.isAutofilled());
}
void TestClearPreviewedFormWithAutofilledInitiatingNode(const char* html) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Set the auto-filled attribute.
WebInputElement firstname = GetInputElementById("firstname");
firstname.setAutofilled(true);
WebInputElement lastname = GetInputElementById("lastname");
lastname.setAutofilled(true);
WebInputElement email = GetInputElementById("email");
email.setAutofilled(true);
WebInputElement email2 = GetInputElementById("email2");
email2.setAutofilled(true);
WebInputElement phone = GetInputElementById("phone");
phone.setAutofilled(true);
// Set the suggested values on all of the elements.
firstname.setSuggestedValue(ASCIIToUTF16("Wyatt"));
lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
email2.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
phone.setSuggestedValue(ASCIIToUTF16("650-777-9999"));
// Clear the previewed fields.
EXPECT_TRUE(ClearPreviewedFormWithElement(firstname, true));
// Fields with non-empty values are restored.
EXPECT_EQ(ASCIIToUTF16("W"), firstname.value());
EXPECT_TRUE(firstname.suggestedValue().isEmpty());
EXPECT_TRUE(firstname.isAutofilled());
EXPECT_EQ(1, firstname.selectionStart());
EXPECT_EQ(1, firstname.selectionEnd());
// Verify the previewed fields are cleared.
EXPECT_TRUE(lastname.value().isEmpty());
EXPECT_TRUE(lastname.suggestedValue().isEmpty());
EXPECT_FALSE(lastname.isAutofilled());
EXPECT_TRUE(email.value().isEmpty());
EXPECT_TRUE(email.suggestedValue().isEmpty());
EXPECT_FALSE(email.isAutofilled());
EXPECT_TRUE(email2.value().isEmpty());
EXPECT_TRUE(email2.suggestedValue().isEmpty());
EXPECT_FALSE(email2.isAutofilled());
EXPECT_TRUE(phone.value().isEmpty());
EXPECT_TRUE(phone.suggestedValue().isEmpty());
EXPECT_FALSE(phone.isAutofilled());
}
void TestClearOnlyAutofilledFields(const char* html) {
LoadHTML(html);
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Set the autofilled attribute.
WebInputElement firstname = GetInputElementById("firstname");
firstname.setAutofilled(false);
WebInputElement lastname = GetInputElementById("lastname");
lastname.setAutofilled(true);
WebInputElement email = GetInputElementById("email");
email.setAutofilled(true);
WebInputElement phone = GetInputElementById("phone");
phone.setAutofilled(true);
// Clear the fields.
EXPECT_TRUE(form_cache.ClearFormWithElement(firstname));
// Verify only autofilled fields are cleared.
EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.value());
EXPECT_TRUE(firstname.suggestedValue().isEmpty());
EXPECT_FALSE(firstname.isAutofilled());
EXPECT_TRUE(lastname.value().isEmpty());
EXPECT_TRUE(lastname.suggestedValue().isEmpty());
EXPECT_FALSE(lastname.isAutofilled());
EXPECT_TRUE(email.value().isEmpty());
EXPECT_TRUE(email.suggestedValue().isEmpty());
EXPECT_FALSE(email.isAutofilled());
EXPECT_TRUE(phone.value().isEmpty());
EXPECT_TRUE(phone.suggestedValue().isEmpty());
EXPECT_FALSE(phone.isAutofilled());
}
static void FillFormIncludingNonFocusableElementsWrapper(
const FormData& form,
const WebFormControlElement& element) {
FillFormIncludingNonFocusableElements(form, element.form());
}
static WebString GetValueWrapper(WebFormControlElement element) {
if (element.formControlType() == "textarea")
return element.to<WebTextAreaElement>().value();
if (element.formControlType() == "select-one")
return element.to<WebSelectElement>().value();
return element.to<WebInputElement>().value();
}
static WebString GetSuggestedValueWrapper(WebFormControlElement element) {
if (element.formControlType() == "textarea")
return element.to<WebTextAreaElement>().suggestedValue();
if (element.formControlType() == "select-one")
return element.to<WebSelectElement>().suggestedValue();
return element.to<WebInputElement>().suggestedValue();
}
private:
DISALLOW_COPY_AND_ASSIGN(FormAutofillTest);
};
// We should be able to extract a normal text field.
TEST_F(FormAutofillTest, WebFormControlElementToFormField) {
LoadHTML("<INPUT type='text' id='element' value='value'/>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result1;
WebFormControlElementToFormField(element, EXTRACT_NONE, &result1);
FormFieldData expected;
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("element");
expected.value.clear();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1);
FormFieldData result2;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result2);
expected.name = ASCIIToUTF16("element");
expected.value = ASCIIToUTF16("value");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result2);
}
// We should be able to extract a text field with autocomplete="off".
TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutocompleteOff) {
LoadHTML("<INPUT type='text' id='element' value='value'"
" autocomplete='off'/>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
FormFieldData expected;
expected.name = ASCIIToUTF16("element");
expected.value = ASCIIToUTF16("value");
expected.form_control_type = "text";
expected.autocomplete_attribute = "off";
expected.max_length = WebInputElement::defaultMaxLength();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
}
// We should be able to extract a text field with maxlength specified.
TEST_F(FormAutofillTest, WebFormControlElementToFormFieldMaxLength) {
LoadHTML("<INPUT type='text' id='element' value='value'"
" maxlength='5'/>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
FormFieldData expected;
expected.name = ASCIIToUTF16("element");
expected.value = ASCIIToUTF16("value");
expected.form_control_type = "text";
expected.max_length = 5;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
}
// We should be able to extract a text field that has been autofilled.
TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutofilled) {
LoadHTML("<INPUT type='text' id='element' value='value'/>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebInputElement element = GetInputElementById("element");
element.setAutofilled(true);
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
FormFieldData expected;
expected.name = ASCIIToUTF16("element");
expected.value = ASCIIToUTF16("value");
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.is_autofilled = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
}
// We should be able to extract a radio or a checkbox field that has been
// autofilled.
TEST_F(FormAutofillTest, WebFormControlElementToClickableFormField) {
LoadHTML("<INPUT type='checkbox' id='checkbox' value='mail' checked/>"
"<INPUT type='radio' id='radio' value='male'/>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebInputElement element = GetInputElementById("checkbox");
element.setAutofilled(true);
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
FormFieldData expected;
expected.name = ASCIIToUTF16("checkbox");
expected.value = ASCIIToUTF16("mail");
expected.form_control_type = "checkbox";
expected.is_autofilled = true;
expected.is_checkable = true;
expected.is_checked = true;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
element = GetInputElementById("radio");
element.setAutofilled(true);
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
expected.name = ASCIIToUTF16("radio");
expected.value = ASCIIToUTF16("male");
expected.form_control_type = "radio";
expected.is_autofilled = true;
expected.is_checkable = true;
expected.is_checked = false;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
}
// We should be able to extract a <select> field.
TEST_F(FormAutofillTest, WebFormControlElementToFormFieldSelect) {
LoadHTML("<SELECT id='element'/>"
" <OPTION value='CA'>California</OPTION>"
" <OPTION value='TX'>Texas</OPTION>"
"</SELECT>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result1;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result1);
FormFieldData expected;
expected.name = ASCIIToUTF16("element");
expected.max_length = 0;
expected.form_control_type = "select-one";
expected.value = ASCIIToUTF16("CA");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1);
FormFieldData result2;
WebFormControlElementToFormField(
element,
static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTION_TEXT),
&result2);
expected.value = ASCIIToUTF16("California");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result2);
FormFieldData result3;
WebFormControlElementToFormField(element, EXTRACT_OPTIONS, &result3);
expected.value.clear();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result3);
ASSERT_EQ(2U, result3.option_values.size());
ASSERT_EQ(2U, result3.option_contents.size());
EXPECT_EQ(ASCIIToUTF16("CA"), result3.option_values[0]);
EXPECT_EQ(ASCIIToUTF16("California"), result3.option_contents[0]);
EXPECT_EQ(ASCIIToUTF16("TX"), result3.option_values[1]);
EXPECT_EQ(ASCIIToUTF16("Texas"), result3.option_contents[1]);
}
// When faced with <select> field with *many* options, we should trim them to a
// reasonable number.
TEST_F(FormAutofillTest, WebFormControlElementToFormFieldLongSelect) {
std::string html = "<SELECT id='element'/>";
for (size_t i = 0; i < 2 * kMaxListSize; ++i) {
html += base::StringPrintf("<OPTION value='%" PRIuS "'>"
"%" PRIuS "</OPTION>", i, i);
}
html += "</SELECT>";
LoadHTML(html.c_str());
WebFrame* frame = GetMainFrame();
ASSERT_TRUE(frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_OPTIONS, &result);
EXPECT_TRUE(result.option_values.empty());
EXPECT_TRUE(result.option_contents.empty());
}
// We should be able to extract a <textarea> field.
TEST_F(FormAutofillTest, WebFormControlElementToFormFieldTextArea) {
LoadHTML("<TEXTAREA id='element'>"
"This element's value&#10;"
"spans multiple lines."
"</TEXTAREA>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result_sans_value;
WebFormControlElementToFormField(element, EXTRACT_NONE, &result_sans_value);
FormFieldData expected;
expected.name = ASCIIToUTF16("element");
expected.max_length = 0;
expected.form_control_type = "textarea";
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_sans_value);
FormFieldData result_with_value;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result_with_value);
expected.value = ASCIIToUTF16("This element's value\n"
"spans multiple lines.");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_with_value);
}
// We should be able to extract an <input type="month"> field.
TEST_F(FormAutofillTest, WebFormControlElementToFormFieldMonthInput) {
LoadHTML("<INPUT type='month' id='element' value='2011-12'>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result_sans_value;
WebFormControlElementToFormField(element, EXTRACT_NONE, &result_sans_value);
FormFieldData expected;
expected.name = ASCIIToUTF16("element");
expected.max_length = 0;
expected.form_control_type = "month";
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_sans_value);
FormFieldData result_with_value;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result_with_value);
expected.value = ASCIIToUTF16("2011-12");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result_with_value);
}
// We should not extract the value for non-text and non-select fields.
TEST_F(FormAutofillTest, WebFormControlElementToFormFieldInvalidType) {
LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <INPUT type='hidden' id='hidden' value='apple'/>"
" <INPUT type='submit' id='submit' value='Send'/>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("hidden");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
FormFieldData expected;
expected.max_length = 0;
expected.name = ASCIIToUTF16("hidden");
expected.form_control_type = "hidden";
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
element = GetFormControlElementById("submit");
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
expected.name = ASCIIToUTF16("submit");
expected.form_control_type = "submit";
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
}
// We should be able to extract password fields.
TEST_F(FormAutofillTest, WebFormControlElementToPasswordFormField) {
LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <INPUT type='password' id='password' value='secret'/>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("password");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
FormFieldData expected;
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("password");
expected.form_control_type = "password";
expected.value = ASCIIToUTF16("secret");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
}
// We should be able to extract the autocompletetype attribute.
TEST_F(FormAutofillTest, WebFormControlElementToFormFieldAutocompletetype) {
std::string html =
"<INPUT type='text' id='absent'/>"
"<INPUT type='text' id='empty' autocomplete=''/>"
"<INPUT type='text' id='off' autocomplete='off'/>"
"<INPUT type='text' id='regular' autocomplete='email'/>"
"<INPUT type='text' id='multi-valued' "
" autocomplete='billing email'/>"
"<INPUT type='text' id='experimental' x-autocompletetype='email'/>"
"<INPUT type='month' id='month' autocomplete='cc-exp'/>"
"<SELECT id='select' autocomplete='state'/>"
" <OPTION value='CA'>California</OPTION>"
" <OPTION value='TX'>Texas</OPTION>"
"</SELECT>"
"<TEXTAREA id='textarea' autocomplete='street-address'>"
" Some multi-"
" lined value"
"</TEXTAREA>";
html +=
"<INPUT type='text' id='malicious' autocomplete='" +
std::string(10000, 'x') + "'/>";
LoadHTML(html.c_str());
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
struct TestCase {
const std::string element_id;
const std::string form_control_type;
const std::string autocomplete_attribute;
};
TestCase test_cases[] = {
// An absent attribute is equivalent to an empty one.
{ "absent", "text", "" },
// Make sure there are no issues parsing an empty attribute.
{ "empty", "text", "" },
// Make sure there are no issues parsing an attribute value that isn't a
// type hint.
{ "off", "text", "off" },
// Common case: exactly one type specified.
{ "regular", "text", "email" },
// Verify that we correctly extract multiple tokens as well.
{ "multi-valued", "text", "billing email" },
// Verify that <input type="month"> fields are supported.
{ "month", "month", "cc-exp" },
// We previously extracted this data from the experimental
// 'x-autocompletetype' attribute. Now that the field type hints are part
// of the spec under the autocomplete attribute, we no longer support the
// experimental version.
{ "experimental", "text", "" },
// <select> elements should behave no differently from text fields here.
{ "select", "select-one", "state" },
// <textarea> elements should also behave no differently from text fields.
{ "textarea", "textarea", "street-address" },
// Very long attribute values should be replaced by a default string, to
// prevent malicious websites from DOSing the browser process.
{ "malicious", "text", "x-max-data-length-exceeded" },
};
WebDocument document = frame->document();
for (size_t i = 0; i < arraysize(test_cases); ++i) {
WebFormControlElement element =
GetFormControlElementById(ASCIIToUTF16(test_cases[i].element_id));
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_NONE, &result);
FormFieldData expected;
expected.name = ASCIIToUTF16(test_cases[i].element_id);
expected.form_control_type = test_cases[i].form_control_type;
expected.autocomplete_attribute = test_cases[i].autocomplete_attribute;
if (test_cases[i].form_control_type == "text")
expected.max_length = WebInputElement::defaultMaxLength();
else
expected.max_length = 0;
SCOPED_TRACE(test_cases[i].element_id);
EXPECT_FORM_FIELD_DATA_EQUALS(expected, result);
}
}
TEST_F(FormAutofillTest, DetectTextDirectionFromDirectStyle) {
LoadHTML("<STYLE>input{direction:rtl}</STYLE>"
"<FORM>"
" <INPUT type='text' id='element'>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
}
TEST_F(FormAutofillTest, DetectTextDirectionFromDirectDIRAttribute) {
LoadHTML("<FORM>"
" <INPUT dir='rtl' type='text' id='element'/>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
}
TEST_F(FormAutofillTest, DetectTextDirectionFromParentStyle) {
LoadHTML("<STYLE>form{direction:rtl}</STYLE>"
"<FORM>"
" <INPUT type='text' id='element'/>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
}
TEST_F(FormAutofillTest, DetectTextDirectionFromParentDIRAttribute) {
LoadHTML("<FORM dir='rtl'>"
" <INPUT type='text' id='element'/>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
}
TEST_F(FormAutofillTest, DetectTextDirectionWhenStyleAndDIRAttributMixed) {
LoadHTML("<STYLE>input{direction:ltr}</STYLE>"
"<FORM dir='rtl'>"
" <INPUT type='text' id='element'/>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, result.text_direction);
}
TEST_F(FormAutofillTest,
DetectTextDirectionWhenParentHasBothDIRAttributeAndStyle) {
LoadHTML("<STYLE>form{direction:ltr}</STYLE>"
"<FORM dir='rtl'>"
" <INPUT type='text' id='element'/>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, result.text_direction);
}
TEST_F(FormAutofillTest, DetectTextDirectionWhenAncestorHasInlineStyle) {
LoadHTML("<FORM style='direction:ltr'>"
" <SPAN dir='rtl'>"
" <INPUT type='text' id='element'/>"
" </SPAN>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebFormControlElement element = GetFormControlElementById("element");
FormFieldData result;
WebFormControlElementToFormField(element, EXTRACT_VALUE, &result);
EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
}
TEST_F(FormAutofillTest, WebFormElementToFormData) {
LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <LABEL for='firstname'>First name:</LABEL>"
" <INPUT type='text' id='firstname' value='John'/>"
" <LABEL for='lastname'>Last name:</LABEL>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <LABEL for='street-address'>Address:</LABEL>"
" <TEXTAREA id='street-address'>"
"123 Fantasy Ln.&#10;"
"Apt. 42"
"</TEXTAREA>"
" <LABEL for='state'>State:</LABEL>"
" <SELECT id='state'/>"
" <OPTION value='CA'>California</OPTION>"
" <OPTION value='TX'>Texas</OPTION>"
" </SELECT>"
" <LABEL for='password'>Password:</LABEL>"
" <INPUT type='password' id='password' value='secret'/>"
" <LABEL for='month'>Card expiration:</LABEL>"
" <INPUT type='month' id='month' value='2011-12'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
// The below inputs should be ignored
" <LABEL for='notvisible'>Hidden:</LABEL>"
" <INPUT type='hidden' id='notvisible' value='apple'/>"
"</FORM>");
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebVector<WebFormElement> forms;
frame->document().forms(forms);
ASSERT_EQ(1U, forms.size());
WebInputElement input_element = GetInputElementById("firstname");
FormData form;
FormFieldData field;
EXPECT_TRUE(WebFormElementToFormData(forms[0],
input_element,
EXTRACT_VALUE,
&form,
&field));
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL(frame->document().url()), form.origin);
EXPECT_FALSE(form.origin.is_empty());
EXPECT_EQ(GURL("http://cnn.com"), form.action);
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(6U, fields.size());
FormFieldData expected;
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("John");
expected.label = ASCIIToUTF16("First name:");
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Smith");
expected.label = ASCIIToUTF16("Last name:");
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("street-address");
expected.value = ASCIIToUTF16("123 Fantasy Ln.\nApt. 42");
expected.label = ASCIIToUTF16("Address:");
expected.form_control_type = "textarea";
expected.max_length = 0;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
expected.name = ASCIIToUTF16("state");
expected.value = ASCIIToUTF16("CA");
expected.label = ASCIIToUTF16("State:");
expected.form_control_type = "select-one";
expected.max_length = 0;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
expected.name = ASCIIToUTF16("password");
expected.value = ASCIIToUTF16("secret");
expected.label = ASCIIToUTF16("Password:");
expected.form_control_type = "password";
expected.max_length = WebInputElement::defaultMaxLength();
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[4]);
expected.name = ASCIIToUTF16("month");
expected.value = ASCIIToUTF16("2011-12");
expected.label = ASCIIToUTF16("Card expiration:");
expected.form_control_type = "month";
expected.max_length = 0;
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[5]);
}
// We should not be able to serialize a form with too many fillable fields.
TEST_F(FormAutofillTest, WebFormElementToFormDataTooManyFields) {
std::string html =
"<FORM name='TestForm' action='http://cnn.com' method='post'>";
for (size_t i = 0; i < (kMaxParseableFields + 1); ++i) {
html += "<INPUT type='text'/>";
}
html += "</FORM>";
LoadHTML(html.c_str());
WebFrame* frame = GetMainFrame();
ASSERT_NE(nullptr, frame);
WebVector<WebFormElement> forms;
frame->document().forms(forms);
ASSERT_EQ(1U, forms.size());
WebInputElement input_element = GetInputElementById("firstname");
FormData form;
FormFieldData field;
EXPECT_FALSE(WebFormElementToFormData(forms[0],
input_element,
EXTRACT_VALUE,
&form,
&field));
}
TEST_F(FormAutofillTest, ExtractForms) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
" First name: <INPUT type='text' id='firstname' value='John'/>"
" Last name: <INPUT type='text' id='lastname' value='Smith'/>"
" Email: <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
}
TEST_F(FormAutofillTest, ExtractMultipleForms) {
LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <INPUT type='text' id='firstname' value='John'/>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>"
"<FORM name='TestForm2' action='http://zoo.com' method='post'>"
" <INPUT type='text' id='firstname' value='Jack'/>"
" <INPUT type='text' id='lastname' value='Adams'/>"
" <INPUT type='text' id='email' value='jack@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(2U, forms.size());
// First form.
const FormData& form = forms[0];
EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
EXPECT_FALSE(form.origin.is_empty());
EXPECT_EQ(GURL("http://cnn.com"), form.action);
const std::vector<FormFieldData>& fields = form.fields;
ASSERT_EQ(3U, fields.size());
FormFieldData expected;
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("John");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Smith");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
expected.value = ASCIIToUTF16("john@example.com");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
// Second form.
const FormData& form2 = forms[1];
EXPECT_EQ(ASCIIToUTF16("TestForm2"), form2.name);
EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
EXPECT_FALSE(form.origin.is_empty());
EXPECT_EQ(GURL("http://zoo.com"), form2.action);
const std::vector<FormFieldData>& fields2 = form2.fields;
ASSERT_EQ(3U, fields2.size());
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("Jack");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Adams");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
expected.name = ASCIIToUTF16("email");
expected.value = ASCIIToUTF16("jack@example.com");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
}
TEST_F(FormAutofillTest, OnlyExtractNewForms) {
LoadHTML(
"<FORM id='testform' action='http://cnn.com' method='post'>"
" <INPUT type='text' id='firstname' value='John'/>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
// Second call should give nothing as there are no new forms.
forms = form_cache.ExtractNewForms();
ASSERT_TRUE(forms.empty());
// Append to the current form will re-extract.
ExecuteJavaScript(
"var newInput = document.createElement('input');"
"newInput.setAttribute('type', 'text');"
"newInput.setAttribute('id', 'telephone');"
"newInput.value = '12345';"
"document.getElementById('testform').appendChild(newInput);");
msg_loop_.RunUntilIdle();
forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
const std::vector<FormFieldData>& fields = forms[0].fields;
ASSERT_EQ(4U, fields.size());
FormFieldData expected;
expected.form_control_type = "text";
expected.max_length = WebInputElement::defaultMaxLength();
expected.name = ASCIIToUTF16("firstname");
expected.value = ASCIIToUTF16("John");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[0]);
expected.name = ASCIIToUTF16("lastname");
expected.value = ASCIIToUTF16("Smith");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[1]);
expected.name = ASCIIToUTF16("email");
expected.value = ASCIIToUTF16("john@example.com");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
expected.name = ASCIIToUTF16("telephone");
expected.value = ASCIIToUTF16("12345");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[3]);
forms.clear();
// Completely new form will also be extracted.
ExecuteJavaScript(
"var newForm=document.createElement('form');"
"newForm.id='new_testform';"
"newForm.action='http://google.com';"
"newForm.method='post';"
"var newFirstname=document.createElement('input');"
"newFirstname.setAttribute('type', 'text');"
"newFirstname.setAttribute('id', 'second_firstname');"
"newFirstname.value = 'Bob';"
"var newLastname=document.createElement('input');"
"newLastname.setAttribute('type', 'text');"
"newLastname.setAttribute('id', 'second_lastname');"
"newLastname.value = 'Hope';"
"var newEmail=document.createElement('input');"
"newEmail.setAttribute('type', 'text');"
"newEmail.setAttribute('id', 'second_email');"
"newEmail.value = 'bobhope@example.com';"
"newForm.appendChild(newFirstname);"
"newForm.appendChild(newLastname);"
"newForm.appendChild(newEmail);"
"document.body.appendChild(newForm);");
msg_loop_.RunUntilIdle();
web_frame = GetMainFrame();
forms = form_cache.ExtractNewForms();
ASSERT_EQ(1U, forms.size());
const std::vector<FormFieldData>& fields2 = forms[0].fields;
ASSERT_EQ(3U, fields2.size());
expected.name = ASCIIToUTF16("second_firstname");
expected.value = ASCIIToUTF16("Bob");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
expected.name = ASCIIToUTF16("second_lastname");
expected.value = ASCIIToUTF16("Hope");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
expected.name = ASCIIToUTF16("second_email");
expected.value = ASCIIToUTF16("bobhope@example.com");
EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
}
// We should not extract a form if it has too few fillable fields.
TEST_F(FormAutofillTest, ExtractFormsTooFewFields) {
LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <INPUT type='text' id='firstname' value='John'/>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_TRUE(forms.empty());
}
// We should not report additional forms for empty forms.
TEST_F(FormAutofillTest, ExtractFormsSkippedForms) {
LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <INPUT type='text' id='firstname' value='John'/>"
" <INPUT type='text' id='lastname' value='Smith'/>"
"</FORM>");
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_TRUE(forms.empty());
}
// We should not report additional forms for empty forms.
TEST_F(FormAutofillTest, ExtractFormsNoFields) {
LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
"</FORM>");
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_TRUE(forms.empty());
}
// We should not extract a form if it has too few fillable fields.
// Make sure radio and checkbox fields don't count.
TEST_F(FormAutofillTest, ExtractFormsTooFewFieldsSkipsCheckable) {
LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <INPUT type='text' id='firstname' value='John'/>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <INPUT type='radio' id='a_radio' value='0'/>"
" <INPUT type='checkbox' id='a_check' value='1'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
FormCache form_cache(*web_frame);
std::vector<FormData> forms = form_cache.ExtractNewForms();
ASSERT_TRUE(forms.empty());
}
TEST_F(FormAutofillTest, WebFormElementToFormDataAutocomplete) {
{
// Form is still Autofill-able despite autocomplete=off.
LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'"
" autocomplete=off>"
" <INPUT type='text' id='firstname' value='John'/>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
WebFrame* web_frame = GetMainFrame();
ASSERT_NE(nullptr, web_frame);
WebVector<WebFormElement> web_forms;
web_frame->document().forms(web_forms);
ASSERT_EQ(1U, web_forms.size());
WebFormElement web_form = web_forms[0];
FormData form;
EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
EXTRACT_NONE, &form, nullptr));
}
}
TEST_F(FormAutofillTest, FindFormForInputElement) {
TestFindFormForInputElement(
"<FORM name='TestForm' action='http://buh.com' method='post'>"
" <INPUT type='text' id='firstname' value='John'/>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <INPUT type='text' id='email' value='john@example.com'"
"autocomplete='off' />"
" <INPUT type='text' id='phone' value='1.800.555.1234'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>",
false);
}
TEST_F(FormAutofillTest, FindFormForInputElementForUnownedForm) {
TestFindFormForInputElement(
"<HEAD><TITLE>delivery recipient</TITLE></HEAD>"
"<INPUT type='text' id='firstname' value='John'/>"
"<INPUT type='text' id='lastname' value='Smith'/>"
"<INPUT type='text' id='email' value='john@example.com'"
"autocomplete='off' />"
"<INPUT type='text' id='phone' value='1.800.555.1234'/>"
"<INPUT type='submit' name='reply-send' value='Send'/>",
true);
}
TEST_F(FormAutofillTest, FindFormForTextAreaElement) {
TestFindFormForTextAreaElement(
"<FORM name='TestForm' action='http://buh.com' method='post'>"
" <INPUT type='text' id='firstname' value='John'/>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <INPUT type='text' id='email' value='john@example.com'"
"autocomplete='off' />"
" <TEXTAREA id='street-address'>"
"123 Fantasy Ln.&#10;"
"Apt. 42"
"</TEXTAREA>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>",
false);
}
TEST_F(FormAutofillTest, FindFormForTextAreaElementForUnownedForm) {
TestFindFormForTextAreaElement(
"<HEAD><TITLE>delivery address</TITLE></HEAD>"
"<INPUT type='text' id='firstname' value='John'/>"
"<INPUT type='text' id='lastname' value='Smith'/>"
"<INPUT type='text' id='email' value='john@example.com'"
"autocomplete='off' />"
"<TEXTAREA id='street-address'>"
"123 Fantasy Ln.&#10;"
"Apt. 42"
"</TEXTAREA>"
"<INPUT type='submit' name='reply-send' value='Send'/>",
true);
}
// Test regular FillForm function.
TEST_F(FormAutofillTest, FillForm) {
TestFillForm(kFormHtml, false);
}
TEST_F(FormAutofillTest, FillFormForUnownedForm) {
TestFillForm(kUnownedFormHtml, true);
}
TEST_F(FormAutofillTest, FillFormIncludingNonFocusableElements) {
static const AutofillFieldCase field_cases[] = {
// fields: form_control_type, name, initial_value, autocomplete_attribute,
// should_be_autofilled, autofill_value, expected_value
// Regular empty fields (firstname & lastname) should be autofilled.
{"text",
"firstname",
"",
"",
true,
"filled firstname",
"filled firstname"},
{"text", "lastname", "", "", true, "filled lastname", "filled lastname"},
// hidden fields should not be extracted to form_data.
// Non empty fields should be overriden.
{"text",
"notempty",
"Hi",
"",
true,
"filled notempty",
"filled notempty"},
{"text",
"noautocomplete",
"",
"off",
true,
"filled noautocomplete",
"filled noautocomplete"},
// Disabled fields should not be autofilled.
{"text", "notenabled", "", "", false, "filled notenabled", ""},
// Readonly fields should not be autofilled.
{"text", "readonly", "", "", false, "filled readonly", ""},
// Fields with "visibility: hidden" should also be autofilled.
{"text",
"invisible",
"",
"",
true,
"filled invisible",
"filled invisible"},
// Fields with "display:none" should also be autofilled.
{"text",
"displaynone",
"",
"",
true,
"filled displaynone",
"filled displaynone"},
// Regular <input type="month"> should be autofilled.
{"month", "month", "", "", true, "2017-11", "2017-11"},
// Non-empty <input type="month"> should be overridden.
{"month", "month-nonempty", "2011-12", "", true, "2017-11", "2017-11"},
// Regular select fields should be autofilled.
{"select-one", "select", "", "", true, "TX", "TX"},
// Select fields should be autofilled even if they already have a
// non-empty value.
{"select-one", "select-nonempty", "CA", "", true, "TX", "TX"},
// Select fields should not be autofilled if no new value is passed from
// autofill profile. The existing value should not be overriden.
{"select-one", "select-unchanged", "CA", "", false, "CA", "CA"},
// Regular textarea elements should be autofilled.
{"textarea",
"textarea",
"",
"",
true,
"some multi-\nline value",
"some multi-\nline value"},
// Nonempty textarea elements should be overridden.
{"textarea",
"textarea-nonempty",
"Go\naway!",
"",
true,
"some multi-\nline value",
"some multi-\nline value"},
};
TestFormFillFunctions(kFormHtml, false, field_cases, arraysize(field_cases),
&FillFormIncludingNonFocusableElementsWrapper,
&GetValueWrapper);
}
TEST_F(FormAutofillTest, PreviewForm) {
TestPreviewForm(kFormHtml, false);
}
TEST_F(FormAutofillTest, PreviewFormForUnownedForm) {
TestPreviewForm(kUnownedFormHtml, true);
}
TEST_F(FormAutofillTest, Labels) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <LABEL for='firstname'> First name: </LABEL>"
" <INPUT type='text' id='firstname' value='John'/>"
" <LABEL for='lastname'> Last name: </LABEL>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <LABEL for='email'> Email: </LABEL>"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
}
TEST_F(FormAutofillTest, LabelsWithSpans) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <LABEL for='firstname'><span>First name: </span></LABEL>"
" <INPUT type='text' id='firstname' value='John'/>"
" <LABEL for='lastname'><span>Last name: </span></LABEL>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <LABEL for='email'><span>Email: </span></LABEL>"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
}
// This test is different from FormAutofillTest.Labels in that the label
// elements for= attribute is set to the name of the form control element it is
// a label for instead of the id of the form control element. This is invalid
// because the for= attribute must be set to the id of the form control element;
// however, current label parsing code will extract the text from the previous
// label element and apply it to the following input field.
TEST_F(FormAutofillTest, InvalidLabels) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <LABEL for='firstname'> First name: </LABEL>"
" <INPUT type='text' name='firstname' value='John'/>"
" <LABEL for='lastname'> Last name: </LABEL>"
" <INPUT type='text' name='lastname' value='Smith'/>"
" <LABEL for='email'> Email: </LABEL>"
" <INPUT type='text' name='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
}
// This test has three form control elements, only one of which has a label
// element associated with it.
TEST_F(FormAutofillTest, OneLabelElement) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
" First name:"
" <INPUT type='text' id='firstname' value='John'/>"
" <LABEL for='lastname'>Last name: </LABEL>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" Email:"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
}
TEST_F(FormAutofillTest, LabelsInferredFromText) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
" First name:"
" <INPUT type='text' id='firstname' value='John'/>"
" Last name:"
" <INPUT type='text' id='lastname' value='Smith'/>"
" Email:"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
}
TEST_F(FormAutofillTest, LabelsInferredFromParagraph) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <P>First name:</P><INPUT type='text' "
" id='firstname' value='John'/>"
" <P>Last name:</P>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <P>Email:</P>"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
}
TEST_F(FormAutofillTest, LabelsInferredFromBold) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
" <B>First name:</B><INPUT type='text' "
" id='firstname' value='John'/>"
" <B>Last name:</B>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" <B>Email:</B>"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
}
TEST_F(FormAutofillTest, LabelsInferredPriorToImgOrBr) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
" First name:<IMG/><INPUT type='text' "
" id='firstname' value='John'/>"
" Last name:<IMG/>"
" <INPUT type='text' id='lastname' value='Smith'/>"
" Email:<BR/>"
" <INPUT type='text' id='email' value='john@example.com'/>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
"</FORM>");
}
TEST_F(FormAutofillTest, LabelsInferredFromTableCell) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
"<TABLE>"
" <TR>"
" <TD>First name:</TD>"
" <TD><INPUT type='text' id='firstname' value='John'/></TD>"
" </TR>"
" <TR>"
" <TD>Last name:</TD>"
" <TD><INPUT type='text' id='lastname' value='Smith'/></TD>"
" </TR>"
" <TR>"
" <TD>Email:</TD>"
" <TD><INPUT type='text' id='email'"
" value='john@example.com'/></TD>"
" </TR>"
" <TR>"
" <TD></TD>"
" <TD>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
" </TD>"
" </TR>"
"</TABLE>"
"</FORM>");
}
TEST_F(FormAutofillTest, LabelsInferredFromTableCellTH) {
ExpectJohnSmithLabels(
"<FORM name='TestForm' action='http://cnn.com' method='post'>"
"<TABLE>"
" <TR>"
" <TH>First name:</TH>"
" <TD><INPUT type='text' id='firstname' value='John'/></TD>"
" </TR>"
" <TR>"
" <TH>Last name:</TH>"
" <TD><INPUT type='text' id='lastname' value='Smith'/></TD>"
" </TR>"
" <TR>"
" <TH>Email:</TH>"
" <TD><INPUT type='text' id='email'"
" value='john@example.com'/></TD>"
" </TR>"
" <TR>"
" <TD></TD>"
" <TD>"
" <INPUT type='submit' name='reply-send' value='Send'/>"
" </TD>"
" </TR>"
"</TABLE>"
"</FORM>");
}
TEST_F(FormAutofillTest, LabelsInferredFromTableCellNested) {
std::vector<base::string16> labels, names, values;
labels.push_back(ASCIIToUTF16("First name: Bogus"));
names.push_back(ASCIIToUTF16("firstname"));
values.push_back(ASCIIToUTF16("John"));
labels.push_back(ASCIIToUTF16("Last name:"));
names.push_back(ASCIIToUTF16("lastname"));
values.push_back(ASCIIToUTF16("Smith"