Reduce boxing and unboxing of AutofillFieldType

chrome/browser/autofill/personal_data_manager.cc

 // Copyright (c) 2011 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/personal_data_manager.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 69 matching lines @@
   WebKit::WebRegularExpression re(WebKit::WebString(kEmailPattern),
                                   WebKit::WebTextCaseInsensitive);
   return re.match(WebKit::WebString(StringToLowerASCII(value))) != -1;
 }
 
 // Returns true if minimum requirements for import of a given |profile| have
 // been met.  An address submitted via a form must have at least these fields
 // filled.  No verification of validity of the contents is preformed.  This is
 // and existence check only.
 bool IsMinimumAddress(const AutofillProfile& profile) {
-  return !profile.GetFieldText(AutofillType(ADDRESS_HOME_LINE1)).empty() &&
-         !profile.GetFieldText(AutofillType(ADDRESS_HOME_CITY)).empty() &&
-         !profile.GetFieldText(AutofillType(ADDRESS_HOME_STATE)).empty() &&
-         !profile.GetFieldText(AutofillType(ADDRESS_HOME_ZIP)).empty();
+  return !profile.GetFieldText(ADDRESS_HOME_LINE1).empty() &&
+         !profile.GetFieldText(ADDRESS_HOME_CITY).empty() &&
+         !profile.GetFieldText(ADDRESS_HOME_STATE).empty() &&
+         !profile.GetFieldText(ADDRESS_HOME_ZIP).empty();
 }
 
 // Whether we have already logged the number of profiles this session.
 bool g_has_logged_profile_count = false;
 
 }  // namespace
 
 PersonalDataManager::~PersonalDataManager() {
   CancelPendingQuery(&pending_profiles_query_);
   CancelPendingQuery(&pending_creditcards_query_);
@@ skipping 63 matching lines @@
     const FormStructure* form = *iter;
     for (size_t i = 0; i < form->field_count(); ++i) {
       const AutofillField* field = form->field(i);
       string16 value = CollapseWhitespace(field->value, false);
 
       // If we don't know the type of the field, or the user hasn't entered any
       // information into the field, then skip it.
       if (!field->IsFieldFillable() || value.empty())
         continue;
 
-      AutofillType field_type(field->type());
-      FieldTypeGroup group(field_type.group());
+      AutofillFieldType field_type = field->type();
+      FieldTypeGroup group(AutofillType(field_type).group());
 
       if (group == AutofillType::CREDIT_CARD) {
         // If the user has a password set, we have no way of setting credit
         // card numbers.
         if (!HasPassword()) {
           if (LowerCaseEqualsASCII(field->form_control_type, "month")) {
-            DCHECK_EQ(CREDIT_CARD_EXP_MONTH, field_type.field_type());
+            DCHECK_EQ(CREDIT_CARD_EXP_MONTH, field_type);
             local_imported_credit_card->SetInfoForMonthInputType(value);
           } else {
-            local_imported_credit_card->SetInfo(
-                AutofillType(field_type.field_type()), value);
+            local_imported_credit_card->SetInfo(field_type, value);
           }
           ++importable_credit_card_fields;
         }
       } else {
         // In the case of a phone number, if the whole phone number was entered
         // into a single field, then parse it and set the sub components.
-        if (field_type.subgroup() == AutofillType::PHONE_WHOLE_NUMBER) {
+        if (AutofillType(field_type).subgroup() ==
+                AutofillType::PHONE_WHOLE_NUMBER) {
           string16 number;
           string16 city_code;
           string16 country_code;
           PhoneNumber::ParsePhoneNumber(value,
                                         &number,
                                         &city_code,
                                         &country_code);
           if (number.empty())
             continue;
 
           if (group == AutofillType::PHONE_HOME) {
-            imported_profile->SetInfo(AutofillType(PHONE_HOME_COUNTRY_CODE),
-                                      country_code);
-            imported_profile->SetInfo(AutofillType(PHONE_HOME_CITY_CODE),
-                                      city_code);
-            imported_profile->SetInfo(AutofillType(PHONE_HOME_NUMBER), number);
+            imported_profile->SetInfo(PHONE_HOME_COUNTRY_CODE, country_code);
+            imported_profile->SetInfo(PHONE_HOME_CITY_CODE, city_code);
+            imported_profile->SetInfo(PHONE_HOME_NUMBER, number);
           } else if (group == AutofillType::PHONE_FAX) {
-            imported_profile->SetInfo(AutofillType(PHONE_FAX_COUNTRY_CODE),
-                                      country_code);
-            imported_profile->SetInfo(AutofillType(PHONE_FAX_CITY_CODE),
-                                      city_code);
-            imported_profile->SetInfo(AutofillType(PHONE_FAX_NUMBER), number);
+            imported_profile->SetInfo(PHONE_FAX_COUNTRY_CODE, country_code);
+            imported_profile->SetInfo(PHONE_FAX_CITY_CODE, city_code);
+            imported_profile->SetInfo(PHONE_FAX_NUMBER, number);
           }
 
           continue;
         }
 
         // Phone and fax numbers can be split across multiple fields, so we
         // might have already stored the prefix, and now be at the suffix.
         // If so, combine them to form the full number.
         if (group == AutofillType::PHONE_HOME ||
             group == AutofillType::PHONE_FAX) {
-          AutofillType number_type(PHONE_HOME_NUMBER);
+          AutofillFieldType number_type = PHONE_HOME_NUMBER;
           if (group == AutofillType::PHONE_FAX)
-            number_type = AutofillType(PHONE_FAX_NUMBER);
+            number_type = PHONE_FAX_NUMBER;
 
           string16 stored_number = imported_profile->GetFieldText(number_type);
           if (stored_number.size() ==
                   static_cast<size_t>(PhoneNumber::kPrefixLength) &&
               value.size() == static_cast<size_t>(PhoneNumber::kSuffixLength)) {
             value = stored_number + value;
           }
         }
 
-        if (field_type.field_type() == EMAIL_ADDRESS && !IsValidEmail(value))
+        if (field_type == EMAIL_ADDRESS && !IsValidEmail(value))
           continue;
 
-        imported_profile->SetInfo(AutofillType(field_type.field_type()),
-                                   value);
+        imported_profile->SetInfo(field_type, value);
         ++importable_fields;
       }
     }
   }
 
   // If the user did not enter enough information on the page then don't bother
   // importing the data.
   if (importable_fields < kMinProfileImportSize)
     imported_profile.reset();
   if (importable_credit_card_fields < kMinCreditCardImportSize)
     local_imported_credit_card.reset();
 
   if (imported_profile.get() && !IsMinimumAddress(*imported_profile.get()))
     imported_profile.reset();
 
   if (local_imported_credit_card.get() &&
       !CreditCard::IsCreditCardNumber(local_imported_credit_card->GetFieldText(
-          AutofillType(CREDIT_CARD_NUMBER)))) {
+          CREDIT_CARD_NUMBER))) {
     local_imported_credit_card.reset();
   }
 
   // Don't import if we already have this info.
   if (local_imported_credit_card.get()) {
     for (std::vector<CreditCard*>::const_iterator iter = credit_cards_.begin();
          iter != credit_cards_.end();
          ++iter) {
       if (local_imported_credit_card->IsSubsetOf(**iter)) {
         local_imported_credit_card.reset();
@@ skipping 534 matching lines @@
 }
 
 const AutofillMetrics* PersonalDataManager::metric_logger() const {
   return metric_logger_.get();
 }
 
 void PersonalDataManager::set_metric_logger(
     const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }