Autofill: one FormCache per WebFrame.

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 177 matching lines @@
                             const std::vector<std::string>& control_types) {
     ASSERT_EQ(labels.size(), names.size());
     ASSERT_EQ(labels.size(), values.size());
     ASSERT_EQ(labels.size(), control_types.size());
 
     LoadHTML(html);
 
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     const FormData& form = forms[0];
     EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
     EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
     EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
     const std::vector<FormFieldData>& fields = form.fields;
     ASSERT_EQ(labels.size(), fields.size());
     for (size_t i = 0; i < labels.size(); ++i) {
@@ skipping 38 matching lines @@
                              bool unowned,
                              const AutofillFieldCase* field_cases,
                              size_t number_of_field_cases,
                              FillFormFunction fill_form_function,
                              GetValueFunction get_value_function) {
     LoadHTML(html);
 
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("firstname");
 
     // Find the form that contains the input element.
     FormData form_data;
     FormFieldData field;
     EXPECT_TRUE(FindFormAndFieldForFormControlElement(
         input_element, &form_data, &field, REQUIRE_NONE));
@@ skipping 209 matching lines @@
     WebInputElement firstname = GetInputElementById("firstname");
     EXPECT_EQ(0, firstname.selectionStart());
     EXPECT_EQ(19, firstname.selectionEnd());
   }
 
   void TestFindFormForInputElement(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("firstname");
 
     // Find the form and verify it's the correct form.
     FormData form;
     FormFieldData field;
     EXPECT_TRUE(FindFormAndFieldForFormControlElement(
         input_element, &form, &field, REQUIRE_NONE));
@@ skipping 58 matching lines @@
     expected.name = ASCIIToUTF16("phone");
     expected.value = ASCIIToUTF16("1.800.555.1234");
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
   }
 
   void TestFindFormForTextAreaElement(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Get the textarea element we want to find.
     WebElement element = web_frame->document().getElementById("street-address");
     WebTextAreaElement textarea_element = element.to<WebTextAreaElement>();
 
     // Find the form and verify it's the correct form.
     FormData form;
     FormFieldData field;
     EXPECT_TRUE(FindFormAndFieldForFormControlElement(
@@ skipping 68 matching lines @@
     expected.max_length = 0;
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, field);
   }
 
   void TestFillFormMaxLength(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("firstname");
 
     // Find the form that contains the input element.
     FormData form;
     FormFieldData field;
     EXPECT_TRUE(FindFormAndFieldForFormControlElement(
         input_element, &form, &field, REQUIRE_NONE));
@@ skipping 66 matching lines @@
     expected.max_length = 9;
     expected.is_autofilled = true;
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
   }
 
   void TestFillFormNegativeMaxLength(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("firstname");
 
     // Find the form that contains the input element.
     FormData form;
     FormFieldData field;
     EXPECT_TRUE(FindFormAndFieldForFormControlElement(
         input_element, &form, &field, REQUIRE_NONE));
@@ skipping 50 matching lines @@
     expected.name = ASCIIToUTF16("email");
     expected.value = ASCIIToUTF16("brotherj@example.com");
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
   }
 
   void TestFillFormEmptyName(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("firstname");
 
     // Find the form that contains the input element.
     FormData form;
     FormFieldData field;
     EXPECT_TRUE(FindFormAndFieldForFormControlElement(
         input_element, &form, &field, REQUIRE_NONE));
@@ skipping 53 matching lines @@
     expected.name = ASCIIToUTF16("email");
     expected.value = ASCIIToUTF16("wyatt@example.com");
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
   }
 
   void TestFillFormEmptyFormNames(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     const size_t expected_size = unowned ? 1 : 2;
     ASSERT_EQ(expected_size, forms.size());
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("apple");
 
     // Find the form that contains the input element.
     FormData form;
     FormFieldData field;
     EXPECT_TRUE(FindFormAndFieldForFormControlElement(
@@ skipping 61 matching lines @@
     expected.value = ASCIIToUTF16("Also Yellow");
     expected.is_autofilled = true;
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[unowned_offset + 2]);
   }
 
   void TestFillFormNonEmptyField(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("firstname");
 
     // Simulate typing by modifying the field value.
     input_element.setValue(ASCIIToUTF16("Wy"));
 
     // Find the form that contains the input element.
     FormData form;
@@ skipping 74 matching lines @@
     // Verify that the cursor position has been updated.
     EXPECT_EQ(5, input_element.selectionStart());
     EXPECT_EQ(5, input_element.selectionEnd());
   }
 
   void TestClearFormWithNode(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement month = GetInputElementById("month");
     month.setAutofilled(true);
     WebInputElement textarea = GetInputElementById("textarea");
@@ skipping 74 matching lines @@
     EXPECT_EQ(0, firstname.selectionStart());
     EXPECT_EQ(0, firstname.selectionEnd());
   }
 
   void TestClearFormWithNodeContainingSelectOne(const char* html,
                                                 bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
 
     // Set the value and auto-filled attribute of the state element.
     WebSelectElement state =
@@ skipping 44 matching lines @@
     // Verify that the cursor position has been updated.
     EXPECT_EQ(0, firstname.selectionStart());
     EXPECT_EQ(0, firstname.selectionEnd());
   }
 
   void TestClearPreviewedFormWithElement(const char* html) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement email = GetInputElementById("email");
     email.setAutofilled(true);
     WebInputElement email2 = GetInputElementById("email2");
@@ skipping 32 matching lines @@
     // Verify that the cursor position has been updated.
     EXPECT_EQ(0, lastname.selectionStart());
     EXPECT_EQ(0, lastname.selectionEnd());
   }
 
   void TestClearPreviewedFormWithNonEmptyInitiatingNode(const char* html) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement email = GetInputElementById("email");
     email.setAutofilled(true);
     WebInputElement email2 = GetInputElementById("email2");
@@ skipping 32 matching lines @@
     EXPECT_TRUE(phone.value().isEmpty());
     EXPECT_TRUE(phone.suggestedValue().isEmpty());
     EXPECT_FALSE(phone.isAutofilled());
   }
 
   void TestClearPreviewedFormWithAutofilledInitiatingNode(const char* html) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement email = GetInputElementById("email");
     email.setAutofilled(true);
     WebInputElement email2 = GetInputElementById("email2");
@@ skipping 32 matching lines @@
     EXPECT_TRUE(phone.suggestedValue().isEmpty());
     EXPECT_FALSE(phone.isAutofilled());
   }
 
   void TestClearOnlyAutofilledFields(const char* html) {
     LoadHTML(html);
 
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
-    FormCache form_cache;
-    std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+    FormCache form_cache(*web_frame);
+    std::vector<FormData> forms = form_cache.ExtractNewForms();
     ASSERT_EQ(1U, forms.size());
 
     // Set the autofilled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(false);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement email = GetInputElementById("email");
     email.setAutofilled(true);
     WebInputElement phone = GetInputElementById("phone");
@@ skipping 671 matching lines @@
            "<FORM name='TestForm2' action='http://zoo.com' method='post'>"
            "  <INPUT type='text' id='firstname' value='Jack'/>"
            "  <INPUT type='text' id='lastname' value='Adams'/>"
            "  <INPUT type='text' id='email' value='jack@example.com'/>"
            "  <INPUT type='submit' name='reply-send' value='Send'/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+  FormCache form_cache(*web_frame);
+  std::vector<FormData> forms = form_cache.ExtractNewForms();
   ASSERT_EQ(2U, forms.size());
 
   // First form.
   const FormData& form = forms[0];
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormFieldData>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
@@ skipping 41 matching lines @@
       "<FORM id='testform' action='http://cnn.com' method='post'>"
       "  <INPUT type='text' id='firstname' value='John'/>"
       "  <INPUT type='text' id='lastname' value='Smith'/>"
       "  <INPUT type='text' id='email' value='john@example.com'/>"
       "  <INPUT type='submit' name='reply-send' value='Send'/>"
       "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*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(*web_frame);
+  forms = form_cache.ExtractNewForms();
   ASSERT_TRUE(forms.empty());
 
   // Append to the current form will re-extract.
   ExecuteJavaScript(
       "var newInput = document.createElement('input');"
       "newInput.setAttribute('type', 'text');"
       "newInput.setAttribute('id', 'telephone');"
       "newInput.value = '12345';"
       "document.getElementById('testform').appendChild(newInput);");
   msg_loop_.RunUntilIdle();
 
-  forms = form_cache.ExtractNewForms(*web_frame);
+  forms = form_cache.ExtractNewForms();
   ASSERT_EQ(1U, forms.size());
 
   const std::vector<FormFieldData>& fields = forms[0].fields;
   ASSERT_EQ(4U, fields.size());
 
   FormFieldData expected;
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("firstname");
@@ skipping 32 matching lines @@
       "newEmail.setAttribute('type', 'text');"
       "newEmail.setAttribute('id', 'second_email');"
       "newEmail.value = 'bobhope@example.com';"
       "newForm.appendChild(newFirstname);"
       "newForm.appendChild(newLastname);"
       "newForm.appendChild(newEmail);"
       "document.body.appendChild(newForm);");
   msg_loop_.RunUntilIdle();
 
   web_frame = GetMainFrame();
