Reduce boxing and unboxing of AutofillFieldType

chrome/browser/autofill/autofill_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/autofill_manager.h"
 
 #include <limits>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 314 matching lines @@
   std::vector<int> unique_ids;
 
   RenderViewHost* host = NULL;
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (GetHost(
           personal_data_->profiles(), personal_data_->credit_cards(), &host) &&
       FindCachedFormAndField(form, field, &form_structure, &autofill_field) &&
       // Don't send suggestions for forms that aren't auto-fillable.
       form_structure->IsAutoFillable(false)) {
-    AutofillType type(autofill_field->type());
-    bool is_filling_credit_card = (type.group() == AutofillType::CREDIT_CARD);
+    AutofillFieldType type = autofill_field->type();
+    bool is_filling_credit_card =
+        (AutofillType(type).group() == AutofillType::CREDIT_CARD);
     if (is_filling_credit_card) {
       GetCreditCardSuggestions(
           form_structure, field, type, &values, &labels, &icons, &unique_ids);
     } else {
       GetProfileSuggestions(
           form_structure, field, type, &values, &labels, &icons, &unique_ids);
     }
 
     DCHECK_EQ(values.size(), labels.size());
     DCHECK_EQ(values.size(), icons.size());
@@ skipping 97 matching lines @@
                     &section_start, &section_end);
 
   FormData result = form;
 
   // If the relevant section is auto-filled, we should fill |field| but not the
   // rest of the form.
   if (SectionIsAutoFilled(form_structure, form, section_start, section_end)) {
     for (std::vector<FormField>::iterator iter = result.fields.begin();
          iter != result.fields.end(); ++iter) {
       if ((*iter) == field) {
-        AutofillType autofill_type(autofill_field->type());
+        AutofillFieldType field_type = autofill_field->type();
         if (profile) {
-          DCHECK_NE(AutofillType::CREDIT_CARD, autofill_type.group());
-          FillFormField(profile, autofill_type, &(*iter));
+          DCHECK_NE(AutofillType::CREDIT_CARD,
+                    AutofillType(field_type).group());
+          FillFormField(profile, field_type, &(*iter));
         } else {
-          DCHECK_EQ(AutofillType::CREDIT_CARD, autofill_type.group());
-          FillCreditCardFormField(credit_card, autofill_type, &(*iter));
+          DCHECK_EQ(AutofillType::CREDIT_CARD,
+                    AutofillType(field_type).group());
+          FillCreditCardFormField(credit_card, field_type, &(*iter));
         }
         break;
       }
     }
 
     host->Send(new AutoFillMsg_FormDataFilled(host->routing_id(), query_id,
                                               result));
     return;
   }
 
@@ skipping 11 matching lines @@
     // Search forward in the |form_structure| for a corresponding field.
     while (k < section_end && *form_structure->field(k) != result.fields[j]) {
       k++;
     }
 
     // If we've found a match then fill the |result| field with the found
     // field in the |form_structure|.
     if (k >= section_end)
       continue;
 
