Autofill: Set requirements for number of recognized fields in an autofillable form

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 178 matching lines @@
     ASSERT_EQ(labels.size(), names.size());
     ASSERT_EQ(labels.size(), values.size());
     ASSERT_EQ(labels.size(), control_types.size());
 
     LoadHTML(html);
 
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    EXPECT_EQ(1U, unowned_form_index);
 
     const FormData& form = forms[0];
     EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
     EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
     EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
     const std::vector<FormFieldData>& fields = form.fields;
     ASSERT_EQ(labels.size(), fields.size());
     for (size_t i = 0; i < labels.size(); ++i) {
       int max_length = control_types[i] == "text" ?
@@ skipping 38 matching lines @@
                              const AutofillFieldCase* field_cases,
                              size_t number_of_field_cases,
                              FillFormFunction fill_form_function,
                              GetValueFunction get_value_function) {
     LoadHTML(html);
 
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // 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));
     if (!unowned) {
@@ skipping 209 matching lines @@
     EXPECT_EQ(0, firstname.selectionStart());
     EXPECT_EQ(19, firstname.selectionEnd());
   }
 
   void TestFindFormForInputElement(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // 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));
     EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 58 matching lines @@
     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(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // Get the textarea element we want to find.
     WebElement element = web_frame->document().getElementById("street-address");
     WebTextAreaElement textarea_element = element.to<WebTextAreaElement>();
 
     // Find the form and verify it's the correct form.
     FormData form;
     FormFieldData field;
     EXPECT_TRUE(FindFormAndFieldForFormControlElement(
         textarea_element, &form, &field, REQUIRE_NONE));
@@ skipping 68 matching lines @@
     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(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // 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));
     EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 66 matching lines @@
     expected.is_autofilled = true;
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
   }
 
   void TestFillFormNegativeMaxLength(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // 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));
     EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 50 matching lines @@
     expected.value = ASCIIToUTF16("brotherj@example.com");
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
   }
 
   void TestFillFormEmptyName(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // 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));
     EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 53 matching lines @@
     expected.value = ASCIIToUTF16("wyatt@example.com");
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
   }
 
   void TestFillFormEmptyFormNames(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     const size_t expected_size = unowned ? 1 : 2;
     ASSERT_EQ(expected_size, forms.size());
+    const size_t expected_index = unowned ? 0 : 2;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("apple");
 
     // Find the form that contains the input element.
     FormData form;
     FormFieldData field;
     EXPECT_TRUE(FindFormAndFieldForFormControlElement(
         input_element, &form, &field, REQUIRE_NONE));
     EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
@@ skipping 60 matching lines @@
     expected.is_autofilled = true;
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[unowned_offset + 2]);
   }
 
   void TestFillFormNonEmptyField(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // Get the input element we want to find.
     WebInputElement input_element = GetInputElementById("firstname");
 
     // Simulate typing by modifying the field value.
     input_element.setValue(ASCIIToUTF16("Wy"));
 
     // Find the form that contains the input element.
     FormData form;
     FormFieldData field;
@@ skipping 74 matching lines @@
     EXPECT_EQ(5, input_element.selectionStart());
     EXPECT_EQ(5, input_element.selectionEnd());
   }
 
   void TestClearFormWithNode(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement month = GetInputElementById("month");
     month.setAutofilled(true);
     WebInputElement textarea = GetInputElementById("textarea");
     textarea.setAutofilled(true);
@@ skipping 74 matching lines @@
     EXPECT_EQ(0, firstname.selectionEnd());
   }
 
   void TestClearFormWithNodeContainingSelectOne(const char* html,
                                                 bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
 
     // Set the value and auto-filled attribute of the state element.
     WebSelectElement state =
         web_frame->document().getElementById("state").to<WebSelectElement>();
@@ skipping 38 matching lines @@
     expected.value = ASCIIToUTF16("?");
     expected.form_control_type = "select-one";
     expected.max_length = 0;
     EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields[2]);
 
     // Verify that the cursor position has been updated.
     EXPECT_EQ(0, firstname.selectionStart());
     EXPECT_EQ(0, firstname.selectionEnd());
   }
 
-  void TestClearPreviewedFormWithElement(const char* html) {
+  void TestClearPreviewedFormWithElement(const char* html, bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement email = GetInputElementById("email");
     email.setAutofilled(true);
     WebInputElement email2 = GetInputElementById("email2");
     email2.setAutofilled(true);
@@ skipping 26 matching lines @@
     EXPECT_FALSE(email2.isAutofilled());
     EXPECT_TRUE(phone.value().isEmpty());
     EXPECT_TRUE(phone.suggestedValue().isEmpty());
     EXPECT_FALSE(phone.isAutofilled());
 
     // Verify that the cursor position has been updated.
     EXPECT_EQ(0, lastname.selectionStart());
     EXPECT_EQ(0, lastname.selectionEnd());
   }
 
-  void TestClearPreviewedFormWithNonEmptyInitiatingNode(const char* html) {
+  void TestClearPreviewedFormWithNonEmptyInitiatingNode(const char* html,
+                                                        bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement email = GetInputElementById("email");
     email.setAutofilled(true);
     WebInputElement email2 = GetInputElementById("email2");
     email2.setAutofilled(true);
@@ skipping 26 matching lines @@
     EXPECT_TRUE(email.suggestedValue().isEmpty());
     EXPECT_FALSE(email.isAutofilled());
     EXPECT_TRUE(email2.value().isEmpty());
     EXPECT_TRUE(email2.suggestedValue().isEmpty());
     EXPECT_FALSE(email2.isAutofilled());
     EXPECT_TRUE(phone.value().isEmpty());
     EXPECT_TRUE(phone.suggestedValue().isEmpty());
     EXPECT_FALSE(phone.isAutofilled());
   }
 
-  void TestClearPreviewedFormWithAutofilledInitiatingNode(const char* html) {
+  void TestClearPreviewedFormWithAutofilledInitiatingNode(const char* html,
+                                                          bool unowned) {
     LoadHTML(html);
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // Set the auto-filled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(true);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement email = GetInputElementById("email");
     email.setAutofilled(true);
     WebInputElement email2 = GetInputElementById("email2");
     email2.setAutofilled(true);
@@ skipping 25 matching lines @@
     EXPECT_TRUE(email.suggestedValue().isEmpty());
     EXPECT_FALSE(email.isAutofilled());
     EXPECT_TRUE(email2.value().isEmpty());
     EXPECT_TRUE(email2.suggestedValue().isEmpty());
     EXPECT_FALSE(email2.isAutofilled());
     EXPECT_TRUE(phone.value().isEmpty());
     EXPECT_TRUE(phone.suggestedValue().isEmpty());
     EXPECT_FALSE(phone.isAutofilled());
   }
 
-  void TestClearOnlyAutofilledFields(const char* html) {
+  void TestClearOnlyAutofilledFields(const char* html, bool unowned) {
     LoadHTML(html);
 
     WebFrame* web_frame = GetMainFrame();
     ASSERT_NE(nullptr, web_frame);
 
     FormCache form_cache(*web_frame);
-    std::vector<FormData> forms = form_cache.ExtractNewForms();
+    size_t unowned_form_index;
+    std::vector<FormData> forms =
+        form_cache.ExtractNewForms(&unowned_form_index);
     ASSERT_EQ(1U, forms.size());
+    const size_t expected_index = unowned ? 0 : 1;
+    EXPECT_EQ(expected_index, unowned_form_index);
 
     // Set the autofilled attribute.
     WebInputElement firstname = GetInputElementById("firstname");
     firstname.setAutofilled(false);
     WebInputElement lastname = GetInputElementById("lastname");
     lastname.setAutofilled(true);
     WebInputElement email = GetInputElementById("email");
     email.setAutofilled(true);
     WebInputElement phone = GetInputElementById("phone");
     phone.setAutofilled(true);
@@ skipping 671 matching lines @@
            "  <INPUT type='text' id='firstname' value='Jack'/>"
            "  <INPUT type='text' id='lastname' value='Adams'/>"
            "  <INPUT type='text' id='email' value='jack@example.com'/>"
            "  <INPUT type='submit' name='reply-send' value='Send'/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache(*web_frame);
-  std::vector<FormData> forms = form_cache.ExtractNewForms();
+  size_t unowned_form_index;
+  std::vector<FormData> forms = form_cache.ExtractNewForms(&unowned_form_index);
   ASSERT_EQ(2U, forms.size());
+  EXPECT_EQ(2U, unowned_form_index);
 
   // 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 @@
       "  <INPUT type='text' id='firstname' value='John'/>"
       "  <INPUT type='text' id='lastname' value='Smith'/>"
       "  <INPUT type='text' id='email' value='john@example.com'/>"
       "  <INPUT type='submit' name='reply-send' value='Send'/>"
       "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache(*web_frame);
-  std::vector<FormData> forms = form_cache.ExtractNewForms();
+  size_t unowned_form_index;
+  std::vector<FormData> forms = form_cache.ExtractNewForms(&unowned_form_index);
   ASSERT_EQ(1U, forms.size());
+  EXPECT_EQ(1U, unowned_form_index);
 
   // Second call should give nothing as there are no new forms.
-  forms = form_cache.ExtractNewForms();
+  forms = form_cache.ExtractNewForms(&unowned_form_index);
   ASSERT_TRUE(forms.empty());
+  EXPECT_EQ(0U, unowned_form_index);
 
   // 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();
+  forms = form_cache.ExtractNewForms(&unowned_form_index);
   ASSERT_EQ(1U, forms.size());
+  EXPECT_EQ(1U, unowned_form_index);
 
   const std::vector<FormFieldData>& fields = forms[0].fields;
   ASSERT_EQ(4U, fields.size());
 
   FormFieldData expected;
   expected.form_control_type = "text";
   expected.max_length = WebInputElement::defaultMaxLength();
 
   expected.name = ASCIIToUTF16("firstname");
   expected.value = ASCIIToUTF16("John");
@@ skipping 31 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();
+  forms = form_cache.ExtractNewForms(&unowned_form_index);
   ASSERT_EQ(1U, forms.size());
+  EXPECT_EQ(1U, unowned_form_index);
 
   const std::vector<FormFieldData>& fields2 = forms[0].fields;
   ASSERT_EQ(3U, fields2.size());
 
   expected.name = ASCIIToUTF16("second_firstname");
   expected.value = ASCIIToUTF16("Bob");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[0]);
 
   expected.name = ASCIIToUTF16("second_lastname");
   expected.value = ASCIIToUTF16("Hope");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[1]);
 
   expected.name = ASCIIToUTF16("second_email");
   expected.value = ASCIIToUTF16("bobhope@example.com");
   EXPECT_FORM_FIELD_DATA_EQUALS(expected, fields2[2]);
 }
 
 // We should not extract a form if it has too few fillable fields.
 TEST_F(FormAutofillTest, ExtractFormsTooFewFields) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  <INPUT type='text' id='firstname' value='John'/>"
            "  <INPUT type='text' id='lastname' value='Smith'/>"
            "  <INPUT type='submit' name='reply-send' value='Send'/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache(*web_frame);
-  std::vector<FormData> forms = form_cache.ExtractNewForms();
+  size_t unowned_form_index;
+  std::vector<FormData> forms = form_cache.ExtractNewForms(&unowned_form_index);
   ASSERT_TRUE(forms.empty());
+  EXPECT_EQ(0U, unowned_form_index);
 }
 
 // We should not report additional forms for empty forms.
 TEST_F(FormAutofillTest, ExtractFormsSkippedForms) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  <INPUT type='text' id='firstname' value='John'/>"
            "  <INPUT type='text' id='lastname' value='Smith'/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache(*web_frame);
-  std::vector<FormData> forms = form_cache.ExtractNewForms();
+  size_t unowned_form_index;
+  std::vector<FormData> forms = form_cache.ExtractNewForms(&unowned_form_index);
   ASSERT_TRUE(forms.empty());
+  EXPECT_EQ(0U, unowned_form_index);
 }
 
 // We should not report additional forms for empty forms.
 TEST_F(FormAutofillTest, ExtractFormsNoFields) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache(*web_frame);
-  std::vector<FormData> forms = form_cache.ExtractNewForms();
+  size_t unowned_form_index;
+  std::vector<FormData> forms = form_cache.ExtractNewForms(&unowned_form_index);
   ASSERT_TRUE(forms.empty());
+  EXPECT_EQ(0U, unowned_form_index);
 }
 
 // We should not extract a form if it has too few fillable fields.
 // Make sure radio and checkbox fields don't count.
 TEST_F(FormAutofillTest, ExtractFormsTooFewFieldsSkipsCheckable) {
   LoadHTML("<FORM name='TestForm' action='http://cnn.com' method='post'>"
            "  <INPUT type='text' id='firstname' value='John'/>"
            "  <INPUT type='text' id='lastname' value='Smith'/>"
            "  <INPUT type='radio' id='a_radio' value='0'/>"
            "  <INPUT type='checkbox' id='a_check' value='1'/>"
            "  <INPUT type='submit' name='reply-send' value='Send'/>"
            "</FORM>");
 
   WebFrame* web_frame = GetMainFrame();
   ASSERT_NE(nullptr, web_frame);
 
   FormCache form_cache(*web_frame);
-  std::vector<FormData> forms = form_cache.ExtractNewForms();
+  size_t unowned_form_index;
+  std::vector<FormData> forms = form_cache.ExtractNewForms(&unowned_form_index);
   ASSERT_TRUE(forms.empty());
+  EXPECT_EQ(0U, unowned_form_index);
 }
 
 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'/>"
              "  <INPUT type='text' id='email' value='john@example.com'/>"