-  forms = form_cache.ExtractNewForms(*web_frame);
+  forms = form_cache.ExtractNewForms();
   ASSERT_EQ(1U, forms.size());
 
   const std::vector<FormFieldData>& fields2 = forms[0].fields;
   ASSERT_EQ(3U, fields2.size());
 
   expected.name = ASCIIToUTF16("second_firstname");
   expected.value = ASCIIToUTF16("Bob");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
 
   expected.name = ASCIIToUTF16("second_lastname");
   expected.value = ASCIIToUTF16("Hope");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
 
   expected.name = ASCIIToUTF16("second_email");
   expected.value = ASCIIToUTF16("bobhope@example.com");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
 }
 
 // We should not extract a form if it has too few fillable fields.
 TEST_F(FormAutofillTest, ExtractFormsTooFewFields) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  <INPUT type='text' id='firstname' value='John'/>"
            "  <INPUT type='text' id='lastname' value='Smith'/>"
            "  <INPUT type='submit' name='reply-send' value='Send'/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+  FormCache form_cache(*web_frame);
+  std::vector<FormData> forms = form_cache.ExtractNewForms();
   ASSERT_TRUE(forms.empty());
 }
 
 // We should not report additional forms for empty forms.
 TEST_F(FormAutofillTest, ExtractFormsSkippedForms) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  <INPUT type='text' id='firstname' value='John'/>"
            "  <INPUT type='text' id='lastname' value='Smith'/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+  FormCache form_cache(*web_frame);
