Autofill: Add some helper function to make getting elements by id less tedious.

chrome/renderer/autofill/form_autofill_browsertest.cc

 // 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"
@@ skipping 11 matching lines @@
 #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;
@@ skipping 53 matching lines @@
       return "CSS_SELECTOR";
     case WebElementDescriptor::ID:
       return "ID";
     case WebElementDescriptor::NONE:
       return "NONE";
   }
   NOTREACHED();
   return "UNKNOWN";
 }
 
-bool ClickElement(const blink::WebDocument& document,
+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 << ".";
@@ skipping 105 matching lines @@
     LoadHTML(html);
 
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache;
     std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
     ASSERT_EQ(1U, forms.size());
 
     // Get the input element we want to find.
-    WebElement element = web_frame->document().getElementById("firstname");
-    WebInputElement input_element = element.to<WebInputElement>();
+    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, autofill::REQUIRE_NONE));
     EXPECT_EQ(ASCIIToUTF16("TestForm"), form_data.name);
     EXPECT_EQ(GURL(web_frame->document().url()), form_data.origin);
     EXPECT_EQ(GURL("http://buh.com"), form_data.action);
 
@@ skipping 27 matching lines @@
       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 = GetMainFrame()->document().getElementById(
-        ASCIIToUTF16(field_case.name)).to<WebFormControlElement>();
+    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>();
+  }
+
   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();
 
@@ skipping 17 matching lines @@
   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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result1;
   WebFormControlElementToFormField(element, autofill::EXTRACT_NONE, &result1);
 
   FormFieldData expected;
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("element");
   expected.value = base::string16();
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, result1);
 
   FormFieldData result2;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebInputElement element = web_element.to<WebInputElement>();
+  WebInputElement element = GetInputElementById("element");
   element.setAutofilled(true);
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("checkbox");
-  WebInputElement element = web_element.to<WebInputElement>();
+  WebInputElement element = GetInputElementById("checkbox");
   element.setAutofilled(true);
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  web_element = frame->document().getElementById("radio");
-  element = web_element.to<WebInputElement>();
+  element = GetInputElementById("radio");
   element.setAutofilled(true);
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result1;
   WebFormControlElementToFormField(element, autofill::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);
@@ skipping 28 matching lines @@
   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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result_sans_value;
   WebFormControlElementToFormField(element, autofill::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, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result_sans_value;
   WebFormControlElementToFormField(element, autofill::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, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("hidden");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("hidden");
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  web_element = frame->document().getElementById("submit");
-  element = web_element.to<WebFormControlElement>();
+  element = GetFormControlElementById("submit");
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("password");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("password");
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 }
@@ skipping 51 matching lines @@
     { "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) {
-    WebElement web_element = frame->document().getElementById(
-        ASCIIToUTF16(test_cases[i].element_id));
-    WebFormControlElement element = web_element.to<WebFormControlElement>();
+    WebFormControlElement element =
+        GetFormControlElementById(ASCIIToUTF16(test_cases[i].element_id));
     FormFieldData result;
     WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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);
 
-  WebElement web_element = frame->document().getElementById("element");
-  WebFormControlElement element = web_element.to<WebFormControlElement>();
+  WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, autofill::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'/>"
@@ skipping 19 matching lines @@
            "    <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());
 
-  WebElement element = frame->document().getElementById("firstname");
-  WebInputElement input_element = element.to<WebInputElement>();
+  WebInputElement input_element = GetInputElementById("firstname");
 
   FormData form;
   FormFieldData field;
   EXPECT_TRUE(WebFormElementToFormData(forms[0],
                                        input_element,
                                        autofill::REQUIRE_NONE,
                                        autofill::EXTRACT_VALUE,
                                        &form,
                                        &field));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
@@ skipping 57 matching lines @@
   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());
 
-  WebElement element = frame->document().getElementById("firstname");
-  WebInputElement input_element = element.to<WebInputElement>();
+  WebInputElement input_element = GetInputElementById("firstname");
 
   FormData form;
   FormFieldData field;
   EXPECT_FALSE(WebFormElementToFormData(forms[0],
                                         input_element,
                                         autofill::REQUIRE_NONE,
                                         autofill::EXTRACT_VALUE,
                                         &form,
                                         &field));
 }
