[Autofill] Always show available data when encountering autocomplete attributes

components/autofill/core/browser/form_structure.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/core/browser/form_structure.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 373 matching lines @@
 }  // namespace
 
 FormStructure::FormStructure(const FormData& form)
     : form_name_(form.name),
       source_url_(form.origin),
       target_url_(form.action),
       autofill_count_(0),
       active_field_count_(0),
       upload_required_(USE_UPLOAD_RATES),
       has_author_specified_types_(false),
+      has_author_specified_sections_(false),
+      was_parsed_for_autocomplete_attributes_(false),
       has_password_field_(false),
       is_form_tag_(form.is_form_tag) {
   // Copy the form fields.
   std::map<base::string16, size_t> unique_names;
   for (const FormFieldData& field : form.fields) {
     if (!ShouldSkipField(field)) {
       // Add all supported form fields (including with empty names) to the
       // signature.  This is a requirement for Autofill servers.
       form_signature_field_names_.append("&");
       form_signature_field_names_.append(StripDigitsIfRequired(field.name));
@@ skipping 14 matching lines @@
   }
 }
 
 FormStructure::~FormStructure() {}
 
 void FormStructure::DetermineHeuristicTypes() {
   // First, try to detect field types based on each field's |autocomplete|
   // attribute value.  If there is at least one form field that specifies an
   // autocomplete type hint, don't try to apply other heuristics to match fields
   // in this form.
-  bool has_author_specified_sections;
-  ParseFieldTypesFromAutocompleteAttributes(&has_author_specified_types_,
-                                            &has_author_specified_sections);
+  if (!was_parsed_for_autocomplete_attributes_)
+    ParseFieldTypesFromAutocompleteAttributes();
 
   if (!has_author_specified_types_) {
     ServerFieldTypeMap field_type_map;
     FormField::ParseFormFields(fields_.get(), is_form_tag_, &field_type_map);
     for (size_t i = 0; i < field_count(); ++i) {
       AutofillField* field = fields_[i];
       ServerFieldTypeMap::iterator iter =
           field_type_map.find(field->unique_name());
       if (iter != field_type_map.end())
         field->set_heuristic_type(iter->second);
     }
   }
 
   UpdateAutofillCount();
-  IdentifySections(has_author_specified_sections);
+  IdentifySections(has_author_specified_sections_);
 
   if (IsAutofillable()) {
     AutofillMetrics::LogDeveloperEngagementMetric(
         AutofillMetrics::FILLABLE_FORM_PARSED);
     if (has_author_specified_types_) {
       AutofillMetrics::LogDeveloperEngagementMetric(
           AutofillMetrics::FILLABLE_FORM_CONTAINS_TYPE_HINTS);
     }
   }
 }
@@ skipping 264 matching lines @@
                             form_signature_field_names_;
 
   return Hash64Bit(form_string);
 }
 
 bool FormStructure::ShouldSkipField(const FormFieldData& field) const {
   return field.is_checkable;
 }
 
 bool FormStructure::IsAutofillable() const {
-  if (autofill_count() < kRequiredAutofillFields)
+  if (autofill_count() < kRequiredFieldsForPredictionRoutines)
     return false;
 
   return ShouldBeParsed();
 }
 
 void FormStructure::UpdateAutofillCount() {
   autofill_count_ = 0;
   for (const AutofillField* field : *this) {
     if (field && field->IsFieldFillable())
       ++autofill_count_;
   }
 }
 
 bool FormStructure::ShouldBeParsed() const {
-  if (active_field_count() < kRequiredAutofillFields)
+  if (active_field_count() < kRequiredFieldsForPredictionRoutines &&
+      !has_author_specified_types_) {
     return false;
+  }
 
   // Rule out http(s)://*/search?...
   //  e.g. http://www.google.com/search?q=...
   //       http://search.yahoo.com/search?p=...
   if (target_url_.path() == "/search")
     return false;
 
   bool has_text_field = false;
   for (const AutofillField* it : *this) {
     has_text_field |= it->form_control_type != "select-one";
@@ skipping 147 matching lines @@
                                                 field_type);
     } else {
       AutofillMetrics::LogOverallTypePrediction(AutofillMetrics::TYPE_MISMATCH,
                                                 field_type);
     }
   }
 
   AutofillMetrics::LogNumberOfEditedAutofilledFieldsAtSubmission(
       num_edited_autofilled_fields);
 