@@ skipping 1397 matching lines @@
 
 TEST_F(FormAutofillTest, ClearPreviewedFormWithElement) {
   TestClearPreviewedFormWithElement(
       "<FORM name='TestForm' action='http://buh.com' method='post'>"
       "  <INPUT type='text' id='firstname' value='Wyatt'/>"
       "  <INPUT type='text' id='lastname'/>"
       "  <INPUT type='text' id='email'/>"
       "  <INPUT type='email' id='email2'/>"
       "  <INPUT type='tel' id='phone'/>"
       "  <INPUT type='submit' value='Send'/>"
-      "</FORM>");
+      "</FORM>",
+      false);
 }
 
 TEST_F(FormAutofillTest, ClearPreviewedFormWithElementForUnownedForm) {
   TestClearPreviewedFormWithElement(
       "<INPUT type='text' id='firstname' value='Wyatt'/>"
       "<INPUT type='text' id='lastname'/>"
       "<INPUT type='text' id='email'/>"
       "<INPUT type='email' id='email2'/>"
       "<INPUT type='tel' id='phone'/>"
-      "<INPUT type='submit' value='Send'/>");
+      "<INPUT type='submit' value='Send'/>",
+      true);
 }
 
 TEST_F(FormAutofillTest, ClearPreviewedFormWithNonEmptyInitiatingNode) {
   TestClearPreviewedFormWithNonEmptyInitiatingNode(
       "<FORM name='TestForm' action='http://buh.com' method='post'>"
       "  <INPUT type='text' id='firstname' value='W'/>"
       "  <INPUT type='text' id='lastname'/>"
       "  <INPUT type='text' id='email'/>"
       "  <INPUT type='email' id='email2'/>"
       "  <INPUT type='tel' id='phone'/>"
       "  <INPUT type='submit' value='Send'/>"
-      "</FORM>");
+      "</FORM>",
+      false);
 }
 
 TEST_F(FormAutofillTest,
        ClearPreviewedFormWithNonEmptyInitiatingNodeForUnownedForm) {
   TestClearPreviewedFormWithNonEmptyInitiatingNode(
       "<INPUT type='text' id='firstname' value='W'/>"
       "<INPUT type='text' id='lastname'/>"
       "<INPUT type='text' id='email'/>"
       "<INPUT type='email' id='email2'/>"
       "<INPUT type='tel' id='phone'/>"
-      "<INPUT type='submit' value='Send'/>");
+      "<INPUT type='submit' value='Send'/>",
+      true);
 }
 
 TEST_F(FormAutofillTest, ClearPreviewedFormWithAutofilledInitiatingNode) {
   TestClearPreviewedFormWithAutofilledInitiatingNode(
       "<FORM name='TestForm' action='http://buh.com' method='post'>"
       "  <INPUT type='text' id='firstname' value='W'/>"
       "  <INPUT type='text' id='lastname'/>"
       "  <INPUT type='text' id='email'/>"
       "  <INPUT type='email' id='email2'/>"
       "  <INPUT type='tel' id='phone'/>"
       "  <INPUT type='submit' value='Send'/>"
-      "</FORM>");
+      "</FORM>",
+      false);
 }
 
 TEST_F(FormAutofillTest,
        ClearPreviewedFormWithAutofilledInitiatingNodeForUnownedForm) {
   TestClearPreviewedFormWithAutofilledInitiatingNode(
       "<INPUT type='text' id='firstname' value='W'/>"
       "<INPUT type='text' id='lastname'/>"
       "<INPUT type='text' id='email'/>"
       "<INPUT type='email' id='email2'/>"
       "<INPUT type='tel' id='phone'/>"
-      "<INPUT type='submit' value='Send'/>");
+      "<INPUT type='submit' value='Send'/>",
+      true);
 }
 
 // Autofill's "Clear Form" should clear only autofilled fields
 TEST_F(FormAutofillTest, ClearOnlyAutofilledFields) {
   TestClearOnlyAutofilledFields(
       "<FORM name='TestForm' action='http://buh.com' method='post'>"
       "  <INPUT type='text' id='firstname' value='Wyatt'/>"
       "  <INPUT type='text' id='lastname' value='Earp'/>"
       "  <INPUT type='email' id='email' value='wyatt@earp.com'/>"
       "  <INPUT type='tel' id='phone' value='650-777-9999'/>"
       "  <INPUT type='submit' value='Send'/>"
-      "</FORM>");
+      "</FORM>",
+      false);
 }
 
 TEST_F(FormAutofillTest, ClearOnlyAutofilledFieldsForUnownedForm) {
   TestClearOnlyAutofilledFields(
       "<INPUT type='text' id='firstname' value='Wyatt'/>"
       "<INPUT type='text' id='lastname' value='Earp'/>"
       "<INPUT type='email' id='email' value='wyatt@earp.com'/>"
       "<INPUT type='tel' id='phone' value='650-777-9999'/>"
-      "<INPUT type='submit' value='Send'/>");
+      "<INPUT type='submit' value='Send'/>",
+      true);
 }
 
 // If we have multiple labels per id, the labels concatenated into label string.
 TEST_F(FormAutofillTest, MultipleLabelsPerElement) {
   std::vector<base::string16> labels, names, values;
 
   labels.push_back(ASCIIToUTF16("First Name:"));
   names.push_back(ASCIIToUTF16("firstname"));
   values.push_back(ASCIIToUTF16("John"));
 
@@ skipping 278 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