@@ skipping 329 matching lines @@
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
-  WebElement element = web_frame->document().getElementById("firstname");
-  WebInputElement input_element = element.to<WebInputElement>();
+  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,
                                                     autofill::REQUIRE_NONE));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 217 matching lines @@
        "textarea-nonempty",
        "Go\naway!",
        "",
        false,
        "some multi-\nline value",
        "Go\naway!"},
   };
   TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases),
                         FillForm, &GetValueWrapper);
   // Verify preview selection.
-  WebInputElement firstname = GetMainFrame()->document().
-      getElementById("firstname").to<WebInputElement>();
+  WebInputElement firstname = GetInputElementById("firstname");
   EXPECT_EQ(16, firstname.selectionStart());
   EXPECT_EQ(16, firstname.selectionEnd());
 }
 
 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.
@@ skipping 136 matching lines @@
        "Go\naway!",
        "",
        false,
        "suggested multi-\nline value",
        ""},
   };
   TestFormFillFunctions(kFormHtml, field_cases, arraysize(field_cases),
                         &PreviewForm, &GetSuggestedValueWrapper);
 
   // Verify preview selection.
-  WebInputElement firstname = GetMainFrame()->document().
-      getElementById("firstname").to<WebInputElement>();
+  WebInputElement firstname = GetInputElementById("firstname");
   EXPECT_EQ(0, firstname.selectionStart());
   EXPECT_EQ(19, firstname.selectionEnd());
 }
 
 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>"
@@ skipping 860 matching lines @@
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
-  WebElement element = web_frame->document().getElementById("firstname");
-  WebInputElement input_element = element.to<WebInputElement>();
+  WebInputElement input_element = GetInputElementById("firstname");
 
   // Find the form that contains the input element.
   FormData form;
   FormFieldData field;
   EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
                                                     &form,
                                                     &field,
                                                     autofill::REQUIRE_NONE));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 77 matching lines @@
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
-  WebElement element = web_frame->document().getElementById("firstname");
-  WebInputElement input_element = element.to<WebInputElement>();
+  WebInputElement input_element = GetInputElementById("firstname");
 
   // Find the form that contains the input element.
   FormData form;
   FormFieldData field;
   EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
                                                     &form,
                                                     &field,
                                                     autofill::REQUIRE_NONE));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 58 matching lines @@
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
-  WebElement element = web_frame->document().getElementById("firstname");
-  WebInputElement input_element = element.to<WebInputElement>();
+  WebInputElement input_element = GetInputElementById("firstname");
 
   // Find the form that contains the input element.
   FormData form;
   FormFieldData field;
   EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
                                                     &form,
                                                     &field,
                                                     autofill::REQUIRE_NONE));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 67 matching lines @@
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(2U, forms.size());
 
   // Get the input element we want to find.
-  WebElement element = web_frame->document().getElementById("apple");
-  WebInputElement input_element = element.to<WebInputElement>();
+  WebInputElement input_element = GetInputElementById("apple");
 
   // Find the form that contains the input element.
   FormData form;
   FormFieldData field;
   EXPECT_TRUE(FindFormAndFieldForFormControlElement(input_element,
                                                     &form,
                                                     &field,
                                                     autofill::REQUIRE_NONE));
   EXPECT_EQ(base::string16(), form.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 200 matching lines @@
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Get the input element we want to find.
-  WebElement element = web_frame->document().getElementById("firstname");
-  WebInputElement input_element = element.to<WebInputElement>();
+  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,
@@ skipping 92 matching lines @@
       "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Set the auto-filled attribute.
-  WebInputElement firstname =
-      web_frame->document().getElementById("firstname").to<WebInputElement>();
+  WebInputElement firstname = GetInputElementById("firstname");
   firstname.setAutofilled(true);
-  WebInputElement lastname =
-      web_frame->document().getElementById("lastname").to<WebInputElement>();
+  WebInputElement lastname = GetInputElementById("lastname");
   lastname.setAutofilled(true);
-  WebInputElement month =
-      web_frame->document().getElementById("month").to<WebInputElement>();
+  WebInputElement month = GetInputElementById("month");
   month.setAutofilled(true);
-  WebInputElement textarea =
-      web_frame->document().getElementById("textarea").to<WebInputElement>();
+  WebInputElement textarea = GetInputElementById("textarea");
   textarea.setAutofilled(true);
 
   // Set the value of the disabled text input element.
-  WebInputElement notenabled =
-      web_frame->document().getElementById("notenabled").to<WebInputElement>();
+  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 form2;
@@ skipping 76 matching lines @@
       "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Set the auto-filled attribute.
-  WebInputElement firstname =
-      web_frame->document().getElementById("firstname").to<WebInputElement>();
+  WebInputElement firstname = GetInputElementById("firstname");
   firstname.setAutofilled(true);
-  WebInputElement lastname =
-      web_frame->document().getElementById("lastname").to<WebInputElement>();
+  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));
@@ skipping 51 matching lines @@
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Set the auto-filled attribute.
-  WebInputElement firstname =
-      web_frame->document().getElementById("firstname").to<WebInputElement>();
+  WebInputElement firstname = GetInputElementById("firstname");
   firstname.setAutofilled(true);
