[Autofill] Update the autocomplete types implementation to match the current HTML spec.

chrome/browser/autofill/form_structure.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 "chrome/browser/autofill/form_structure.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 67 matching lines @@
   // Print all meaningfull bytes into a string.
   std::string data_presence;
   data_presence.reserve(data_end * 2 + 1);
   for (size_t i = 0; i < data_end; ++i) {
     base::StringAppendF(&data_presence, "%02x", bit_field[i]);
   }
 
   return data_presence;
 }
 
-bool UpdateFromAutocompleteType(const string16& autocomplete_type,
-                                AutofillField* field) {
-  if (autocomplete_type == ASCIIToUTF16("given-name")) {
-    field->set_heuristic_type(NAME_FIRST);
-    return true;
+// Returns |true| iff the |token| is a type hint for a contact field, as
+// specified in the implementation section of
+// http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#autofilling-form-controls:-the-autocomplete-attribute

[Dan Beam, 2012/10/19 00:12:44]

nit: it might be useful to URL shorten some of these links, IMO

[Ilya Sherman, 2012/10/19 04:19:32]

Done.

+// Note that "fax" is intentionally ignored, as Chrome does not support filling
+// fax information.
+bool IsContactTypeHint(const string16& token) {
+  return

[Dan Beam, 2012/10/19 00:12:44]

nit: isn't the chromium style more

  return token == ASCIIToUTF16("home") ||
         token == ASCIIToUTF16("work") ||
         token == ASCIIToUTF16("mobile") ||
         token == ASCIIToUTF16("pager");

? also, who uses pagers?

[Ilya Sherman, 2012/10/19 04:19:32]

Done.

[Dan Beam, 2012/10/23 00:28:59]

it doesn't seem like anything other than stripping of ASCIIToUTF16() has changed
in the upstream code, but it's not a huge deal...

[Ilya Sherman, 2012/10/23 01:06:12]

Whoops.  Actually done now.

+      token == ASCIIToUTF16("home") ||
+      token == ASCIIToUTF16("work") ||
+      token == ASCIIToUTF16("mobile") ||
+      token == ASCIIToUTF16("pager");
+}
+
+// Returns |true| iff the |token| is a type hint appropriate for a field of the
+// given |field_type|, as specified in the implementation section of
+// http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#autofilling-form-controls:-the-autocomplete-attribute
+bool ContactTypeHintMatchesFieldType(const string16& token,
+                                     AutofillFieldType field_type) {
+  // The "home" and "work" type hints are only appropriate for email and phone
+  // number field types.
+  if (token == ASCIIToUTF16("home") || token == ASCIIToUTF16("work")) {
+    return
+        field_type == EMAIL_ADDRESS ||
+        (field_type >= PHONE_HOME_NUMBER &&
+         field_type <= PHONE_HOME_WHOLE_NUMBER);
   }
 
-  if (autocomplete_type == ASCIIToUTF16("middle-name")) {
-    field->set_heuristic_type(NAME_MIDDLE);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("middle-initial")) {
-    field->set_heuristic_type(NAME_MIDDLE_INITIAL);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("surname")) {
-    field->set_heuristic_type(NAME_LAST);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("full-name")) {
-    field->set_heuristic_type(NAME_FULL);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("street-address") ||
-      autocomplete_type == ASCIIToUTF16("address-line1")) {
-    field->set_heuristic_type(ADDRESS_HOME_LINE1);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("address-line2")) {
-    field->set_heuristic_type(ADDRESS_HOME_LINE2);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("locality") ||
-      autocomplete_type == ASCIIToUTF16("city")) {
-    field->set_heuristic_type(ADDRESS_HOME_CITY);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("administrative-area") ||
-      autocomplete_type == ASCIIToUTF16("state") ||
-      autocomplete_type == ASCIIToUTF16("province") ||
-      autocomplete_type == ASCIIToUTF16("region")) {
-    field->set_heuristic_type(ADDRESS_HOME_STATE);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("postal-code")) {
-    field->set_heuristic_type(ADDRESS_HOME_ZIP);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("country")) {
-    field->set_heuristic_type(ADDRESS_HOME_COUNTRY);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("organization")) {
-    field->set_heuristic_type(COMPANY_NAME);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("email")) {
-    field->set_heuristic_type(EMAIL_ADDRESS);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("phone-full")) {
-    field->set_heuristic_type(PHONE_HOME_WHOLE_NUMBER);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("phone-country-code")) {
-    field->set_heuristic_type(PHONE_HOME_COUNTRY_CODE);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("phone-national")) {
-    field->set_heuristic_type(PHONE_HOME_CITY_AND_NUMBER);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("phone-area-code")) {
-    field->set_heuristic_type(PHONE_HOME_CITY_CODE);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("phone-local")) {
-    field->set_heuristic_type(PHONE_HOME_NUMBER);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("phone-local-prefix")) {
-    field->set_heuristic_type(PHONE_HOME_NUMBER);
-    field->set_phone_part(AutofillField::PHONE_PREFIX);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("phone-local-suffix")) {
-    field->set_heuristic_type(PHONE_HOME_NUMBER);
-    field->set_phone_part(AutofillField::PHONE_SUFFIX);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("cc-full-name")) {
-    field->set_heuristic_type(CREDIT_CARD_NAME);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("cc-number")) {
-    field->set_heuristic_type(CREDIT_CARD_NUMBER);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("cc-exp-month")) {
-    field->set_heuristic_type(CREDIT_CARD_EXP_MONTH);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("cc-exp-year")) {
-    if (field->max_length == 2)
-      field->set_heuristic_type(CREDIT_CARD_EXP_2_DIGIT_YEAR);
-    else
-      field->set_heuristic_type(CREDIT_CARD_EXP_4_DIGIT_YEAR);
-    return true;
-  }
-
-  if (autocomplete_type == ASCIIToUTF16("cc-exp")) {
-    if (field->max_length == 5)
-      field->set_heuristic_type(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR);
-    else
-      field->set_heuristic_type(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
-    return true;
+  // The remaining type hints are only appropriate for phone number field types.
+  // Note that "fax" is intentionally ignored, as Chrome does not support
+  // filling fax information.
+  if (token == ASCIIToUTF16("mobile") || token == ASCIIToUTF16("pager")) {
+    return
+        field_type >= PHONE_HOME_NUMBER &&
+        field_type <= PHONE_HOME_WHOLE_NUMBER;
   }
 
   return false;
 }
 
+// Returns the Chrome Autofill-supported field type corresponding to the given
+// |autocomplete_type|, if there is one, in the context of the given |field|.
+// Chrome Autofill supports a subset of the field types listed at
+// http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#autofilling-form-controls:-the-autocomplete-attribute
+AutofillFieldType FieldTypeFromAutocompleteType(
+    const string16& autocomplete_type,
+    const AutofillField& field) {
+  if (autocomplete_type == ASCIIToUTF16("name"))
+    return NAME_FULL;
+
+  if (autocomplete_type == ASCIIToUTF16("given-name"))
+    return NAME_FIRST;
+
+  if (autocomplete_type == ASCIIToUTF16("additional-name")) {
+    if (field.max_length == 1)
+      return NAME_MIDDLE_INITIAL;
+    else
+      return NAME_MIDDLE;
+  }
+
+  if (autocomplete_type == ASCIIToUTF16("family-name"))
+    return NAME_LAST;
+
+  if (autocomplete_type == ASCIIToUTF16("honorific-suffix"))
+    return NAME_SUFFIX;
+
+  if (autocomplete_type == ASCIIToUTF16("organization"))

[Dan Beam, 2012/10/19 00:12:44]

organization == company always?

[Ilya Sherman, 2012/10/19 04:19:32]

The spec defines this token as meaning "Company name corresponding to the
person, address, or contact information in the other fields associated with this
field".

[Dan Beam, 2012/10/19 04:25:41]

I know, I noticed that.  My issue is really with the spec... :(

+    return COMPANY_NAME;
+
+  if (autocomplete_type == ASCIIToUTF16("street-address") ||
+      autocomplete_type == ASCIIToUTF16("address-line1"))
+    return ADDRESS_HOME_LINE1;
+
+  if (autocomplete_type == ASCIIToUTF16("address-line2"))
+    return ADDRESS_HOME_LINE2;
+
+  if (autocomplete_type == ASCIIToUTF16("locality"))
+    return ADDRESS_HOME_CITY;
+
+  if (autocomplete_type == ASCIIToUTF16("region"))

[Dan Beam, 2012/10/19 00:12:44]

region == state always?

[Ilya Sherman, 2012/10/19 04:19:32]

"state" is the name that Autofill internally uses to refer to this, yes.  It's
not a perfect name, but it's at least really easy for US folks to quickly
understand.

[Dan Beam, 2012/10/19 04:25:41]

So we could have things like Bavaria as the state...?  Could we check that the
max_length is 2 and/or or that it's in a U.S. state whitelist?

[Ilya Sherman, 2012/10/19 04:54:11]

Yes, we could have things like Bavaria as the "state", and we would fill the
form correctly (assuming that the user has a German address that specifies
Bavaria as a state).  Ok, I'm not sure if German addresses actually include
these sorts of states; but we certainly support Quebec as having this data type,
even though residents would more likely refer to it as a province than a state. 
For the purposes of Autofill internals, "state" is just the next biggest
geographic region from "city", and the next smallest one from "country".

+    return ADDRESS_HOME_STATE;
+
+  if (autocomplete_type == ASCIIToUTF16("country"))
+    return ADDRESS_HOME_COUNTRY;
+
+  if (autocomplete_type == ASCIIToUTF16("postal-code"))
+    return ADDRESS_HOME_ZIP;

[Dan Beam, 2012/10/19 00:12:44]

postal-code == zip always?

[Ilya Sherman, 2012/10/19 04:19:32]

Ditto: This is just what the Autofill code calls this data type internally.

+
+  if (autocomplete_type == ASCIIToUTF16("cc-name"))
+    return CREDIT_CARD_NAME;
+
+  if (autocomplete_type == ASCIIToUTF16("cc-number"))
+    return CREDIT_CARD_NUMBER;
+
+  if (autocomplete_type == ASCIIToUTF16("cc-exp")) {
+    if (field.max_length == 5)
+      return CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR;
+    else
+      return CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR;
+  }
+
+  if (autocomplete_type == ASCIIToUTF16("cc-exp-month"))
+    return CREDIT_CARD_EXP_MONTH;
+
+  if (autocomplete_type == ASCIIToUTF16("cc-exp-year")) {
+    if (field.max_length == 2)
+      return CREDIT_CARD_EXP_2_DIGIT_YEAR;
+    else
+      return CREDIT_CARD_EXP_4_DIGIT_YEAR;
+  }
+
+  if (autocomplete_type == ASCIIToUTF16("tel"))
+    return PHONE_HOME_WHOLE_NUMBER;
+
+  if (autocomplete_type == ASCIIToUTF16("tel-country-code"))
+    return PHONE_HOME_COUNTRY_CODE;
+
+  if (autocomplete_type == ASCIIToUTF16("tel-national"))
+    return PHONE_HOME_CITY_AND_NUMBER;
+
+  if (autocomplete_type == ASCIIToUTF16("tel-area-code"))
+    return PHONE_HOME_CITY_CODE;
+
+  if (autocomplete_type == ASCIIToUTF16("tel-local"))
+    return PHONE_HOME_NUMBER;
+
+  if (autocomplete_type == ASCIIToUTF16("tel-local-prefix"))
+    return PHONE_HOME_NUMBER;
+
+  if (autocomplete_type == ASCIIToUTF16("tel-local-suffix"))
+    return PHONE_HOME_NUMBER;
+
+  if (autocomplete_type == ASCIIToUTF16("email"))
+    return EMAIL_ADDRESS;
+
+  return UNKNOWN_TYPE;
+}
+
 }  // namespace
 
 FormStructure::FormStructure(const FormData& form)
     : form_name_(form.name),
       source_url_(form.origin),
       target_url_(form.action),
       autofill_count_(0),
       upload_required_(USE_UPLOAD_RATES),
       server_experiment_id_("no server response"),
       has_author_specified_types_(false) {
@@ skipping 25 matching lines @@
   } else {
     // Either the method is 'get', or we don't know.  In this case we default
     // to GET.
     method_ = GET;
   }
 }
 
 FormStructure::~FormStructure() {}
 
 void FormStructure::DetermineHeuristicTypes() {
-  // First, try to detect field types based on the fields' |autocompletetype|
-  // attributes.  If there is at least one form field with this attribute, don't
-  // try to apply other heuristics to match fields in this form.
+  // First, try to detect field types based on each field's |autocomplete|
+  // attribute value.  If there is at least one form field with that specifies

[Dan Beam, 2012/10/19 00:12:44]

If there is at least one form field that specifies

[Ilya Sherman, 2012/10/19 04:19:32]

Done.

+  // an autocomplete type hint, don't try to apply other heuristics to match
+  // fields in this form.
   bool has_author_specified_sections;
-  ParseAutocompletetypeAttributes(&has_author_specified_types_,
-                                  &has_author_specified_sections);
+  ParseFieldTypesFromAutocompleteAttributes(&has_author_specified_types_,
+                                            &has_author_specified_sections);
 
   if (!has_author_specified_types_) {
     FieldTypeMap field_type_map;
     FormField::ParseFormFields(fields_.get(), &field_type_map);
     for (size_t index = 0; index < field_count(); index++) {
       AutofillField* field = fields_[index];
       FieldTypeMap::iterator iter = field_type_map.find(field->unique_name());
       if (iter != field_type_map.end())
         field->set_heuristic_type(iter->second);
     }
@@ skipping 579 matching lines @@
       buzz::XmlElement *field_element = new buzz::XmlElement(
           buzz::QName(kXMLElementField));
       field_element->SetAttr(buzz::QName(kAttributeSignature),
                              field->FieldSignature());
       encompassing_xml_element->AddElement(field_element);
     }
   }
   return true;
 }
 
-void FormStructure::ParseAutocompletetypeAttributes(bool* found_attribute,
-                                                    bool* found_sections) {
-  *found_attribute = false;
+// TODO(isherman): This method could use a shorter name...

[Ilya Sherman, 2012/10/18 00:11:19]

Any suggestions?

[Dan Beam, 2012/10/19 00:12:44]

Not really, maybe just FieldTypeFromAutocompleteAttribute but I don't mind long
names as long as they're descriptive like this one.

[Ilya Sherman, 2012/10/19 04:19:32]

Ok.  I like having parse in the name, so I guess let's just leave it as is: long
and descriptive.

+void FormStructure::ParseFieldTypesFromAutocompleteAttributes(
+    bool* found_types,
+    bool* found_sections) {
+  *found_types = false;
   *found_sections = false;
   for (std::vector<AutofillField*>::iterator field = fields_.begin();
        field != fields_.end(); ++field) {
-    if ((*field)->autocomplete_type.empty())
+    // Canonicalize the attribute value by trimming whitespace and converting to
+    // lowercase ASCII.
+    string16 autocomplete_attribute = (*field)->autocomplete_attribute;
+    TrimWhitespace(autocomplete_attribute, TRIM_ALL, &autocomplete_attribute);
+    autocomplete_attribute = StringToLowerASCII(autocomplete_attribute);
+
+    // The autocomplete attribute is overloaded: it can specify either a field
+    // type hint or whether autocomplete should be enabled at all.  Ignore the
+    // latter type of attribute value.
+    if (autocomplete_attribute.empty() ||
+        autocomplete_attribute == ASCIIToUTF16("on") ||
+        autocomplete_attribute == ASCIIToUTF16("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;
+
+    // Tokenize the attribute value.  Per the spec, the tokens are parsed in
+    // reverse order.
+    std::vector<string16> tokens;
+    Tokenize(autocomplete_attribute, ASCIIToUTF16(" "), &tokens);
+
+    // The final token must be the field type.
+    // If it is not one of the known types, abort.
+    DCHECK(!tokens.empty());
+    string16 field_type_token = tokens.back();
+    tokens.pop_back();
+    AutofillFieldType field_type =
+        FieldTypeFromAutocompleteType(field_type_token, **field);
+    if (field_type == UNKNOWN_TYPE)
       continue;
 
-    *found_attribute = true;
-    std::vector<string16> types;
-    Tokenize((*field)->autocomplete_type, ASCIIToUTF16(" "), &types);
+    // 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.

[Dan Beam, 2012/10/19 00:12:44]

you may want to add/hint at that there could be valid tokens that we haven't
reached yet, but that the whole attribute is now invalidated

[Ilya Sherman, 2012/10/19 04:19:32]

Done.

+      if (!ContactTypeHintMatchesFieldType(tokens.back(), field_type))
+        continue;
 
-    // Look for a named section.
-    const string16 kSectionPrefix = ASCIIToUTF16("section-");
-    if (!types.empty() && StartsWith(types.front(), kSectionPrefix, true)) {
-      *found_sections = true;
-      (*field)->set_section(types.front().substr(kSectionPrefix.size()));
+      // Chrome Autofill ignore these type hints.

[Dan Beam, 2012/10/19 00:12:44]

ignores

[Ilya Sherman, 2012/10/19 04:19:32]

Done.

+      tokens.pop_back();
     }
 
-    // Look for specified types.
-    for (std::vector<string16>::const_iterator type = types.begin();
-         type != types.end(); ++type) {
-      if (UpdateFromAutocompleteType(*type, *field))
-        break;
+    // The preceding token, if any, may be a fixed string that is either
+    // "shipping" or "billing".  Chrome Autofill treats these as implicit
+    // section name suffixes.
+    if (!tokens.empty() &&
+        (tokens.back() == ASCIIToUTF16("shipping") ||
+         tokens.back() == ASCIIToUTF16("billing"))) {
+      *found_sections = true;
+      (*field)->set_section(ASCIIToUTF16("-") + tokens.back());
+      tokens.pop_back();
+    } else {
+      // To prevent potential section name collisions, add a default suffix for

[Dan Beam, 2012/10/19 00:12:44]

you might want to add a comment here explaining what you told me over IM with an
example

[Ilya Sherman, 2012/10/19 04:19:32]

Done.

+      // other fields.
+      (*field)->set_section(ASCIIToUTF16("-default"));
     }
+
+    // The preceding token, if any, may be a named section.
+    const string16 kSectionPrefix = ASCIIToUTF16("section-");
+    if (!tokens.empty() && StartsWith(tokens.back(), kSectionPrefix, true)) {
+      *found_sections = true;
+      // Prepend this section name to the suffix set in the preceding block.
+      (*field)->set_section(
+          tokens.back().substr(kSectionPrefix.size()) + (*field)->section());
+      tokens.pop_back();
+    }
+
+    // No other tokens are allowed.  If there are any remaining, abort.
+    if (!tokens.empty())
+      continue;
+
+    // No errors encountered while parsing!
+    // Update the |field|'s type based on what was parsed from the attribute.
+    (*field)->set_heuristic_type(field_type);
+    if (field_type_token == ASCIIToUTF16("tel-local-prefix"))
+      (*field)->set_phone_part(AutofillField::PHONE_PREFIX);
+    else if (field_type_token == ASCIIToUTF16("tel-local-suffix"))
+      (*field)->set_phone_part(AutofillField::PHONE_SUFFIX);
   }
 }
 
 void FormStructure::IdentifySections(bool has_author_specified_sections) {
   if (fields_.empty())
     return;
 
   if (!has_author_specified_sections) {
     // Name sections after the first field in the section.
     string16 current_section = fields_.front()->unique_name();
@@ skipping 45 matching lines @@
   for (std::vector<AutofillField*>::iterator field = fields_.begin();
        field != fields_.end(); ++field) {
     AutofillType::FieldTypeGroup field_type_group =
         AutofillType((*field)->type()).group();
     if (field_type_group == AutofillType::CREDIT_CARD)
       (*field)->set_section((*field)->section() + ASCIIToUTF16("-cc"));
     else
       (*field)->set_section((*field)->section() + ASCIIToUTF16("-default"));
   }
 }