[Autofill] Always show available data when encountering autocomplete attributes

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 41 matching lines @@
       continue;
     std::string msg = std::string("autocomplete='") + deprecated[i] +
         "' is deprecated and will soon be ignored. See http://goo.gl/YjeSsW";
     WebConsoleMessage console_message = WebConsoleMessage(
         WebConsoleMessage::LevelWarning,
         WebString(base::ASCIIToUTF16(msg)));
     element.document().frame()->addMessageToConsole(console_message);
   }
 }
 
-// To avoid overly expensive computation, we impose a minimum number of
-// allowable fields.  The corresponding maximum number of allowable fields
-// is imposed by WebFormElementToFormData().
-bool ShouldIgnoreForm(size_t num_editable_elements,
-                      size_t num_control_elements) {
-  return (num_editable_elements < kRequiredAutofillFields &&
-          num_control_elements > 0);
+// Determines whether the form is interesting enough to send to the browser
+// for further operations.
+bool IsFormInteresting(const FormData& form) {
+  if (form.fields.empty())
+    return false;
+
+  // If the form has at least one field with an autocomplete attribute, it is a
+  // candidate for autofill.
+  for (const FormFieldData& field : form.fields) {
+    if (!field.autocomplete_attribute.empty())
+      return true;
+  }
+
+  // If there are no autocomplete attributes, the form needs to have at least
+  // the required number of fields for the prediction routines to be a
+  // candidate for autofill.
+  return form.fields.size() >= kRequiredFieldsForPredictionRoutines;
 }
 
 }  // namespace
 
 FormCache::FormCache(const WebFrame& frame) : frame_(frame) {
 }
 
 FormCache::~FormCache() {
 }
 
@@ skipping 18 matching lines @@
 
   size_t num_fields_seen = 0;
   for (size_t i = 0; i < web_forms.size(); ++i) {
     const WebFormElement& form_element = web_forms[i];
 
     std::vector<WebFormControlElement> control_elements =
         form_util::ExtractAutofillableElementsInForm(form_element);
     size_t num_editable_elements =
         ScanFormControlElements(control_elements, log_deprecation_messages);
 
-    if (ShouldIgnoreForm(num_editable_elements, control_elements.size()))
+    if (num_editable_elements == 0)
       continue;
 
     FormData form;
     if (!WebFormElementToFormData(form_element, WebFormControlElement(),
                                   extract_mask, &form, nullptr)) {
       continue;
     }
 
     num_fields_seen += form.fields.size();
     if (num_fields_seen > form_util::kMaxParseableFields)
       return forms;
 
-    if (form.fields.size() >= kRequiredAutofillFields &&
-        !ContainsKey(parsed_forms_, form)) {
+    if (!ContainsKey(parsed_forms_, form) && IsFormInteresting(form)) {
       for (auto it = parsed_forms_.begin(); it != parsed_forms_.end(); ++it) {
         if (it->SameFormAs(form)) {
           parsed_forms_.erase(it);
           break;
         }
       }
 
       SaveInitialValues(control_elements);
       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 =
       form_util::GetUnownedAutofillableFormFieldElements(document.all(),
                                                          &fieldsets);
 
   size_t num_editable_elements =
       ScanFormControlElements(control_elements, log_deprecation_messages);
 
-  if (ShouldIgnoreForm(num_editable_elements, control_elements.size()))
+  if (num_editable_elements == 0)
     return forms;
 
   FormData synthetic_form;
   if (!UnownedCheckoutFormElementsAndFieldSetsToFormData(
           fieldsets, control_elements, nullptr, document, extract_mask,
           &synthetic_form, nullptr)) {
     return forms;
   }
 
   num_fields_seen += synthetic_form.fields.size();
   if (num_fields_seen > form_util::kMaxParseableFields)
     return forms;
 
-  if (synthetic_form.fields.size() >= kRequiredAutofillFields &&
-      !parsed_forms_.count(synthetic_form)) {
+  if (!parsed_forms_.count(synthetic_form) &&
+      IsFormInteresting(synthetic_form)) {
     SaveInitialValues(control_elements);
     forms.push_back(synthetic_form);
     parsed_forms_.insert(synthetic_form);
     parsed_forms_.erase(synthetic_form_);
     synthetic_form_ = synthetic_form;
   }
   return forms;
 }
 
 void FormCache::Reset() {
@@ skipping 171 matching lines @@
       const WebInputElement* input_element = toWebInputElement(&element);
       if (form_util::IsCheckableElement(input_element)) {
         initial_checked_state_.insert(
             std::make_pair(*input_element, input_element->isChecked()));
       }
     }
   }
 }
 
 }  // namespace autofill