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

components/autofill/core/browser/autofill_profile.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/autofill_profile.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <ostream>
@@ skipping 12 matching lines @@
 #include "components/autofill/core/browser/phone_number.h"
 #include "components/autofill/core/browser/phone_number_i18n.h"
 #include "components/autofill/core/browser/validation.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "grit/component_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace autofill {
 namespace {
 
-// Like |AutofillType::GetEquivalentFieldType()|, but also returns |NAME_FULL|
-// for first, middle, and last name field types.
-ServerFieldType GetEquivalentFieldTypeCollapsingNames(ServerFieldType type) {
-  if (type == NAME_FIRST || type == NAME_MIDDLE || type == NAME_LAST ||
-      type == NAME_MIDDLE_INITIAL)
+// Like |AutofillType::GetStorableType()|, but also returns |NAME_FULL| for
+// first, middle, and last name field types.
+ServerFieldType GetStorableTypeCollapsingNames(ServerFieldType type) {
+  ServerFieldType storable_type = AutofillType(type).GetStorableType();
+  if (AutofillType(storable_type).group() == NAME)
     return NAME_FULL;
 
-  return AutofillType::GetEquivalentFieldType(type);
+  return storable_type;
 }
 
 // Fills |distinguishing_fields| with a list of fields to use when creating
 // labels that can help to distinguish between two profiles. Draws fields from
 // |suggested_fields| if it is non-NULL; otherwise returns a default list.
 // If |suggested_fields| is non-NULL, does not include |excluded_field| in the
 // list. Otherwise, |excluded_field| is ignored, and should be set to
 // |UNKNOWN_TYPE| by convention. The resulting list of fields is sorted in
 // decreasing order of importance.
 void GetFieldsForDistinguishingProfiles(
@@ skipping 18 matching lines @@
     distinguishing_fields->assign(
         kDefaultDistinguishingFields,
         kDefaultDistinguishingFields + arraysize(kDefaultDistinguishingFields));
     return;
   }
 
   // Keep track of which fields we've seen so that we avoid duplicate entries.
   // Always ignore fields of unknown type and the excluded field.
   std::set<ServerFieldType> seen_fields;
   seen_fields.insert(UNKNOWN_TYPE);
-  seen_fields.insert(GetEquivalentFieldTypeCollapsingNames(excluded_field));
+  seen_fields.insert(GetStorableTypeCollapsingNames(excluded_field));
 
   distinguishing_fields->clear();
   for (std::vector<ServerFieldType>::const_iterator it =
            suggested_fields->begin();
        it != suggested_fields->end(); ++it) {
-    ServerFieldType suggested_type = GetEquivalentFieldTypeCollapsingNames(*it);
+    ServerFieldType suggested_type = GetStorableTypeCollapsingNames(*it);
     if (seen_fields.insert(suggested_type).second)
       distinguishing_fields->push_back(suggested_type);
   }
 
   // Special case: If the excluded field is a partial name (e.g. first name) and
   // the suggested fields include other name fields, include |NAME_FULL| in the
   // list of distinguishing fields as a last-ditch fallback. This allows us to
   // distinguish between profiles that are identical except for the name.
   if (excluded_field != NAME_FULL &&
-      GetEquivalentFieldTypeCollapsingNames(excluded_field) == NAME_FULL) {
+      GetStorableTypeCollapsingNames(excluded_field) == NAME_FULL) {
     for (std::vector<ServerFieldType>::const_iterator it =
              suggested_fields->begin();
          it != suggested_fields->end(); ++it) {
       if (*it != excluded_field &&
-          GetEquivalentFieldTypeCollapsingNames(*it) == NAME_FULL) {
+          GetStorableTypeCollapsingNames(*it) == NAME_FULL) {
         distinguishing_fields->push_back(NAME_FULL);
         break;
       }
     }
   }
 }
 
 // A helper function for string streaming.  Concatenates multi-valued entries
 // stored for a given |type| into a single string.  This string is returned.
 const base::string16 MultiString(const AutofillProfile& p,
                                  ServerFieldType type) {
   std::vector<base::string16> values;
   p.GetRawMultiInfo(type, &values);
   base::string16 accumulate;
   for (size_t i = 0; i < values.size(); ++i) {
     if (i > 0)
       accumulate += ASCIIToUTF16(" ");
     accumulate += values[i];
   }
   return accumulate;
 }
 
 base::string16 GetFormGroupInfo(const FormGroup& form_group,
                                 const AutofillType& type,
                                 const std::string& app_locale) {
   return app_locale.empty() ?
-      form_group.GetRawInfo(type.server_type()) :
+      form_group.GetRawInfo(type.GetStorableType()) :
       form_group.GetInfo(type, app_locale);
 }
 
 template <class T>
 void CopyValuesToItems(ServerFieldType type,
                        const std::vector<base::string16>& values,
                        std::vector<T>* form_group_items,
                        const T& prototype) {
   form_group_items->resize(values.size(), prototype);
   for (size_t i = 0; i < form_group_items->size(); ++i) {
@@ skipping 130 matching lines @@
 void AutofillProfile::GetMatchingTypes(
     const base::string16& text,
     const std::string& app_locale,
     ServerFieldTypeSet* matching_types) const {
   FormGroupList info = FormGroups();
   for (FormGroupList::const_iterator it = info.begin(); it != info.end(); ++it)
     (*it)->GetMatchingTypes(text, app_locale, matching_types);
 }
 
 base::string16 AutofillProfile::GetRawInfo(ServerFieldType type) const {
-  ServerFieldType return_type = AutofillType::GetEquivalentFieldType(type);
-  const FormGroup* form_group = FormGroupForType(AutofillType(return_type));
+  const FormGroup* form_group = FormGroupForType(AutofillType(type));
   if (!form_group)
     return base::string16();
 
-  return form_group->GetRawInfo(return_type);
+  return form_group->GetRawInfo(type);
 }
 
 void AutofillProfile::SetRawInfo(ServerFieldType type,
                                  const base::string16& value) {
   FormGroup* form_group = MutableFormGroupForType(AutofillType(type));
   if (form_group)
     form_group->SetRawInfo(type, CollapseWhitespace(value, false));
 }
 
 base::string16 AutofillProfile::GetInfo(const AutofillType& type,
                                         const std::string& app_locale) const {
-  ServerFieldType return_type =
-      AutofillType::GetEquivalentFieldType(type.server_type());
-  const FormGroup* form_group = FormGroupForType(AutofillType(return_type));
+  const FormGroup* form_group = FormGroupForType(type);
   if (!form_group)
     return base::string16();
 
-  return form_group->GetInfo(AutofillType(return_type), app_locale);
+  return form_group->GetInfo(type, app_locale);
 }
 
 bool AutofillProfile::SetInfo(const AutofillType& type,
                               const base::string16& value,
                               const std::string& app_locale) {
   FormGroup* form_group = MutableFormGroupForType(type);
   if (!form_group)
     return false;
 
   return
@@ skipping 44 matching lines @@
 }
 
 void AutofillProfile::FillFormField(const AutofillField& field,
                                     size_t variant,
                                     const std::string& app_locale,
                                     FormFieldData* field_data) const {
   AutofillType type = field.Type();
   DCHECK_NE(CREDIT_CARD, type.group());
   DCHECK(field_data);
 
-  if (type.server_type() == PHONE_HOME_NUMBER ||
-      type.server_type() == PHONE_BILLING_NUMBER) {
+  if (type.GetStorableType() == PHONE_HOME_NUMBER) {
     FillPhoneNumberField(field, variant, app_locale, field_data);
   } else if (field_data->form_control_type == "select-one") {
     FillSelectControl(type, app_locale, field_data);
   } else {
     std::vector<base::string16> values;
     GetMultiInfo(type, app_locale, &values);
     if (variant >= values.size()) {
       // If the variant is unavailable, bail.  This case is reachable, for
       // example if Sync updates a profile during the filling process.
       return;
@@ skipping 523 matching lines @@
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STATE))
       << " "
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_ZIP))
       << " "
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))
       << " "
       << UTF16ToUTF8(MultiString(profile, PHONE_HOME_WHOLE_NUMBER));
 }
 
 }  // namespace autofill