-    AutofillType autofill_type(form_structure->field(k)->type());
-    if (autofill_type.group() != AutofillType::NO_GROUP) {
+    AutofillFieldType field_type = form_structure->field(k)->type();
+    FieldTypeGroup field_group_type = AutofillType(field_type).group();
+    if (field_group_type != AutofillType::NO_GROUP) {
       if (profile) {
-        DCHECK_NE(AutofillType::CREDIT_CARD, autofill_type.group());
-        FillFormField(profile, autofill_type, &result.fields[j]);
+        DCHECK_NE(AutofillType::CREDIT_CARD, field_group_type);
+        FillFormField(profile, field_type, &result.fields[j]);
       } else {
-        DCHECK_EQ(AutofillType::CREDIT_CARD, autofill_type.group());
-        FillCreditCardFormField(credit_card, autofill_type, &result.fields[j]);
+        DCHECK_EQ(AutofillType::CREDIT_CARD, field_group_type);
+        FillCreditCardFormField(credit_card, field_type, &result.fields[j]);
       }
     }
 
     // We found a matching field in the |form_structure| so we
     // proceed to the next |result| field, and the next |form_structure|.
     ++i;
   }
   autofilled_forms_signatures_.push_front(form_structure->FormSignature());
 
   host->Send(new AutoFillMsg_FormDataFilled(
@@ skipping 208 matching lines @@
   }
 
   if (!(*autofill_field))
     return false;
 
   return true;
 }
 
 void AutofillManager::GetProfileSuggestions(FormStructure* form,
                                             const FormField& field,
-                                            AutofillType type,
+                                            AutofillFieldType type,
                                             std::vector<string16>* values,
                                             std::vector<string16>* labels,
                                             std::vector<string16>* icons,
                                             std::vector<int>* unique_ids) {
   const std::vector<AutofillProfile*>& profiles = personal_data_->profiles();
   std::vector<AutofillProfile*> matched_profiles;
   for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin();
        iter != profiles.end(); ++iter) {
     AutofillProfile* profile = *iter;
 
@@ skipping 13 matching lines @@
   for (std::vector<AutofillField*>::const_iterator iter = form->begin();
        iter != form->end(); ++iter) {
     // The field list is terminated with a NULL AutofillField, so don't try to
     // dereference it.
     if (!*iter)
       break;
     form_fields.push_back((*iter)->type());
   }
 
   AutofillProfile::CreateInferredLabels(&matched_profiles, &form_fields,
-                                        type.field_type(), 1, labels);
+                                        type, 1, labels);
 
   // No icons for profile suggestions.
   icons->resize(values->size());
 }
 
 void AutofillManager::GetCreditCardSuggestions(FormStructure* form,
                                                const FormField& field,
-                                               AutofillType type,
+                                               AutofillFieldType type,
                                                std::vector<string16>* values,
                                                std::vector<string16>* labels,
                                                std::vector<string16>* icons,
                                                std::vector<int>* unique_ids) {
   for (std::vector<CreditCard*>::const_iterator iter =
            personal_data_->credit_cards().begin();
        iter != personal_data_->credit_cards().end(); ++iter) {
     CreditCard* credit_card = *iter;
 
     // The value of the stored data for this field type in the |credit_card|.
     string16 creditcard_field_value = credit_card->GetFieldText(type);
     if (!creditcard_field_value.empty() &&
         StartsWith(creditcard_field_value, field.value, false)) {
-      if (type.field_type() == CREDIT_CARD_NUMBER)
+      if (type == CREDIT_CARD_NUMBER)
         creditcard_field_value = credit_card->ObfuscatedNumber();
 
       string16 label;
       if (credit_card->number().empty()) {
         // If there is no CC number, return name to show something.
-        label = credit_card->GetFieldText(AutofillType(CREDIT_CARD_NAME));
+        label = credit_card->GetFieldText(CREDIT_CARD_NAME);
       } else {
         label = kCreditCardPrefix;
         label.append(credit_card->LastFourDigits());
       }
 
       values->push_back(creditcard_field_value);
       labels->push_back(label);
       icons->push_back(credit_card->type());
       unique_ids->push_back(PackGUIDs(credit_card->guid(), std::string()));
     }
   }
 }
 
 void AutofillManager::FillCreditCardFormField(const CreditCard* credit_card,
-                                              AutofillType type,
+                                              AutofillFieldType type,
                                               webkit_glue::FormField* field) {
   DCHECK(credit_card);
-  DCHECK_EQ(AutofillType::CREDIT_CARD, type.group());
+  DCHECK_EQ(AutofillType::CREDIT_CARD, AutofillType(type).group());
   DCHECK(field);
 
   if (field->form_control_type == ASCIIToUTF16("select-one")) {
     autofill::FillSelectControl(*credit_card, type, field);
   } else if (field->form_control_type == ASCIIToUTF16("month")) {
     // HTML5 input="month" consists of year-month.
-    string16 year = credit_card->GetFieldText(
-        AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR));
-    string16 month = credit_card->GetFieldText(
-        AutofillType(CREDIT_CARD_EXP_MONTH));
+    string16 year = credit_card->GetFieldText(CREDIT_CARD_EXP_4_DIGIT_YEAR);
+    string16 month = credit_card->GetFieldText(CREDIT_CARD_EXP_MONTH);
     if (!year.empty() && !month.empty()) {
       // Fill the value only if |credit_card| includes both year and month
       // information.
       field->value = year + ASCIIToUTF16("-") + month;
     }
   } else {
     field->value = credit_card->GetFieldText(type);
   }
 }
 
 void AutofillManager::FillFormField(const AutofillProfile* profile,
-                                    AutofillType type,
+                                    AutofillFieldType type,
                                     webkit_glue::FormField* field) {
   DCHECK(profile);
-  DCHECK_NE(AutofillType::CREDIT_CARD, type.group());
+  DCHECK_NE(AutofillType::CREDIT_CARD, AutofillType(type).group());
   DCHECK(field);
 
-  if (type.subgroup() == AutofillType::PHONE_NUMBER) {
+  if (AutofillType(type).subgroup() == AutofillType::PHONE_NUMBER) {
     FillPhoneNumberField(profile, type, field);
   } else {
     if (field->form_control_type == ASCIIToUTF16("select-one"))
       autofill::FillSelectControl(*profile, type, field);
     else
       field->value = profile->GetFieldText(type);
   }
 }
 
 void AutofillManager::FillPhoneNumberField(const AutofillProfile* profile,
-                                           AutofillType type,
+                                           AutofillFieldType type,
                                            webkit_glue::FormField* field) {
   // If we are filling a phone number, check to see if the size field
   // matches the "prefix" or "suffix" sizes and fill accordingly.
-  string16 number = profile->GetFieldText(AutofillType(type));
+  string16 number = profile->GetFieldText(type);
   bool has_valid_suffix_and_prefix = (number.length() ==
       static_cast<size_t>(PhoneNumber::kPrefixLength +
                           PhoneNumber::kSuffixLength));
   if (has_valid_suffix_and_prefix &&
       field->max_length == PhoneNumber::kPrefixLength) {
     number = number.substr(PhoneNumber::kPrefixOffset,
                            PhoneNumber::kPrefixLength);
     field->value = number;
   } else if (has_valid_suffix_and_prefix &&
              field->max_length == PhoneNumber::kSuffixLength) {
@@ skipping 83 matching lines @@
     return std::string();
 
   std::map<int, std::string>::const_iterator iter = id_guid_map_.find(id);
   if (iter == id_guid_map_.end()) {
     NOTREACHED();
     return std::string();
   }
 
   return iter->second;
 }