Reduce boxing and unboxing of AutofillFieldType

chrome/browser/autofill/autofill_profile.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_profile.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/stl_util-inl.h"
@@ skipping 130 matching lines @@
     (*it)->GetPossibleFieldTypes(text, possible_types);
 }
 
 void AutofillProfile::GetAvailableFieldTypes(
     FieldTypeSet* available_types) const {
   FormGroupList info = info_list();
   for (FormGroupList::const_iterator it = info.begin(); it != info.end(); ++it)
     (*it)->GetAvailableFieldTypes(available_types);
 }
 
-string16 AutofillProfile::GetFieldText(const AutofillType& type) const {
-  AutofillType return_type(
-      AutofillType::GetEquivalentFieldType(type.field_type()));
+string16 AutofillProfile::GetFieldText(AutofillFieldType type) const {
+  AutofillFieldType return_type = AutofillType::GetEquivalentFieldType(type);
 
   FormGroupMap info = info_map();
-  FormGroupMap::const_iterator it = info.find(return_type.group());
+  FormGroupMap::const_iterator it =
+      info.find(AutofillType(return_type).group());
   if (it == info.end())
     return string16();
 
   return it->second->GetFieldText(return_type);
 }
 
 void AutofillProfile::FindInfoMatches(
-    const AutofillType& type,
+    AutofillFieldType type,
     const string16& value,
     std::vector<string16>* matched_text) const {
   if (matched_text == NULL) {
     DLOG(ERROR) << "NULL matched text passed in";
     return;
   }
 
   string16 clean_info = StringToLowerASCII(CollapseWhitespace(value, false));
 
   // If the field_type is unknown, then match against all field types.
-  if (type.field_type() == UNKNOWN_TYPE) {
+  if (type == UNKNOWN_TYPE) {
     FormGroupList info = info_list();
     for (FormGroupList::const_iterator it = info.begin();
          it != info.end(); ++it)
       (*it)->FindInfoMatches(type, clean_info, matched_text);
   } else {
     FormGroupMap info = info_map();
-    FormGroupMap::const_iterator it = info.find(type.group());
+    FormGroupMap::const_iterator it = info.find(AutofillType(type).group());
     if (it != info.end())
       it->second->FindInfoMatches(type, clean_info, matched_text);
   }
 }
 
-void AutofillProfile::SetInfo(const AutofillType& type, const string16& value) {
+void AutofillProfile::SetInfo(AutofillFieldType type, const string16& value) {
   MutableFormGroupMap info = mutable_info_map();
-  MutableFormGroupMap::iterator it = info.find(type.group());
+  MutableFormGroupMap::iterator it = info.find(AutofillType(type).group());
   if (it != info.end())
     it->second->SetInfo(type, CollapseWhitespace(value, false));
 }
 
 const string16 AutofillProfile::Label() const {
   return label_;
 }
 
 const std::string AutofillProfile::CountryCode() const {
   return address_.country_code();
@@ skipping 83 matching lines @@
                                       ADDRESS_HOME_LINE1,
                                       ADDRESS_HOME_LINE2,
                                       ADDRESS_HOME_CITY,
                                       ADDRESS_HOME_STATE,
                                       ADDRESS_HOME_ZIP,
                                       ADDRESS_HOME_COUNTRY,
                                       PHONE_HOME_NUMBER,
                                       PHONE_FAX_NUMBER };
 
   for (size_t index = 0; index < arraysize(types); ++index) {
-    int comparison = GetFieldText(AutofillType(types[index])).compare(
-        profile.GetFieldText(AutofillType(types[index])));
+    int comparison = GetFieldText(types[index]).compare(
+        profile.GetFieldText(types[index]));
     if (comparison != 0)
       return comparison;
   }
 
   return 0;
 }
 
 bool AutofillProfile::operator==(const AutofillProfile& profile) const {
   return guid_ == profile.guid_ && Compare(profile) == 0;
 }
 
 bool AutofillProfile::operator!=(const AutofillProfile& profile) const {
   return !operator==(profile);
 }
 
 const string16 AutofillProfile::PrimaryValue() const {
-  return GetFieldText(AutofillType(NAME_FULL)) +
-         GetFieldText(AutofillType(ADDRESS_HOME_LINE1)) +
-         GetFieldText(AutofillType(ADDRESS_HOME_LINE2)) +
-         GetFieldText(AutofillType(EMAIL_ADDRESS));
+  return GetFieldText(NAME_FULL) +
+         GetFieldText(ADDRESS_HOME_LINE1) +
+         GetFieldText(ADDRESS_HOME_LINE2) +
+         GetFieldText(EMAIL_ADDRESS);
 }
 
 string16 AutofillProfile::ConstructInferredLabel(
     const std::vector<AutofillFieldType>& included_fields,
     size_t num_fields_to_use) const {
   const string16 separator =
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADDRESS_SUMMARY_SEPARATOR);
 
   string16 label;
   size_t num_fields_used = 0;
   for (std::vector<AutofillFieldType>::const_iterator it =
            included_fields.begin();
        it != included_fields.end() && num_fields_used < num_fields_to_use;
        ++it) {
-    string16 field = GetFieldText(AutofillType(*it));
+    string16 field = GetFieldText(*it);
     if (field.empty())
       continue;
 
     if (!label.empty())
       label.append(separator);
 
     // Fax number has special format, to indicate that this is a fax number.
     if (*it == PHONE_FAX_WHOLE_NUMBER) {
       field = l10n_util::GetStringFUTF16(
           IDS_AUTOFILL_DIALOG_ADDRESS_SUMMARY_FAX_FORMAT, field);
@@ skipping 16 matching lines @@
   std::map<AutofillFieldType,
            std::map<string16, size_t> > field_text_frequencies_by_field;
   for (std::vector<AutofillFieldType>::const_iterator field = fields.begin();
        field != fields.end(); ++field) {
     std::map<string16, size_t>& field_text_frequencies =
         field_text_frequencies_by_field[*field];
 
     for (std::list<size_t>::const_iterator it = indices.begin();
          it != indices.end(); ++it) {
       const AutofillProfile* profile = profiles[*it];
-      string16 field_text = profile->GetFieldText(AutofillType(*field));
+      string16 field_text = profile->GetFieldText(*field);
 
       // If this label is not already in the map, add it with frequency 0.
       if (!field_text_frequencies.count(field_text))
         field_text_frequencies[field_text] = 0;
 
       // Now, increment the frequency for this label.
       ++field_text_frequencies[field_text];
     }
   }
 
   // Now comes the meat of the algorithm. For each profile, we scan the list of
   // fields to use, looking for two things:
   //  1. A (non-empty) field that differentiates the profile from all others
   //  2. At least |num_fields_to_include| non-empty fields
   // Before we've satisfied condition (2), we include all fields, even ones that
   // are identical across all the profiles. Once we've satisfied condition (2),
   // we only include fields that that have at last two distinct values.
   for (std::list<size_t>::const_iterator it = indices.begin();
        it != indices.end(); ++it) {
     const AutofillProfile* profile = profiles[*it];
 
     std::vector<AutofillFieldType> label_fields;
     bool found_differentiating_field = false;
     for (std::vector<AutofillFieldType>::const_iterator field = fields.begin();
          field != fields.end(); ++field) {
       // Skip over empty fields.
-      string16 field_text = profile->GetFieldText(AutofillType(*field));
+      string16 field_text = profile->GetFieldText(*field);
       if (field_text.empty())
         continue;
 
       std::map<string16, size_t>& field_text_frequencies =
           field_text_frequencies_by_field[*field];
       found_differentiating_field |=
           !field_text_frequencies.count(string16()) &&
           (field_text_frequencies[field_text] == 1);
 
       // Once we've found enough non-empty fields, skip over any remaining
@@ skipping 49 matching lines @@
   return m;
 }
 
 // So we can compare AutofillProfiles with EXPECT_EQ().
 std::ostream& operator<<(std::ostream& os, const AutofillProfile& profile) {
   return os
       << UTF16ToUTF8(profile.Label())
       << " "
       << profile.guid()
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(NAME_FIRST)))
+      << UTF16ToUTF8(profile.GetFieldText(NAME_FIRST))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(NAME_MIDDLE)))
+      << UTF16ToUTF8(profile.GetFieldText(NAME_MIDDLE))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(NAME_LAST)))
+      << UTF16ToUTF8(profile.GetFieldText(NAME_LAST))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(EMAIL_ADDRESS)))
+      << UTF16ToUTF8(profile.GetFieldText(EMAIL_ADDRESS))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(COMPANY_NAME)))
+      << UTF16ToUTF8(profile.GetFieldText(COMPANY_NAME))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(ADDRESS_HOME_LINE1)))
+      << UTF16ToUTF8(profile.GetFieldText(ADDRESS_HOME_LINE1))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(ADDRESS_HOME_LINE2)))
+      << UTF16ToUTF8(profile.GetFieldText(ADDRESS_HOME_LINE2))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(ADDRESS_HOME_CITY)))
+      << UTF16ToUTF8(profile.GetFieldText(ADDRESS_HOME_CITY))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(ADDRESS_HOME_STATE)))
+      << UTF16ToUTF8(profile.GetFieldText(ADDRESS_HOME_STATE))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(ADDRESS_HOME_ZIP)))
+      << UTF16ToUTF8(profile.GetFieldText(ADDRESS_HOME_ZIP))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(ADDRESS_HOME_COUNTRY)))
+      << UTF16ToUTF8(profile.GetFieldText(ADDRESS_HOME_COUNTRY))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(
-             PHONE_HOME_WHOLE_NUMBER)))
+      << UTF16ToUTF8(profile.GetFieldText(PHONE_HOME_WHOLE_NUMBER))
       << " "
-      << UTF16ToUTF8(profile.GetFieldText(AutofillType(
-             PHONE_FAX_WHOLE_NUMBER)));
+      << UTF16ToUTF8(profile.GetFieldText(PHONE_FAX_WHOLE_NUMBER));
 }