-  WebInputElement lastname =
-      web_frame->document().getElementById("lastname").to<WebInputElement>();
+  WebInputElement lastname = GetInputElementById("lastname");
   lastname.setAutofilled(true);
-  WebInputElement email =
-      web_frame->document().getElementById("email").to<WebInputElement>();
+  WebInputElement email = GetInputElementById("email");
   email.setAutofilled(true);
-  WebInputElement email2 =
-      web_frame->document().getElementById("email2").to<WebInputElement>();
+  WebInputElement email2 = GetInputElementById("email2");
   email2.setAutofilled(true);
-  WebInputElement phone =
-      web_frame->document().getElementById("phone").to<WebInputElement>();
+  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));
@@ skipping 33 matching lines @@
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Set the auto-filled attribute.
-  WebInputElement firstname =
-      web_frame->document().getElementById("firstname").to<WebInputElement>();
+  WebInputElement firstname = GetInputElementById("firstname");
   firstname.setAutofilled(true);
-  WebInputElement lastname =
-      web_frame->document().getElementById("lastname").to<WebInputElement>();
+  WebInputElement lastname = GetInputElementById("lastname");
   lastname.setAutofilled(true);
-  WebInputElement email =
-      web_frame->document().getElementById("email").to<WebInputElement>();
+  WebInputElement email = GetInputElementById("email");
   email.setAutofilled(true);
-  WebInputElement email2 =
-      web_frame->document().getElementById("email2").to<WebInputElement>();
+  WebInputElement email2 = GetInputElementById("email2");
   email2.setAutofilled(true);
-  WebInputElement phone =
-      web_frame->document().getElementById("phone").to<WebInputElement>();
+  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"));
 
@@ skipping 33 matching lines @@
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Set the auto-filled attribute.
-  WebInputElement firstname =
-      web_frame->document().getElementById("firstname").to<WebInputElement>();
+  WebInputElement firstname = GetInputElementById("firstname");
   firstname.setAutofilled(true);
-  WebInputElement lastname =
-      web_frame->document().getElementById("lastname").to<WebInputElement>();
+  WebInputElement lastname = GetInputElementById("lastname");
   lastname.setAutofilled(true);
-  WebInputElement email =
-      web_frame->document().getElementById("email").to<WebInputElement>();
+  WebInputElement email = GetInputElementById("email");
   email.setAutofilled(true);
-  WebInputElement email2 =
-      web_frame->document().getElementById("email2").to<WebInputElement>();
+  WebInputElement email2 = GetInputElementById("email2");
   email2.setAutofilled(true);
-  WebInputElement phone =
-      web_frame->document().getElementById("phone").to<WebInputElement>();
+  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.
@@ skipping 34 matching lines @@
       "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache;
   std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
   ASSERT_EQ(1U, forms.size());
 
   // Set the autofilled attribute.
-  WebInputElement firstname =
-      web_frame->document().getElementById("firstname").to<WebInputElement>();
+  WebInputElement firstname = GetInputElementById("firstname");
   firstname.setAutofilled(false);
-  WebInputElement lastname =
-      web_frame->document().getElementById("lastname").to<WebInputElement>();
+  WebInputElement lastname = GetInputElementById("lastname");
   lastname.setAutofilled(true);
-  WebInputElement email =
-      web_frame->document().getElementById("email").to<WebInputElement>();
+  WebInputElement email = GetInputElementById("email");
   email.setAutofilled(true);
-  WebInputElement phone =
-      web_frame->document().getElementById("phone").to<WebInputElement>();
+  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());
@@ skipping 294 matching lines @@
       frame->document().all(), &fieldsets);
   ASSERT_EQ(0U, control_elements.size());
   ASSERT_EQ(0U, fieldsets.size());
 
   FormData form;
   EXPECT_FALSE(UnownedFormElementsAndFieldSetsToFormData(
       fieldsets, control_elements, dummy_origin, extract_mask, &form));
 }
 
 }  // namespace autofill