[Autofill] Parse forms that have 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 <stdint.h>
 
 #include <map>
 #include <utility>
@@ skipping 348 matching lines @@
 
   if (autocomplete_attribute_value == "tel-local-prefix")
     return HTML_TYPE_TEL_LOCAL_PREFIX;
 
   if (autocomplete_attribute_value == "tel-local-suffix")
     return HTML_TYPE_TEL_LOCAL_SUFFIX;
 
   if (autocomplete_attribute_value == "email")
     return HTML_TYPE_EMAIL;
 
-  return HTML_TYPE_UNKNOWN;
+  if (autocomplete_attribute_value == "")

[Mathieu, 2016/01/13 01:03:20]

this should probably be first in the function, because it will occur more often
(assuming this code is run for every field?)

[sebsg, 2016/01/13 16:05:13]

Absolutely, I should have thought of this. Thanks!

+    return HTML_TYPE_UNSPECIFIED;
+
+  return HTML_TYPE_UNRECOGNIZED;
 }
 
 std::string StripDigitsIfRequired(const base::string16& input) {
   std::string return_string = base::UTF16ToUTF8(input);
 
   re2::RE2::GlobalReplace(&return_string, re2::RE2(kIgnorePatternInFieldName),
                           std::string());
   return return_string;
 }
 
@@ skipping 39 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.
   if (!was_parsed_for_autocomplete_attributes_)
     ParseFieldTypesFromAutocompleteAttributes();
 
-  if (!has_author_specified_types_) {
+  if (active_field_count() >= kRequiredFieldsForPredictionRoutines) {
     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);
     }
   }
@@ skipping 335 matching lines @@
 
   bool has_text_field = false;
   for (const AutofillField* it : *this) {
     has_text_field |= it->form_control_type != "select-one";
   }
 
   return has_text_field;
 }
 
 bool FormStructure::ShouldBeCrowdsourced() const {
-  return (has_password_field_ || !has_author_specified_types_) &&
-      ShouldBeParsed();
+  return (has_password_field_ ||
+          active_field_count() >= kRequiredFieldsForPredictionRoutines) &&
+         ShouldBeParsed();
 }
 
 void FormStructure::UpdateFromCache(const FormStructure& cached_form) {
   // Map from field signatures to cached fields.
   std::map<std::string, const AutofillField*> cached_fields;
   for (size_t i = 0; i < cached_form.field_count(); ++i) {
     const AutofillField* field = cached_form.field(i);
     cached_fields[field->FieldSignature()] = field;
   }
 
@@ skipping 362 matching lines @@
         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());
     std::string field_type_token = tokens.back();
     tokens.pop_back();
     HtmlFieldType field_type =
         FieldTypeFromAutocompleteAttributeValue(field_type_token, *field);
-    if (field_type == HTML_TYPE_UNKNOWN)
+    if (field_type == HTML_TYPE_UNSPECIFIED)

[Mathieu, 2016/01/13 01:03:20]

shouldn't we also "continue" if it's unrecognized?

[sebsg, 2016/01/13 16:05:13]

No because if we continue, it's like we give up on the field. So heuristics and
server predictions will be taken into account when deciding the overall type. If
it is unrecognized we don't want the overall type to be unrecognized so we need
to follow the path. 

       continue;
 
     // The preceding token, if any, may be a type hint.
     if (!tokens.empty() && IsContactTypeHint(tokens.back())) {
       // If it is, it must match the field type; otherwise, abort.
       // Note that an invalid token invalidates the entire attribute value, even
       // if the other tokens are valid.
       if (!ContactTypeHintMatchesFieldType(tokens.back(), field_type))
         continue;
 
@@ skipping 185 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