+  std::vector<FormData> forms = form_cache.ExtractNewForms();
   ASSERT_TRUE(forms.empty());
 }
 
 // We should not report additional forms for empty forms.
 TEST_F(FormAutofillTest, ExtractFormsNoFields) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+  FormCache form_cache(*web_frame);
+  std::vector<FormData> forms = form_cache.ExtractNewForms();
   ASSERT_TRUE(forms.empty());
 }
 
 // We should not extract a form if it has too few fillable fields.
 // Make sure radio and checkbox fields don't count.
 TEST_F(FormAutofillTest, ExtractFormsTooFewFieldsSkipsCheckable) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  <INPUT type='text' id='firstname' value='John'/>"
            "  <INPUT type='text' id='lastname' value='Smith'/>"
            "  <INPUT type='radio' id='a_radio' value='0'/>"
            "  <INPUT type='checkbox' id='a_check' value='1'/>"
            "  <INPUT type='submit' name='reply-send' value='Send'/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
-  FormCache form_cache;
-  std::vector<FormData> forms = form_cache.ExtractNewForms(*web_frame);
+  FormCache form_cache(*web_frame);
+  std::vector<FormData> forms = form_cache.ExtractNewForms();
   ASSERT_TRUE(forms.empty());
 }
 
 TEST_F(FormAutofillTest, WebFormElementToFormDataAutocomplete) {
   {
     // Form is not auto-completable due to 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'/>"
@@ skipping 1774 matching lines @@
   ASSERT_TRUE(control_elements.empty());
   ASSERT_TRUE(fieldsets.empty());
 
   FormData form;
   EXPECT_FALSE(UnownedFormElementsAndFieldSetsToFormData(
       fieldsets, control_elements, nullptr, dummy_origin, REQUIRE_NONE,
       extract_mask, &form, nullptr));
 }
 
 }  // namespace autofill