Revert of Autofill: Disable autofill for fields outside of forms.

components/autofill/content/renderer/form_cache.cc

 // Copyright 2013 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 "components/autofill/content/renderer/form_cache.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
@@ skipping 101 matching lines @@
     num_fields_seen += form.fields.size();
     if (num_fields_seen > kMaxParseableFields)
       return forms;
 
     if (form.fields.size() >= kRequiredAutofillFields &&
         !ContainsKey(parsed_forms_, form)) {
       forms.push_back(form);
       parsed_forms_.insert(form);
     }
   }
+
+  // Look for more parseable fields outside of forms.
+  std::vector<WebElement> fieldsets;
+  std::vector<WebFormControlElement> control_elements =
+      GetUnownedAutofillableFormFieldElements(document.all(), &fieldsets);
+
+  size_t num_editable_elements =
+      ScanFormControlElements(control_elements, log_deprecation_messages);
+
+  if (ShouldIgnoreForm(num_editable_elements, control_elements.size()))
+    return forms;
+
+  FormData synthetic_form;
+  if (!UnownedFormElementsAndFieldSetsToFormData(fieldsets, control_elements,
+                                                 nullptr, document.url(),
+                                                 REQUIRE_NONE, extract_mask,
+                                                 &synthetic_form, nullptr)) {
+    return forms;
+  }
+
+  num_fields_seen += synthetic_form.fields.size();
+  if (num_fields_seen > kMaxParseableFields)
+    return forms;
+
+  if (synthetic_form.fields.size() >= kRequiredAutofillFields &&
+      !parsed_forms_.count(synthetic_form)) {
+    forms.push_back(synthetic_form);
+    parsed_forms_.insert(synthetic_form);
+    synthetic_form_ = synthetic_form;
+  }
   return forms;
 }
 
 void FormCache::Reset() {
+  synthetic_form_ = FormData();
   parsed_forms_.clear();
   initial_select_values_.clear();
   initial_checked_state_.clear();
 }
 
 bool FormCache::ClearFormWithElement(const WebFormControlElement& element) {
   WebFormElement form_element = element.form();
   std::vector<WebFormControlElement> control_elements;
   if (form_element.isNull()) {
     control_elements = GetUnownedAutofillableFormFieldElements(
@@ skipping 48 matching lines @@
   }
 
   return true;
 }
 
 bool FormCache::ShowPredictions(const FormDataPredictions& form) {
   DCHECK_EQ(form.data.fields.size(), form.fields.size());
 
   std::vector<WebFormControlElement> control_elements;
 
+  // First check the synthetic form.
   bool found_synthetic_form = false;
+  if (form.data.SameFormAs(synthetic_form_)) {
+    found_synthetic_form = true;
+    WebDocument document = frame_.document();
+    control_elements =
+        GetUnownedAutofillableFormFieldElements(document.all(), nullptr);
+  }
+
   if (!found_synthetic_form) {
     // Find the real form by searching through the WebDocuments.
     bool found_form = false;
     WebFormElement form_element;
     WebVector<WebFormElement> web_forms;
     frame_.document().forms(web_forms);
 
     for (size_t i = 0; i < web_forms.size(); ++i) {
       form_element = web_forms[i];
       // Note: matching on the form name here which is not guaranteed to be
@@ skipping 74 matching lines @@
             std::make_pair(input_element, input_element.isChecked()));
       } else {
         ++num_editable_elements;
       }
     }
   }
   return num_editable_elements;
 }
 
 }  // namespace autofill