Move GetDocument method from WebFrame to WebLocalFrame.

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 <stddef.h>
 
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/macros.h"
@@ skipping 18 matching lines @@
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebSelectElement.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::WebLocalFrame;
 using blink::WebSelectElement;
 using blink::WebString;
 using blink::WebVector;
 
 namespace autofill {
 namespace form_util {
 
 namespace {
 
 struct AutofillFieldCase {
@@ skipping 232 matching lines @@
                             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();
+    WebLocalFrame* 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(GetCanonicalOriginForDocument(web_frame->GetDocument()),
               form.origin);
@@ skipping 44 matching lines @@
                              const char* url_override,
                              const AutofillFieldCase* field_cases,
                              size_t number_of_field_cases,
                              FillFormFunction fill_form_function,
                              GetValueFunction get_value_function) {
     if (url_override)
       LoadHTMLWithUrlOverride(html, url_override);
     else
       LoadHTML(html);
 
-    WebFrame* web_frame = GetMainFrame();
+    WebLocalFrame* 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.
@@ skipping 232 matching lines @@
     EXPECT_EQ(0, firstname.SelectionStart());
     EXPECT_EQ(19, firstname.SelectionEnd());
   }
 
   void TestUnmatchedUnownedForm(const char* html, const char* url_override) {
     if (url_override)
       LoadHTMLWithUrlOverride(html, url_override);
     else
       LoadHTML(html);
 
-    WebFrame* web_frame = GetMainFrame();
+    WebLocalFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
     std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(0U, forms.size());
   }
 
   void TestFindFormForInputElement(const char* html, bool unowned) {
     LoadHTML(html);
-    WebFrame* web_frame = GetMainFrame();
+    WebLocalFrame* 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.
@@ skipping 34 matching lines @@
     expected.autocomplete_attribute.clear();
 
     expected.name = ASCIIToUTF16("phone");
     expected.value = ASCIIToUTF16("1.800.555.1234");
     expected.label = 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();
+    WebLocalFrame* 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->GetDocument().GetElementById("street-address");
     WebFormControlElement textarea_element =
@@ skipping 43 matching lines @@
     expected.value = ASCIIToUTF16("123 Fantasy Ln.\nApt. 42");
     expected.label.clear();
     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();
+    WebLocalFrame* 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.
@@ skipping 69 matching lines @@
 
     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();
+    WebLocalFrame* 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.
@@ skipping 53 matching lines @@
     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();
+    WebLocalFrame* 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.
@@ skipping 56 matching lines @@
     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();
+    WebLocalFrame* 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");
 
@@ skipping 70 matching lines @@
   }
 
   void TestFillFormNonEmptyField(const char* html,
                                  bool unowned,
                                  const char* initial_lastname,
                                  const char* initial_email,
                                  const char* placeholder_firstname,
                                  const char* placeholder_lastname,
                                  const char* placeholder_email) {
     LoadHTML(html);
-    WebFrame* web_frame = GetMainFrame();
+    WebLocalFrame* 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.
@@ skipping 122 matching lines @@
     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();
+    WebLocalFrame* 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");
@@ skipping 82 matching lines @@
     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();
+    WebLocalFrame* 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");
@@ skipping 47 matching lines @@
     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();
+    WebLocalFrame* 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");
@@ skipping 33 matching lines @@
     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();
+    WebLocalFrame* 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");
@@ skipping 32 matching lines @@
     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();
+    WebLocalFrame* 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");
@@ skipping 33 matching lines @@
     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();
+    WebLocalFrame* 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");
@@ skipping 48 matching lines @@
   }
 
  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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result1;
   WebFormControlElementToFormField(element, nullptr, 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, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebInputElement element = GetInputElementById("element");
   element.SetAutofilled(true);
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebInputElement element = GetInputElementById("checkbox");
   element.SetAutofilled(true);
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("checkbox");
   expected.value = ASCIIToUTF16("mail");
@@ skipping 13 matching lines @@
   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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result1;
   WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result1);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
   expected.max_length = 0;
   expected.form_control_type = "select-one";
@@ skipping 22 matching lines @@
 }
 
 // We copy extra attributes for the select field.
 TEST_F(FormAutofillTest,
        WebFormControlElementToFormFieldSelect_ExtraAttributes) {
   LoadHTML("<SELECT id='element' autocomplete='off'/>"
            "  <OPTION value='CA'>California</OPTION>"
            "  <OPTION value='TX'>Texas</OPTION>"
            "</SELECT>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   element.SetAutofilled(true);
 
   FormFieldData result1;
   WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result1);
 
   FormFieldData expected;
   expected.name = ASCIIToUTF16("element");
@@ skipping 14 matching lines @@
 // 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_TRUE(frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result_sans_value;
   WebFormControlElementToFormField(element, nullptr, 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, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
   FormFieldData result_sans_value;
   WebFormControlElementToFormField(element, nullptr, 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, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("hidden");
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("password");
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
 
   FormFieldData expected;
   expected.max_length = WebInputElement::DefaultMaxLength();
   expected.name = ASCIIToUTF16("password");
   expected.form_control_type = "password";
@@ skipping 18 matching lines @@
       "</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();
+  WebLocalFrame* 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", "" },
@@ skipping 42 matching lines @@
     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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest, TextAlignOverridesDirection) {
   // text-align: right
   LoadHTML("<STYLE>input{direction:ltr;text-align:right}</STYLE>"
            "<FORM>"
            "  <INPUT type='text' id='element'/>"
            "</FORM>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
 
   // text-align: left
   LoadHTML("<STYLE>input{direction:rtl;text-align:left}</STYLE>"
@@ skipping 10 matching lines @@
   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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, 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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormControlElement element = GetFormControlElementById("element");
 
   FormFieldData result;
   WebFormControlElementToFormField(element, nullptr, EXTRACT_VALUE, &result);
   EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, result.text_direction);
 }
 
 TEST_F(FormAutofillTest, WebFormElementToFormData) {
@@ skipping 15 matching lines @@
            "  <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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebVector<WebFormElement> forms;
   frame->GetDocument().Forms(forms);
   ASSERT_EQ(1U, forms.size());
 
   WebInputElement input_element = GetInputElementById("firstname");
 
   FormData form;
   FormFieldData field;
@@ skipping 52 matching lines @@
 }
 
 TEST_F(FormAutofillTest, WebFormElementConsiderNonControlLabelableElements) {
   LoadHTML("<form id=form>"
            "  <label for='progress'>Progress:</label>"
            "  <progress id='progress'></progress>"
            "  <label for='firstname'>First name:</label>"
            "  <input type='text' id='firstname' value='John'>"
            "</form>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormElement web_form =
       frame->GetDocument().GetElementById("form").To<WebFormElement>();
   ASSERT_FALSE(web_form.IsNull());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
                                        nullptr, EXTRACT_NONE, &form, nullptr));
 
@@ skipping 13 matching lines @@
 // We should not be able to serialize a form with too many fillable fields.
 TEST_F(FormAutofillTest, MAYBE_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();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebVector<WebFormElement> forms;
   frame->GetDocument().Forms(forms);
   ASSERT_EQ(1U, forms.size());
 
   WebInputElement input_element = GetInputElementById("firstname");
 
   FormData form;
   FormFieldData field;
   EXPECT_FALSE(WebFormElementToFormData(forms[0], input_element, nullptr,
                                         EXTRACT_VALUE, &form, &field));
 }
 
 // Tests that the |should_autocomplete| is set to false for all the fields when
 // an autocomplete='off' attribute is set for the form in HTML.
 TEST_F(FormAutofillTest, WebFormElementToFormData_AutocompleteOff_OnForm) {
   LoadHTML(
       "<FORM name='TestForm' id='form' action='http://cnn.com' method='post' "
       "autocomplete='off'>"
       "  <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>"
       "    <INPUT type='text' id='addressline1' value='123 Test st.'/>"
       "</FORM>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormElement web_form =
       frame->GetDocument().GetElementById("form").To<WebFormElement>();
   ASSERT_FALSE(web_form.IsNull());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
                                        nullptr, EXTRACT_NONE, &form, nullptr));
 
   for (const FormFieldData& field : form.fields) {
     EXPECT_FALSE(field.should_autocomplete);
   }
 }
 
 // Tests that the |should_autocomplete| is set to false only for the field
 // which has an autocomplete='off' attribute set for it in HTML.
 TEST_F(FormAutofillTest, WebFormElementToFormData_AutocompleteOff_OnField) {
   LoadHTML(
       "<FORM name='TestForm' id='form' action='http://cnn.com' method='post'>"
       "  <LABEL for='firstname'>First name:</LABEL>"
       "    <INPUT type='text' id='firstname' value='John' autocomplete='off'/>"
       "  <LABEL for='lastname'>Last name:</LABEL>"
       "    <INPUT type='text' id='lastname' value='Smith'/>"
       "  <LABEL for='street-address'>Address:</LABEL>"
       "    <INPUT type='text' id='addressline1' value='123 Test st.'/>"
       "</FORM>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormElement web_form =
       frame->GetDocument().GetElementById("form").To<WebFormElement>();
   ASSERT_FALSE(web_form.IsNull());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
                                        nullptr, EXTRACT_NONE, &form, nullptr));
 
   ASSERT_EQ(3U, form.fields.size());
 
   EXPECT_FALSE(form.fields[0].should_autocomplete);
   EXPECT_TRUE(form.fields[1].should_autocomplete);
   EXPECT_TRUE(form.fields[2].should_autocomplete);
 }
 
 // Tests CSS classes are set.
 TEST_F(FormAutofillTest, WebFormElementToFormData_CssClasses) {
   LoadHTML(
       "<FORM name='TestForm' id='form' action='http://cnn.com' method='post' "
       "autocomplete='off'>"
       "    <INPUT type='text' id='firstname' class='firstname_field' />"
       "    <INPUT type='text' id='lastname' class='lastname_field' />"
       "    <INPUT type='text' id='addressline1'  />"
       "</FORM>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormElement web_form =
       frame->GetDocument().GetElementById("form").To<WebFormElement>();
   ASSERT_FALSE(web_form.IsNull());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
                                        nullptr, EXTRACT_NONE, &form, nullptr));
 
   EXPECT_EQ(3U, form.fields.size());
   EXPECT_EQ(ASCIIToUTF16("firstname_field"), form.fields[0].css_classes);
   EXPECT_EQ(ASCIIToUTF16("lastname_field"), form.fields[1].css_classes);
   EXPECT_EQ(base::string16(), form.fields[2].css_classes);
 }
 
 // Tests id attributes are set.
 TEST_F(FormAutofillTest, WebFormElementToFormData_IdAttributes) {
   LoadHTML(
       "<FORM name='TestForm' id='form' action='http://cnn.com' method='post' "
       "autocomplete='off'>"
       "    <INPUT type='text' name='name1' id='firstname' />"
       "    <INPUT type='text' name='name2' id='lastname' />"
       "    <INPUT type='text' name='same' id='same' />"
       "    <INPUT type='text' id='addressline1' />"
       "</FORM>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebFormElement web_form =
       frame->GetDocument().GetElementById("form").To<WebFormElement>();
   ASSERT_FALSE(web_form.IsNull());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
                                        nullptr, EXTRACT_NONE, &form, nullptr));
 
@@ skipping 24 matching lines @@
            "  <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();
+  WebLocalFrame* 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(GetCanonicalOriginForDocument(web_frame->GetDocument()),
@@ skipping 52 matching lines @@
 
 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();
+  WebLocalFrame* 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());
 
@@ skipping 86 matching lines @@
 }
 
 // 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();
+  WebLocalFrame* 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();
+  WebLocalFrame* 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();
+  WebLocalFrame* 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();
+  WebLocalFrame* 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();
+    WebLocalFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     WebVector<WebFormElement> web_forms;
     web_frame->GetDocument().Forms(web_forms);
     ASSERT_EQ(1U, web_forms.size());
     WebFormElement web_form = web_forms[0];
 
     FormData form;
     EXPECT_TRUE(WebFormElementToFormData(web_form, WebFormControlElement(),
                                          nullptr, EXTRACT_NONE, &form,
@@ skipping 1269 matching lines @@
            "  <input type='text' name='dayphone1'>"
            "  -"
            "  <input type='text' name='dayphone2'>"
            "  -"
            "  <input type='text' name='dayphone3'>"
            "  ext.:"
            "  <input type='text' name='dayphone4'>"
            "  <input type='submit' name='reply-send' value='Send'>"
            "</FORM>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebVector<WebFormElement> forms;
   frame->GetDocument().Forms(forms);
   ASSERT_EQ(1U, forms.size());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(forms[0], WebFormControlElement(),
                                        nullptr, EXTRACT_VALUE, &form, nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
@@ skipping 34 matching lines @@
            "  -"
            "  <input type='text' maxlength='4' size='5'"
            "         name='dayphone3'>"
            "  ext.:"
            "  <input type='text' maxlength='5' name='dayphone4'>"
            "  <input type='text' name='default1'>"
            "  <input type='text' maxlength='-1' name='invalid1'>"
            "  <input type='submit' name='reply-send' value='Send'>"
            "</FORM>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   WebVector<WebFormElement> forms;
   frame->GetDocument().Forms(forms);
   ASSERT_EQ(1U, forms.size());
 
   FormData form;
   EXPECT_TRUE(WebFormElementToFormData(forms[0], WebFormControlElement(),
                                        nullptr, EXTRACT_VALUE, &form, nullptr));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
@@ skipping 279 matching lines @@
       "  <LABEL for='email'> xxx@yyy.com </LABEL>"
       "    <INPUT type='text' id='email' value='john@example.com'/>"
       "  <INPUT type='submit' name='reply-send' value='Send'/>"
       "</FORM>",
       labels, names, values);
 }
 
 TEST_F(FormAutofillTest, ClickElement) {
   LoadHTML("<BUTTON id='link'>Button</BUTTON>"
            "<BUTTON name='button'>Button</BUTTON>");
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   // Successful retrieval by id.
   WebElementDescriptor clicker;
   clicker.retrieval_method = WebElementDescriptor::ID;
   clicker.descriptor = "link";
   EXPECT_TRUE(ClickElement(frame->GetDocument(), clicker));
 
   // Successful retrieval by css selector.
   clicker.retrieval_method = WebElementDescriptor::CSS_SELECTOR;
@@ skipping 14 matching lines @@
            "  <INPUT type='text' id='firstname' value='John'/>"
            "  <INPUT type='text' id='lastname' value='Smith'/>"
            "  <SELECT id='country'>"
            "    <OPTION value='AF'>Afghanistan</OPTION>"
            "    <OPTION value='AL'>Albania</OPTION>"
            "    <OPTION value='DZ'>Algeria</OPTION>"
            "  </SELECT>"
            "  <INPUT type='submit' name='reply-send' value='Send'/>"
            "</FORM>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   // Set the value of the select-one.
   WebSelectElement select_element =
       frame->GetDocument().GetElementById("country").To<WebSelectElement>();
   select_element.SetValue(WebString::FromUTF8("AL"));
 
   WebVector<WebFormElement> forms;
   frame->GetDocument().Forms(forms);
   ASSERT_EQ(1U, forms.size());
@@ skipping 82 matching lines @@
            "    <LABEL for='lastname'>Last name:</LABEL>"
            "    <INPUT type='text' id='firstname' value='John'/>"
            "    <INPUT type='text' id='lastname' value='Smith'/>"
            "  </FIELDSET>"
            "  <FIELDSET>"
            "    <LABEL for='email'>Email:</LABEL>"
            "    <INPUT type='text' id='email' value='john@example.com'/>"
            "  </FIELDSET>"
            "</DIV>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   control_elements = GetUnownedAutofillableFormFieldElements(
       frame->GetDocument().All(), &fieldsets);
   ASSERT_EQ(3U, control_elements.size());
   ASSERT_EQ(2U, fieldsets.size());
 
   FormData form;
   EXPECT_TRUE(UnownedCheckoutFormElementsAndFieldSetsToFormData(
       fieldsets, control_elements, nullptr, frame->GetDocument(), extract_mask,
@@ skipping 39 matching lines @@
            "  <FIELDSET>"
            "    <LABEL for='firstname'>First name:</LABEL>"
            "    <LABEL for='lastname'>Last name:</LABEL>"
            "    <INPUT type='text' id='firstname' value='John'/>"
            "    <INPUT type='text' id='lastname' value='Smith'/>"
            "    <LABEL for='email'>Email:</LABEL>"
            "  </FIELDSET>"
            "  <INPUT type='text' id='email' value='john@example.com'/>"
            "</DIV>");
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   control_elements = GetUnownedAutofillableFormFieldElements(
       frame->GetDocument().All(), &fieldsets);
   ASSERT_EQ(3U, control_elements.size());
   ASSERT_EQ(1U, fieldsets.size());
 
   FormData form;
   EXPECT_TRUE(UnownedCheckoutFormElementsAndFieldSetsToFormData(
       fieldsets, control_elements, nullptr, frame->GetDocument(), extract_mask,
@@ skipping 28 matching lines @@
 
 TEST_F(FormAutofillTest, UnownedFormElementsAndFieldSetsToFormDataWithForm) {
   std::vector<WebElement> fieldsets;
   std::vector<WebFormControlElement> control_elements;
 
   const ExtractMask extract_mask =
       static_cast<ExtractMask>(EXTRACT_VALUE | EXTRACT_OPTIONS);
 
   LoadHTML(kFormHtml);
 
-  WebFrame* frame = GetMainFrame();
+  WebLocalFrame* frame = GetMainFrame();
   ASSERT_NE(nullptr, frame);
 
   control_elements = GetUnownedAutofillableFormFieldElements(
       frame->GetDocument().All(), &fieldsets);
   ASSERT_TRUE(control_elements.empty());
   ASSERT_TRUE(fieldsets.empty());
 
   FormData form;
   EXPECT_FALSE(UnownedCheckoutFormElementsAndFieldSetsToFormData(
       fieldsets, control_elements, nullptr, frame->GetDocument(), extract_mask,
@@ skipping 51 matching lines @@
       {"<FORM name='TestForm' action='http://abc.com' method='post'>"
        "  <INPUT type='password' id='pw'/>"
        "  <INPUT type='password' id='new_pw'/>"
        "</FORM>",
        true, true, false},
   };
 
   for (auto test_case : test_cases) {
     LoadHTML(test_case.html);
 
-    WebFrame* web_frame = GetMainFrame();
+    WebLocalFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
     std::vector<FormData> forms = form_cache.ExtractNewForms();
     EXPECT_EQ(test_case.has_extracted_form, forms.size() == 1);
 
     if (test_case.has_extracted_form) {
       EXPECT_EQ(test_case.is_form_tag, forms[0].is_form_tag);
       EXPECT_EQ(test_case.is_formless_checkout, forms[0].is_formless_checkout);
     }
   }
 }
 
 }  // namespace form_util
 }  // namespace autofill