[Autofill] Move FieldTypeGroup out of the AutofillType class.

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 298 matching lines @@
     return false;
 
   return
       form_group->SetInfo(type, CollapseWhitespace(value, false), app_locale);
 }
 
 void AutofillProfile::SetRawMultiInfo(
     AutofillFieldType type,
     const std::vector<base::string16>& values) {
   switch (AutofillType(type).group()) {
-    case AutofillType::NAME:
-    case AutofillType::NAME_BILLING:
+    case NAME:
+    case NAME_BILLING:
       CopyValuesToItems(type, values, &name_, NameInfo());
       break;
-    case AutofillType::EMAIL:
+    case EMAIL:
       CopyValuesToItems(type, values, &email_, EmailInfo());
       break;
-    case AutofillType::PHONE_HOME:
-    case AutofillType::PHONE_BILLING:
+    case PHONE_HOME:
+    case PHONE_BILLING:
       CopyValuesToItems(type,
                         values,
                         &phone_number_,
                         PhoneNumber(this));
       break;
     default:
       if (values.size() == 1) {
         SetRawInfo(type, values[0]);
       } else if (values.size() == 0) {
         SetRawInfo(type, base::string16());
@@ skipping 15 matching lines @@
                                    const std::string& app_locale,
                                    std::vector<base::string16>* values) const {
   GetMultiInfoImpl(type, app_locale, values);
 }
 
 void AutofillProfile::FillFormField(const AutofillField& field,
                                     size_t variant,
                                     const std::string& app_locale,
                                     FormFieldData* field_data) const {
   AutofillFieldType type = field.type();
-  DCHECK_NE(AutofillType::CREDIT_CARD, AutofillType(type).group());
+  DCHECK_NE(CREDIT_CARD, AutofillType(type).group());
   DCHECK(field_data);
 
   if (type == PHONE_HOME_NUMBER || type == PHONE_BILLING_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()) {
@@ skipping 133 matching lines @@
   GetNonEmptyTypes(app_locale, &types);
 
   for (FieldTypeSet::const_iterator iter = types.begin(); iter != types.end();
        ++iter) {
     if (*iter == NAME_FULL) {
       // Ignore the compound "full name" field type.  We are only interested in
       // comparing the constituent parts.  For example, if |this| has a middle
       // name saved, but |profile| lacks one, |profile| could still be a subset
       // of |this|.
       continue;
-    } else if (AutofillType(*iter).group() == AutofillType::PHONE_HOME) {
+    } else if (AutofillType(*iter).group() == PHONE_HOME) {
       // Phone numbers should be canonicalized prior to being compared.
       if (*iter != PHONE_HOME_WHOLE_NUMBER) {
         continue;
       } else if (!i18n::PhoneNumbersMatch(
             GetRawInfo(*iter),
             profile.GetRawInfo(*iter),
             UTF16ToASCII(GetRawInfo(ADDRESS_HOME_COUNTRY)),
             app_locale)) {
         return false;
       }
@@ skipping 30 matching lines @@
       // GetMultiInfo always returns at least one element, even if the profile
       // has no data stored for this field type.
       if (existing_values.size() == 1 && existing_values.front().empty())
         existing_values.clear();
 
       FieldTypeGroup group = AutofillType(*iter).group();
       for (std::vector<base::string16>::iterator value_iter =
                new_values.begin();
            value_iter != new_values.end(); ++value_iter) {
         // Don't add duplicates.
-        if (group == AutofillType::PHONE_HOME) {
+        if (group == PHONE_HOME) {
           AddPhoneIfUnique(*value_iter, app_locale, &existing_values);
         } else {
           std::vector<base::string16>::const_iterator existing_iter =
               std::find_if(
                   existing_values.begin(), existing_values.end(),
                   std::bind1st(CaseInsensitiveStringEquals(), *value_iter));
           if (existing_iter == existing_values.end())
             existing_values.insert(existing_values.end(), *value_iter);
         }
       }
       SetRawMultiInfo(*iter, existing_values);
     } else {
       base::string16 new_value = profile.GetRawInfo(*iter);
       if (StringToLowerASCII(GetRawInfo(*iter)) !=
               StringToLowerASCII(new_value)) {
         SetRawInfo(*iter, new_value);
       }
     }
   }
 }
 
 // static
 bool AutofillProfile::SupportsMultiValue(AutofillFieldType type) {
-  AutofillType::FieldTypeGroup group = AutofillType(type).group();
-  return group == AutofillType::NAME ||
-         group == AutofillType::NAME_BILLING ||
-         group == AutofillType::EMAIL ||
-         group == AutofillType::PHONE_HOME ||
-         group == AutofillType::PHONE_BILLING;
+  FieldTypeGroup group = AutofillType(type).group();
+  return group == NAME ||
+         group == NAME_BILLING ||
+         group == EMAIL ||
+         group == PHONE_HOME ||
+         group == PHONE_BILLING;
 }
 
 // static
 bool AutofillProfile::AdjustInferredLabels(
     std::vector<AutofillProfile*>* profiles) {
   const size_t kMinimalFieldsShown = 2;
 
   std::vector<base::string16> created_labels;
   CreateInferredLabels(profiles, NULL, UNKNOWN_TYPE, kMinimalFieldsShown,
                        &created_labels);
@@ skipping 78 matching lines @@
   }
 
   return false;
 }
 
 void AutofillProfile::GetMultiInfoImpl(
     AutofillFieldType type,
     const std::string& app_locale,
     std::vector<base::string16>* values) const {
   switch (AutofillType(type).group()) {
-    case AutofillType::NAME:
-    case AutofillType::NAME_BILLING:
+    case NAME:
+    case NAME_BILLING:
       CopyItemsToValues(type, name_, app_locale, values);
       break;
-    case AutofillType::EMAIL:
+    case EMAIL:
       CopyItemsToValues(type, email_, app_locale, values);
       break;
-    case AutofillType::PHONE_HOME:
-    case AutofillType::PHONE_BILLING:
+    case PHONE_HOME:
+    case PHONE_BILLING:
       CopyItemsToValues(type, phone_number_, app_locale, values);
       break;
     default:
       values->resize(1);
       (*values)[0] = GetFormGroupInfo(*this, type, app_locale);
   }
 }
 
 void AutofillProfile::AddPhoneIfUnique(
     const base::string16& phone,
@@ skipping 123 matching lines @@
 }
 
 const FormGroup* AutofillProfile::FormGroupForType(
     AutofillFieldType type) const {
   return const_cast<AutofillProfile*>(this)->MutableFormGroupForType(type);
 }
 
 FormGroup* AutofillProfile::MutableFormGroupForType(AutofillFieldType type) {
   FormGroup* form_group = NULL;
   switch (AutofillType(type).group()) {
-    case AutofillType::NAME:
-    case AutofillType::NAME_BILLING:
+    case NAME:
+    case NAME_BILLING:
       form_group = &name_[0];
       break;
-    case AutofillType::EMAIL:
+    case EMAIL:
       form_group = &email_[0];
       break;
-    case AutofillType::COMPANY:
+    case COMPANY:
       form_group = &company_;
       break;
-    case AutofillType::PHONE_HOME:
-    case AutofillType::PHONE_BILLING:
+    case PHONE_HOME:
+    case PHONE_BILLING:
       form_group = &phone_number_[0];
       break;
-    case AutofillType::ADDRESS_HOME:
-    case AutofillType::ADDRESS_BILLING:
+    case ADDRESS_HOME:
+    case ADDRESS_BILLING:
       form_group = &address_;
       break;
     default:
       break;
   }
 
   return form_group;
 }
 
 // So we can compare AutofillProfiles with EXPECT_EQ().
@@ skipping 24 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