[Autofill] Add a separate enumeration for HTML field type hints.

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 39 matching lines @@
 const char kAcceptedFeaturesExperiment[] = "e"; // e=experiments
 const char kAcceptedFeaturesAutocheckoutExperiment[] = "a,e"; // a=autocheckout
 const char kClientVersion[] = "6.1.1715.1442/en (GGLL)";
 const char kXMLDeclaration[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
 const char kXMLElementAutofillQuery[] = "autofillquery";
 const char kXMLElementAutofillUpload[] = "autofillupload";
 const char kXMLElementFieldAssignments[] = "fieldassignments";
 const char kXMLElementField[] = "field";
 const char kXMLElementFields[] = "fields";
 const char kXMLElementForm[] = "form";
-const char kBillingSection[] = "billing";
-const char kShippingSection[] = "shipping";
+const char kBillingMode[] = "billing";
+const char kShippingMode[] = "shipping";
 
 // Stip away >= 5 consecutive digits.
 const char kIgnorePatternInFieldName[] = "\\d{5,}+";
 
 // Helper for |EncodeUploadRequest()| that creates a bit field corresponding to
 // |available_field_types| and returns the hex representation as a string.
 std::string EncodeFieldTypes(const ServerFieldTypeSet& available_field_types) {
   // There are |MAX_VALID_FIELD_TYPE| different field types and 8 bits per byte,
   // so we need ceil(MAX_VALID_FIELD_TYPE / 8) bytes to encode the bit field.
   const size_t kNumBytes = (MAX_VALID_FIELD_TYPE + 0x7) / 8;
@@ skipping 86 matching lines @@
 // specified in the implementation section of http://is.gd/whatwg_autocomplete
 // Note that "fax" and "pager" are intentionally ignored, as Chrome does not
 // support filling either type of information.
 bool IsContactTypeHint(const std::string& token) {
   return token == "home" || token == "work" || token == "mobile";
 }
 
 // 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://is.gd/whatwg_autocomplete
-// TODO(isherman): This should use HTML field types, not native ones.
 bool ContactTypeHintMatchesFieldType(const std::string& token,
-                                     ServerFieldType field_type) {
+                                     HtmlFieldType field_type) {
   // The "home" and "work" type hints are only appropriate for email and phone
   // number field types.
   if (token == "home" || token == "work") {
-    return field_type == EMAIL_ADDRESS ||
-        (field_type >= PHONE_HOME_NUMBER &&
-         field_type <= PHONE_HOME_WHOLE_NUMBER);
+    return field_type == HTML_TYPE_EMAIL ||
+        (field_type >= HTML_TYPE_TEL &&
+         field_type <= HTML_TYPE_TEL_LOCAL_SUFFIX);
   }
 
   // The "mobile" type hint is only appropriate for phone number field types.
   // Note that "fax" and "pager" are intentionally ignored, as Chrome does not
   // support filling either type of information.
   if (token == "mobile") {
-    return field_type >= PHONE_HOME_NUMBER &&
-        field_type <= PHONE_HOME_WHOLE_NUMBER;
+    return field_type >= HTML_TYPE_TEL &&
+        field_type <= HTML_TYPE_TEL_LOCAL_SUFFIX;
   }
 
   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
+// |autocomplete_attribute_value|, if there is one, in the context of the given
+// |field|.  Chrome Autofill supports a subset of the field types listed at
 // http://is.gd/whatwg_autocomplete
-// TODO(isherman): This should use HTML field types, not native ones.
-ServerFieldType FieldTypeFromAutocompleteType(
-    const std::string& autocomplete_type,
+HtmlFieldType FieldTypeFromAutocompleteAttributeValue(
+    const std::string& autocomplete_attribute_value,
     const AutofillField& field) {
-  if (autocomplete_type == "name")
-    return NAME_FULL;
+  if (autocomplete_attribute_value == "name")
+    return HTML_TYPE_NAME;
 
-  if (autocomplete_type == "given-name")
-    return NAME_FIRST;
+  if (autocomplete_attribute_value == "given-name")
+    return HTML_TYPE_GIVEN_NAME;
 
-  if (autocomplete_type == "additional-name") {
+  if (autocomplete_attribute_value == "additional-name") {
     if (field.max_length == 1)
-      return NAME_MIDDLE_INITIAL;
+      return HTML_TYPE_ADDITIONAL_NAME_INITIAL;
     else
-      return NAME_MIDDLE;
+      return HTML_TYPE_ADDITIONAL_NAME;
   }
 
-  if (autocomplete_type == "family-name")
-    return NAME_LAST;
+  if (autocomplete_attribute_value == "family-name")
+    return HTML_TYPE_FAMILY_NAME;
 
-  if (autocomplete_type == "honorific-suffix")
-    return NAME_SUFFIX;
+  if (autocomplete_attribute_value == "organization")
+    return HTML_TYPE_ORGANIZATION;
 
-  if (autocomplete_type == "organization")
-    return COMPANY_NAME;
+  if (autocomplete_attribute_value == "address-line1")
+    return HTML_TYPE_ADDRESS_LINE1;
 
-  if (autocomplete_type == "address-line1")
-    return ADDRESS_HOME_LINE1;
+  if (autocomplete_attribute_value == "address-line2")
+    return HTML_TYPE_ADDRESS_LINE2;
 
-  if (autocomplete_type == "address-line2")
-    return ADDRESS_HOME_LINE2;
+  if (autocomplete_attribute_value == "locality")
+    return HTML_TYPE_LOCALITY;
 
-  if (autocomplete_type == "locality")
-    return ADDRESS_HOME_CITY;
+  if (autocomplete_attribute_value == "region")
+    return HTML_TYPE_REGION;
 
-  if (autocomplete_type == "region")
-    return ADDRESS_HOME_STATE;
+  if (autocomplete_attribute_value == "country")
+    return HTML_TYPE_COUNTRY_CODE;
 
-  if (autocomplete_type == "country")
-    return ADDRESS_HOME_COUNTRY;
+  if (autocomplete_attribute_value == "country-name")
+    return HTML_TYPE_COUNTRY_NAME;
 
-  if (autocomplete_type == "postal-code")
-    return ADDRESS_HOME_ZIP;
+  if (autocomplete_attribute_value == "postal-code")
+    return HTML_TYPE_POSTAL_CODE;
 
-  if (autocomplete_type == "cc-name")
-    return CREDIT_CARD_NAME;
+  if (autocomplete_attribute_value == "cc-name")
+    return HTML_TYPE_CREDIT_CARD_NAME;
 
-  if (autocomplete_type == "cc-number")
-    return CREDIT_CARD_NUMBER;
+  if (autocomplete_attribute_value == "cc-number")
+    return HTML_TYPE_CREDIT_CARD_NUMBER;
 
-  if (autocomplete_type == "cc-exp") {
+  if (autocomplete_attribute_value == "cc-exp") {
     if (field.max_length == 5)
-      return CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR;
+      return HTML_TYPE_CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR;
+    else if (field.max_length == 7)
+      return HTML_TYPE_CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR;
     else
-      return CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR;
+      return HTML_TYPE_CREDIT_CARD_EXP;
   }
 
-  if (autocomplete_type == "cc-exp-month")
-    return CREDIT_CARD_EXP_MONTH;
+  if (autocomplete_attribute_value == "cc-exp-month")
+    return HTML_TYPE_CREDIT_CARD_EXP_MONTH;
 
-  if (autocomplete_type == "cc-exp-year") {
+  if (autocomplete_attribute_value == "cc-exp-year") {
     if (field.max_length == 2)
-      return CREDIT_CARD_EXP_2_DIGIT_YEAR;
+      return HTML_TYPE_CREDIT_CARD_EXP_2_DIGIT_YEAR;
+    else if (field.max_length == 4)
+      return HTML_TYPE_CREDIT_CARD_EXP_4_DIGIT_YEAR;
     else
-      return CREDIT_CARD_EXP_4_DIGIT_YEAR;
+      return HTML_TYPE_CREDIT_CARD_EXP_YEAR;
   }
 
-  if (autocomplete_type == "cc-csc")
-    return CREDIT_CARD_VERIFICATION_CODE;
+  if (autocomplete_attribute_value == "cc-csc")
+    return HTML_TYPE_CREDIT_CARD_VERIFICATION_CODE;
 
-  if (autocomplete_type == "cc-type")
-    return CREDIT_CARD_TYPE;
+  if (autocomplete_attribute_value == "cc-type")
+    return HTML_TYPE_CREDIT_CARD_TYPE;
 
-  if (autocomplete_type == "tel")
-    return PHONE_HOME_WHOLE_NUMBER;
+  if (autocomplete_attribute_value == "tel")
+    return HTML_TYPE_TEL;
 
-  if (autocomplete_type == "tel-country-code")
-    return PHONE_HOME_COUNTRY_CODE;
+  if (autocomplete_attribute_value == "tel-country-code")
+    return HTML_TYPE_TEL_COUNTRY_CODE;
 
-  if (autocomplete_type == "tel-national")
-    return PHONE_HOME_CITY_AND_NUMBER;
+  if (autocomplete_attribute_value == "tel-national")
+    return HTML_TYPE_TEL_NATIONAL;
 
-  if (autocomplete_type == "tel-area-code")
-    return PHONE_HOME_CITY_CODE;
+  if (autocomplete_attribute_value == "tel-area-code")
+    return HTML_TYPE_TEL_AREA_CODE;
 
-  if (autocomplete_type == "tel-local")
-    return PHONE_HOME_NUMBER;
+  if (autocomplete_attribute_value == "tel-local")
+    return HTML_TYPE_TEL_LOCAL;
 
-  if (autocomplete_type == "tel-local-prefix")
-    return PHONE_HOME_NUMBER;
+  if (autocomplete_attribute_value == "tel-local-prefix")
+    return HTML_TYPE_TEL_LOCAL_PREFIX;
 
-  if (autocomplete_type == "tel-local-suffix")
-    return PHONE_HOME_NUMBER;
+  if (autocomplete_attribute_value == "tel-local-suffix")
+    return HTML_TYPE_TEL_LOCAL_SUFFIX;
 
-  if (autocomplete_type == "email")
-    return EMAIL_ADDRESS;
+  if (autocomplete_attribute_value == "email")
+    return HTML_TYPE_EMAIL;
 
-  return UNKNOWN_TYPE;
+  return HTML_TYPE_UNKNOWN;
 }
 
 std::string StripDigitsIfRequired(const base::string16& input) {
   UErrorCode status = U_ZERO_ERROR;
   CR_DEFINE_STATIC_LOCAL(icu::UnicodeString, icu_pattern,
                          (kIgnorePatternInFieldName));
   CR_DEFINE_STATIC_LOCAL(icu::RegexMatcher, matcher,
                          (icu_pattern, UREGEX_CASE_INSENSITIVE, status));
   DCHECK_EQ(status, U_ZERO_ERROR);
 
@@ skipping 68 matching lines @@
 
 FormStructure::~FormStructure() {}
 
 void FormStructure::DetermineHeuristicTypes(
     const AutofillMetrics& metric_logger) {
   // 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(PARSE_FOR_AUTOFILL,
-                                            &has_author_specified_types_,
+  ParseFieldTypesFromAutocompleteAttributes(&has_author_specified_types_,
                                             &has_author_specified_sections);
 
   if (!has_author_specified_types_) {
     ServerFieldTypeMap field_type_map;
     FormField::ParseFormFields(fields_.get(), &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())
@@ skipping 208 matching lines @@
         break;
 
       // UNKNOWN_TYPE is reserved for use by the client.
       DCHECK_NE(current_info->field_type, UNKNOWN_TYPE);
 
       ServerFieldType heuristic_type = (*field)->heuristic_type();
       if (heuristic_type != UNKNOWN_TYPE)
         heuristics_detected_fillable_field = true;
 
       (*field)->set_server_type(current_info->field_type);
-      if (heuristic_type != (*field)->Type().server_type())
+      if (heuristic_type != (*field)->Type().GetStorableType())
         query_response_overrode_heuristics = true;
 
       // Copy default value into the field if available.
       if (!current_info->default_value.empty())
         (*field)->set_default_value(current_info->default_value);
 
       ++current_info;
     }
 
     form->UpdateAutofillCount();
@@ skipping 31 matching lines @@
     form.experiment_id = form_structure->server_experiment_id_;
 
     for (std::vector<AutofillField*>::const_iterator field =
              form_structure->fields_.begin();
          field != form_structure->fields_.end(); ++field) {
       form.data.fields.push_back(FormFieldData(**field));
 
       FormFieldDataPredictions annotated_field;
       annotated_field.signature = (*field)->FieldSignature();
       annotated_field.heuristic_type =
-          AutofillType::FieldTypeToString((*field)->heuristic_type());
+          AutofillType((*field)->heuristic_type()).ToString();
       annotated_field.server_type =
-          AutofillType::FieldTypeToString((*field)->server_type());
-      annotated_field.overall_type =
-          AutofillType::FieldTypeToString((*field)->Type().server_type());
+          AutofillType((*field)->server_type()).ToString();
+      annotated_field.overall_type = (*field)->Type().ToString();
       form.fields.push_back(annotated_field);
     }
 
     forms->push_back(form);
   }
 }
 
 std::string FormStructure::FormSignature() const {
   std::string scheme(target_url_.scheme());
   std::string host(target_url_.host());
@@ skipping 151 matching lines @@
     for (ServerFieldTypeSet::const_iterator it = field_types.begin();
          it != field_types.end();
          ++it) {
       // Since we currently only support US phone numbers, the (city code + main
       // digits) number is almost always identical to the whole phone number.
       // TODO(isherman): Improve this logic once we add support for
       // international numbers.
       if (*it == PHONE_HOME_CITY_AND_NUMBER)
         collapsed_field_types.insert(PHONE_HOME_WHOLE_NUMBER);
       else
-        collapsed_field_types.insert(AutofillType::GetEquivalentFieldType(*it));
+        collapsed_field_types.insert(AutofillType(*it).GetStorableType());
     }
 
     // Capture the field's type, if it is unambiguous.
     ServerFieldType field_type = UNKNOWN_TYPE;
     if (collapsed_field_types.size() == 1)
       field_type = *collapsed_field_types.begin();
 
-    ServerFieldType heuristic_type = field->heuristic_type();
-    ServerFieldType server_type = field->server_type();
-    ServerFieldType predicted_type = field->Type().server_type();
+    ServerFieldType heuristic_type =
+        AutofillType(field->heuristic_type()).GetStorableType();
+    ServerFieldType server_type =
+        AutofillType(field->server_type()).GetStorableType();
+    ServerFieldType predicted_type = field->Type().GetStorableType();
 
     // Log heuristic, server, and overall type quality metrics, independently of
     // whether the field was autofilled.
     if (heuristic_type == UNKNOWN_TYPE) {
       metric_logger.LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
                                                field_type, experiment_id);
     } else if (field_types.count(heuristic_type)) {
       metric_logger.LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH,
                                                field_type, experiment_id);
     } else {
@@ skipping 214 matching lines @@
         break;
       case FormStructure::FIELD_ASSIGNMENTS:
         EncodeFieldForFieldAssignments(*field, encompassing_xml_element);
         break;
     }
   }
   return true;
 }
 
 void FormStructure::ParseFieldTypesFromAutocompleteAttributes(
-    ParseTarget parse_target,
     bool* found_types,
     bool* found_sections) {
   const std::string kDefaultSection = "-default";
 
   *found_types = false;
   *found_sections = false;
   for (std::vector<AutofillField*>::iterator it = fields_.begin();
        it != fields_.end(); ++it) {
     AutofillField* field = *it;
 
@@ skipping 31 matching lines @@
     // Tokenize the attribute value.  Per the spec, the tokens are parsed in
     // reverse order.
     std::vector<std::string> tokens;
     Tokenize(autocomplete_attribute, " ", &tokens);
 
     // 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();
-    ServerFieldType field_type =
-        FieldTypeFromAutocompleteType(field_type_token, *field);
-    if (field_type == UNKNOWN_TYPE)
+    HtmlFieldType field_type =
+        FieldTypeFromAutocompleteAttributeValue(field_type_token, *field);
+    if (field_type == HTML_TYPE_UNKNOWN)
       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;
 
       // Chrome Autofill ignores these type hints.
       tokens.pop_back();
     }
 
     // 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.
     DCHECK_EQ(kDefaultSection, field->section());
     std::string section = field->section();
-    if (!tokens.empty() &&
-        (tokens.back() == kShippingSection ||
-         tokens.back() == kBillingSection)) {
-      // Set Autofill field type to billing if section is billing.
-      if (tokens.back() == kBillingSection) {
-        field_type = AutofillType::GetEquivalentBillingFieldType(field_type);
+    HtmlFieldMode mode = HTML_MODE_NONE;
+    if (!tokens.empty()) {
+      if (tokens.back() == kShippingMode)
+        mode = HTML_MODE_SHIPPING;
+      else if (tokens.back() == kBillingMode)
+        mode = HTML_MODE_BILLING;
+    }
 
-        // The Autofill dialog uses the type CREDIT_CARD_NAME to refer to both
-        // the credit card holder's name and the name on the billing address.
-        if (parse_target == PARSE_FOR_AUTOFILL_DIALOG &&
-            field_type == NAME_FULL) {
-          field_type = CREDIT_CARD_NAME;
-        }
-      }
-
+    if (mode != HTML_MODE_NONE) {
       section = "-" + tokens.back();
       tokens.pop_back();
     }
 
     // The preceding token, if any, may be a named section.
     const std::string kSectionPrefix = "section-";
     if (!tokens.empty() &&
         StartsWithASCII(tokens.back(), kSectionPrefix, true)) {
       // 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;
       field->set_section(section);
     }
 
     // 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 == "tel-local-prefix")
-      field->set_phone_part(AutofillField::PHONE_PREFIX);
-    else if (field_type_token == "tel-local-suffix")
-      field->set_phone_part(AutofillField::PHONE_SUFFIX);
+    field->SetHtmlType(field_type, mode);
   }
 }
 
 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.
     base::string16 current_section = fields_.front()->unique_name();
 
     // Keep track of the types we've seen in this section.
     std::set<ServerFieldType> seen_types;
     ServerFieldType previous_type = UNKNOWN_TYPE;
 
     for (std::vector<AutofillField*>::iterator field = fields_.begin();
          field != fields_.end(); ++field) {
-      const ServerFieldType current_type =
-          AutofillType::GetEquivalentFieldType((*field)->Type().server_type());
+      const ServerFieldType current_type = (*field)->Type().GetStorableType();
 
       bool already_saw_current_type = seen_types.count(current_type) > 0;
 
       // Forms often ask for multiple phone numbers -- e.g. both a daytime and
       // evening phone number.  Our phone number detection is also generally a
       // little off.  Hence, ignore this field type as a signal here.
       if (AutofillType(current_type).group() == PHONE_HOME)
         already_saw_current_type = false;
 
       // Some forms have adjacent fields of the same type.  Two common examples:
@@ skipping 27 matching lines @@
        field != fields_.end(); ++field) {
     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