-  if (num_detected_field_types < kRequiredAutofillFields) {
+  if (num_detected_field_types < kRequiredFieldsForPredictionRoutines) {
     AutofillMetrics::LogUserHappinessMetric(
         AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM);
   } else {
     if (did_autofill_all_possible_fields) {
       AutofillMetrics::LogUserHappinessMetric(
           AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_ALL);
     } else if (did_autofill_some_possible_fields) {
       AutofillMetrics::LogUserHappinessMetric(
           AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME);
     } else {
@@ skipping 140 matching lines @@
         EncodeFieldForQuery(*field, encompassing_xml_element);
         break;
       case FormStructure::FIELD_ASSIGNMENTS:
         EncodeFieldForFieldAssignments(*field, encompassing_xml_element);
         break;
     }
   }
   return true;
 }
 
-void FormStructure::ParseFieldTypesFromAutocompleteAttributes(
-    bool* found_types,
-    bool* found_sections) {
+void FormStructure::ParseFieldTypesFromAutocompleteAttributes() {
   const std::string kDefaultSection = "-default";
 
-  *found_types = false;
-  *found_sections = false;
+  has_author_specified_types_ = false;
+  has_author_specified_sections_ = false;
   for (AutofillField* field : fields_) {
     // To prevent potential section name collisions, add a default suffix for
     // other fields.  Without this, 'autocomplete' attribute values
     // "section--shipping street-address" and "shipping street-address" would be
     // parsed identically, given the section handling code below.  We do this
     // before any validation so that fields with invalid attributes still end up
     // in the default section.  These default section names will be overridden
     // by subsequent heuristic parsing steps if there are no author-specified
     // section names.
     field->set_section(kDefaultSection);
@@ skipping 10 matching lines @@
     if (autocomplete_attribute.empty() ||
         autocomplete_attribute == "on" ||
         autocomplete_attribute == "off") {
       continue;
     }
 
     // Any other value, even it is invalid, is considered to be a type hint.
     // This allows a website's author to specify an attribute like
     // autocomplete="other" on a field to disable all Autofill heuristics for
     // the form.
-    *found_types = true;
+    has_author_specified_types_ = true;
 
     // Tokenize the attribute value.  Per the spec, the tokens are parsed in
     // reverse order.
     std::vector<std::string> tokens = base::SplitString(
         autocomplete_attribute, " ", base::KEEP_WHITESPACE,
         base::SPLIT_WANT_NONEMPTY);
 
     // The final token must be the field type.
     // If it is not one of the known types, abort.
     DCHECK(!tokens.empty());
@@ skipping 42 matching lines @@
       // Prepend this section name to the suffix set in the preceding block.
       section = tokens.back().substr(kSectionPrefix.size()) + section;
       tokens.pop_back();
     }
 
     // No other tokens are allowed.  If there are any remaining, abort.
     if (!tokens.empty())
       continue;
 
     if (section != kDefaultSection) {
-      *found_sections = true;
+      has_author_specified_sections_ = true;
       field->set_section(section);
     }
 
     // No errors encountered while parsing!
     // Update the |field|'s type based on what was parsed from the attribute.
     field->SetHtmlType(field_type, mode);
   }
+
+  was_parsed_for_autocomplete_attributes_ = true;
 }
 
 bool FormStructure::FillFields(
     const std::vector<ServerFieldType>& types,
     const InputFieldComparator& matches,
     const base::Callback<base::string16(const AutofillType&)>& get_info,
     const std::string& address_language_code,
     const std::string& app_locale) {
   bool filled_something = false;
   for (size_t i = 0; i < field_count(); ++i) {
@@ skipping 128 matching lines @@
   for (AutofillField* field : fields_) {
     FieldTypeGroup field_type_group = field->Type().group();
     if (field_type_group == CREDIT_CARD)
       field->set_section(field->section() + "-cc");
     else
       field->set_section(field->section() + "-default");
   }
 }
 
 }  // namespace autofill