Reduce boxing and unboxing of AutofillFieldType

chrome/browser/webdata/web_database.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/webdata/web_database.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 267 matching lines @@
     return data.substr(0, kMaxDataLength);
 
   return data;
 }
 
 void BindAutofillProfileToStatement(const AutofillProfile& profile,
                                     sql::Statement* s) {
   DCHECK(guid::IsValidGUID(profile.guid()));
   s->BindString(0, profile.guid());
 
-  string16 text = profile.GetFieldText(AutofillType(COMPANY_NAME));
+  string16 text = profile.GetFieldText(COMPANY_NAME);
   s->BindString16(1, LimitDataSize(text));
-  text = profile.GetFieldText(AutofillType(ADDRESS_HOME_LINE1));
+  text = profile.GetFieldText(ADDRESS_HOME_LINE1);
   s->BindString16(2, LimitDataSize(text));
-  text = profile.GetFieldText(AutofillType(ADDRESS_HOME_LINE2));
+  text = profile.GetFieldText(ADDRESS_HOME_LINE2);
   s->BindString16(3, LimitDataSize(text));
-  text = profile.GetFieldText(AutofillType(ADDRESS_HOME_CITY));
+  text = profile.GetFieldText(ADDRESS_HOME_CITY);
   s->BindString16(4, LimitDataSize(text));
-  text = profile.GetFieldText(AutofillType(ADDRESS_HOME_STATE));
+  text = profile.GetFieldText(ADDRESS_HOME_STATE);
   s->BindString16(5, LimitDataSize(text));
-  text = profile.GetFieldText(AutofillType(ADDRESS_HOME_ZIP));
+  text = profile.GetFieldText(ADDRESS_HOME_ZIP);
   s->BindString16(6, LimitDataSize(text));
-  text = profile.GetFieldText(AutofillType(ADDRESS_HOME_COUNTRY));
+  text = profile.GetFieldText(ADDRESS_HOME_COUNTRY);
   s->BindString16(7, LimitDataSize(text));
   std::string country_code = profile.CountryCode();
   s->BindString(8, country_code);
   s->BindInt64(9, Time::Now().ToTimeT());
 }
 
 AutofillProfile* AutofillProfileFromStatement(const sql::Statement& s) {
   AutofillProfile* profile = new AutofillProfile;
   profile->set_guid(s.ColumnString(0));
   DCHECK(guid::IsValidGUID(profile->guid()));
 
-  profile->SetInfo(AutofillType(COMPANY_NAME), s.ColumnString16(1));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_LINE1), s.ColumnString16(2));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_LINE2), s.ColumnString16(3));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_CITY), s.ColumnString16(4));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_STATE), s.ColumnString16(5));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_ZIP), s.ColumnString16(6));
+  profile->SetInfo(COMPANY_NAME, s.ColumnString16(1));
+  profile->SetInfo(ADDRESS_HOME_LINE1, s.ColumnString16(2));
+  profile->SetInfo(ADDRESS_HOME_LINE2, s.ColumnString16(3));
+  profile->SetInfo(ADDRESS_HOME_CITY, s.ColumnString16(4));
+  profile->SetInfo(ADDRESS_HOME_STATE, s.ColumnString16(5));
+  profile->SetInfo(ADDRESS_HOME_ZIP, s.ColumnString16(6));
   // Intentionally skip column 7, which stores the localized country name.
   profile->SetCountryCode(s.ColumnString(8));
   // Intentionally skip column 9, which stores the profile's modification date.
 
   return profile;
 }
 
 void AddAutofillProfileNameFromStatement(const sql::Statement& s,
                                       AutofillProfile* profile) {
   DCHECK_EQ(profile->guid(), s.ColumnString(0));
   DCHECK(guid::IsValidGUID(profile->guid()));
 
-  profile->SetInfo(AutofillType(NAME_FIRST), s.ColumnString16(1));
-  profile->SetInfo(AutofillType(NAME_MIDDLE), s.ColumnString16(2));
-  profile->SetInfo(AutofillType(NAME_LAST), s.ColumnString16(3));
+  profile->SetInfo(NAME_FIRST, s.ColumnString16(1));
+  profile->SetInfo(NAME_MIDDLE, s.ColumnString16(2));
+  profile->SetInfo(NAME_LAST, s.ColumnString16(3));
 }
 
 void AddAutofillProfileEmailFromStatement(const sql::Statement& s,
                                        AutofillProfile* profile) {
   DCHECK_EQ(profile->guid(), s.ColumnString(0));
   DCHECK(guid::IsValidGUID(profile->guid()));
 
-  profile->SetInfo(AutofillType(EMAIL_ADDRESS), s.ColumnString16(1));
+  profile->SetInfo(EMAIL_ADDRESS, s.ColumnString16(1));
 }
 
 void AddAutofillProfilePhoneFromStatement(const sql::Statement& s,
                                        AutofillProfile* profile) {
   DCHECK_EQ(profile->guid(), s.ColumnString(0));
   DCHECK(guid::IsValidGUID(profile->guid()));
   DCHECK_EQ(kAutoFillPhoneNumber, s.ColumnInt(1));
-  profile->SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER), s.ColumnString16(2));
+  profile->SetInfo(PHONE_HOME_WHOLE_NUMBER, s.ColumnString16(2));
 }
 
 void AddAutofillProfileFaxFromStatement(const sql::Statement& s,
                                      AutofillProfile* profile) {
   DCHECK_EQ(profile->guid(), s.ColumnString(0));
   DCHECK(guid::IsValidGUID(profile->guid()));
   DCHECK_EQ(kAutoFillFaxNumber, s.ColumnInt(1));
-  profile->SetInfo(AutofillType(PHONE_FAX_WHOLE_NUMBER), s.ColumnString16(2));
+  profile->SetInfo(PHONE_FAX_WHOLE_NUMBER, s.ColumnString16(2));
 }
 
 void BindCreditCardToStatement(const CreditCard& credit_card,
                                sql::Statement* s) {
   DCHECK(guid::IsValidGUID(credit_card.guid()));
   s->BindString(0, credit_card.guid());
 
-  string16 text = credit_card.GetFieldText(AutofillType(CREDIT_CARD_NAME));
+  string16 text = credit_card.GetFieldText(CREDIT_CARD_NAME);
   s->BindString16(1, LimitDataSize(text));
-  text = credit_card.GetFieldText(AutofillType(CREDIT_CARD_EXP_MONTH));
+  text = credit_card.GetFieldText(CREDIT_CARD_EXP_MONTH);
   s->BindString16(2, LimitDataSize(text));
-  text = credit_card.GetFieldText(AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR));
+  text = credit_card.GetFieldText(CREDIT_CARD_EXP_4_DIGIT_YEAR);
   s->BindString16(3, LimitDataSize(text));
-  text = credit_card.GetFieldText(AutofillType(CREDIT_CARD_NUMBER));
+  text = credit_card.GetFieldText(CREDIT_CARD_NUMBER);
   std::string encrypted_data;
   Encryptor::EncryptString16(text, &encrypted_data);
   s->BindBlob(4, encrypted_data.data(),
               static_cast<int>(encrypted_data.length()));
   s->BindInt64(5, Time::Now().ToTimeT());
 }
 
 CreditCard* CreditCardFromStatement(const sql::Statement& s) {
   CreditCard* credit_card = new CreditCard;
 
   credit_card->set_guid(s.ColumnString(0));
   DCHECK(guid::IsValidGUID(credit_card->guid()));
 
-  credit_card->SetInfo(AutofillType(CREDIT_CARD_NAME), s.ColumnString16(1));
-  credit_card->SetInfo(AutofillType(CREDIT_CARD_EXP_MONTH),
+  credit_card->SetInfo(CREDIT_CARD_NAME, s.ColumnString16(1));
+  credit_card->SetInfo(CREDIT_CARD_EXP_MONTH,
                        s.ColumnString16(2));
-  credit_card->SetInfo(AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR),
+  credit_card->SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR,
                        s.ColumnString16(3));
   int encrypted_number_len = s.ColumnByteLength(4);
   string16 credit_card_number;
   if (encrypted_number_len) {
     std::string encrypted_number;
     encrypted_number.resize(encrypted_number_len);
     memcpy(&encrypted_number[0], s.ColumnBlob(4), encrypted_number_len);
     Encryptor::DecryptString16(encrypted_number, &credit_card_number);
   }
-  credit_card->SetInfo(AutofillType(CREDIT_CARD_NUMBER), credit_card_number);
+  credit_card->SetInfo(CREDIT_CARD_NUMBER, credit_card_number);
   // Intentionally skip column 5, which stores the modification date.
 
   return credit_card;
 }
 
 bool AutofillProfileHasName(const AutofillProfile& profile) {
-  return !profile.GetFieldText(AutofillType(NAME_FIRST)).empty() ||
-         !profile.GetFieldText(AutofillType(NAME_MIDDLE)).empty() ||
-         !profile.GetFieldText(AutofillType(NAME_MIDDLE)).empty();
+  return !profile.GetFieldText(NAME_FIRST).empty() ||
+         !profile.GetFieldText(NAME_MIDDLE).empty() ||
+         !profile.GetFieldText(NAME_MIDDLE).empty();
 }
 
 bool AddAutofillProfileName(const std::string& guid,
                             const AutofillProfile& profile,
                             sql::Connection* db) {
   if (!AutofillProfileHasName(profile))
     return true;
 
   // Check for duplicate.
   sql::Statement s_find(db->GetUniqueStatement(
     "SELECT guid, first_name, middle_name, last_name "
     "FROM autofill_profile_names "
     "WHERE guid=? AND first_name=? AND middle_name=? AND last_name=?"));
   if (!s_find) {
     NOTREACHED();
     return false;
   }
   s_find.BindString(0, guid);
-  s_find.BindString16(1, profile.GetFieldText(AutofillType(NAME_FIRST)));
-  s_find.BindString16(2, profile.GetFieldText(AutofillType(NAME_MIDDLE)));
-  s_find.BindString16(3, profile.GetFieldText(AutofillType(NAME_LAST)));
+  s_find.BindString16(1, profile.GetFieldText(NAME_FIRST));
+  s_find.BindString16(2, profile.GetFieldText(NAME_MIDDLE));
+  s_find.BindString16(3, profile.GetFieldText(NAME_LAST));
 
   if (!s_find.Step()) {
     // Add the new name.
     sql::Statement s(db->GetUniqueStatement(
       "INSERT INTO autofill_profile_names"
       " (guid, first_name, middle_name, last_name) "
       "VALUES (?,?,?,?)"));
     if (!s) {
       NOTREACHED();
       return false;
     }
     s.BindString(0, guid);
-    s.BindString16(1, profile.GetFieldText(AutofillType(NAME_FIRST)));
-    s.BindString16(2, profile.GetFieldText(AutofillType(NAME_MIDDLE)));
-    s.BindString16(3, profile.GetFieldText(AutofillType(NAME_LAST)));
+    s.BindString16(1, profile.GetFieldText(NAME_FIRST));
+    s.BindString16(2, profile.GetFieldText(NAME_MIDDLE));
+    s.BindString16(3, profile.GetFieldText(NAME_LAST));
 
     if (!s.Run()) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool AddAutofillProfileEmail(const std::string& guid,
                              const AutofillProfile& profile,
                              sql::Connection* db) {
-  if (profile.GetFieldText(AutofillType(EMAIL_ADDRESS)).empty())
+  if (profile.GetFieldText(EMAIL_ADDRESS).empty())
     return true;
 
   // Check for duplicate.
   sql::Statement s_find(db->GetUniqueStatement(
     "SELECT guid, email "
     "FROM autofill_profile_emails "
     "WHERE guid=? AND email=?"));
   if (!s_find) {
     NOTREACHED();
     return false;
   }
   s_find.BindString(0, guid);
-  s_find.BindString16(1, profile.GetFieldText(AutofillType(EMAIL_ADDRESS)));
+  s_find.BindString16(1, profile.GetFieldText(EMAIL_ADDRESS));
 
   if (!s_find.Step()) {
     sql::Statement s(db->GetUniqueStatement(
       "INSERT INTO autofill_profile_emails"
       " (guid, email) "
       "VALUES (?,?)"));
     if (!s) {
       NOTREACHED();
       return false;
     }
     s.BindString(0, guid);
-    s.BindString16(1, profile.GetFieldText(AutofillType(EMAIL_ADDRESS)));
+    s.BindString16(1, profile.GetFieldText(EMAIL_ADDRESS));
 
     if (!s.Run()) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool AddAutofillProfilePhone(const std::string& guid,
                              const AutofillProfile& profile,
                              AutoFillPhoneType phone_type,
                              sql::Connection* db) {
   AutofillFieldType field_type;
   if (phone_type == kAutoFillPhoneNumber) {
     field_type = PHONE_HOME_WHOLE_NUMBER;
   } else if (phone_type == kAutoFillFaxNumber) {
     field_type = PHONE_FAX_WHOLE_NUMBER;
   } else {
     NOTREACHED();
     return false;
   }
 
-  if (profile.GetFieldText(AutofillType(field_type)).empty())
+  if (profile.GetFieldText(field_type).empty())
     return true;
 
   // Check for duplicate.
   sql::Statement s_find(db->GetUniqueStatement(
     "SELECT guid, type, number "
     "FROM autofill_profile_phones "
     "WHERE guid=? AND type=? AND number=?"));
   if (!s_find) {
     NOTREACHED();
     return false;
   }
   s_find.BindString(0, guid);
   s_find.BindInt(1, phone_type);
   s_find.BindString16(
-      2, profile.GetFieldText(AutofillType(field_type)));
+      2, profile.GetFieldText(field_type));
 
   if (!s_find.Step()) {
     sql::Statement s(db->GetUniqueStatement(
       "INSERT INTO autofill_profile_phones"
       " (guid, type, number) "
       "VALUES (?,?,?)"));
     if (!s) {
       NOTREACHED();
       return sql::INIT_FAILURE;
     }
     s.BindString(0, guid);
     s.BindInt(1, phone_type);
     s.BindString16(
-        2, profile.GetFieldText(AutofillType(field_type)));
+        2, profile.GetFieldText(field_type));
 
     if (!s.Run()) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool AddAutofillProfilePieces(const std::string& guid,
@@ skipping 2344 matching lines @@
           sql::Statement s(db_.GetUniqueStatement(
               "SELECT guid, first_name, middle_name, last_name, email, "
               "company_name, address_line_1, address_line_2, city, state, "
               "zipcode, country, phone, fax, date_modified "
               "FROM autofill_profiles"));
           while (s.Step()) {
             AutofillProfile profile;
             profile.set_guid(s.ColumnString(0));
             DCHECK(guid::IsValidGUID(profile.guid()));
 
-            profile.SetInfo(AutofillType(NAME_FIRST), s.ColumnString16(1));
-            profile.SetInfo(AutofillType(NAME_MIDDLE), s.ColumnString16(2));
-            profile.SetInfo(AutofillType(NAME_LAST), s.ColumnString16(3));
-            profile.SetInfo(AutofillType(EMAIL_ADDRESS), s.ColumnString16(4));
-            profile.SetInfo(AutofillType(COMPANY_NAME), s.ColumnString16(5));
-            profile.SetInfo(AutofillType(ADDRESS_HOME_LINE1),
+            profile.SetInfo(NAME_FIRST, s.ColumnString16(1));
+            profile.SetInfo(NAME_MIDDLE, s.ColumnString16(2));
+            profile.SetInfo(NAME_LAST, s.ColumnString16(3));
+            profile.SetInfo(EMAIL_ADDRESS, s.ColumnString16(4));
+            profile.SetInfo(COMPANY_NAME, s.ColumnString16(5));
+            profile.SetInfo(ADDRESS_HOME_LINE1,

[dhollowa, 2011/03/16 17:07:11]

nit: A number of these should fit on single line now.

[Ilya Sherman, 2011/03/17 03:42:29]

Done.

                             s.ColumnString16(6));
-            profile.SetInfo(AutofillType(ADDRESS_HOME_LINE2),
+            profile.SetInfo(ADDRESS_HOME_LINE2,
                             s.ColumnString16(7));
-            profile.SetInfo(AutofillType(ADDRESS_HOME_CITY),
+            profile.SetInfo(ADDRESS_HOME_CITY,
                             s.ColumnString16(8));
-            profile.SetInfo(AutofillType(ADDRESS_HOME_STATE),
+            profile.SetInfo(ADDRESS_HOME_STATE,
                             s.ColumnString16(9));
-            profile.SetInfo(AutofillType(ADDRESS_HOME_ZIP),
+            profile.SetInfo(ADDRESS_HOME_ZIP,
                             s.ColumnString16(10));
-            profile.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY),
+            profile.SetInfo(ADDRESS_HOME_COUNTRY,
                             s.ColumnString16(11));
-            profile.SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER),
+            profile.SetInfo(PHONE_HOME_WHOLE_NUMBER,
                             s.ColumnString16(12));
-            profile.SetInfo(AutofillType(PHONE_FAX_WHOLE_NUMBER),
+            profile.SetInfo(PHONE_FAX_WHOLE_NUMBER,
                             s.ColumnString16(13));
             int64 date_modified = s.ColumnInt64(14);
 
             sql::Statement s_insert(db_.GetUniqueStatement(
                 "INSERT INTO autofill_profiles_temp"
                 "(guid, company_name, address_line_1, address_line_2, city,"
                 " state, zipcode, country, date_modified)"
                 "VALUES (?,?,?,?,?,?,?,?,?)"));
             if (!s) {
               LOG(WARNING) << "Unable to update web database to version 33.";
               NOTREACHED();
               return sql::INIT_FAILURE;
             }
             s_insert.BindString(0, profile.guid());
             s_insert.BindString16(
-                1, profile.GetFieldText(AutofillType(COMPANY_NAME)));
+                1, profile.GetFieldText(COMPANY_NAME));
             s_insert.BindString16(
-                2, profile.GetFieldText(AutofillType(ADDRESS_HOME_LINE1)));
+                2, profile.GetFieldText(ADDRESS_HOME_LINE1));
             s_insert.BindString16(
-                3, profile.GetFieldText(AutofillType(ADDRESS_HOME_LINE2)));
+                3, profile.GetFieldText(ADDRESS_HOME_LINE2));
             s_insert.BindString16(
-                4, profile.GetFieldText(AutofillType(ADDRESS_HOME_CITY)));
+                4, profile.GetFieldText(ADDRESS_HOME_CITY));
             s_insert.BindString16(
-                5, profile.GetFieldText(AutofillType(ADDRESS_HOME_STATE)));
+                5, profile.GetFieldText(ADDRESS_HOME_STATE));
             s_insert.BindString16(
-                6, profile.GetFieldText(AutofillType(ADDRESS_HOME_ZIP)));
+                6, profile.GetFieldText(ADDRESS_HOME_ZIP));
             s_insert.BindString16(
-                7, profile.GetFieldText(AutofillType(ADDRESS_HOME_COUNTRY)));
+                7, profile.GetFieldText(ADDRESS_HOME_COUNTRY));
             s_insert.BindInt64(8, date_modified);
 
             if (!s_insert.Run()) {
               NOTREACHED();
               return sql::INIT_FAILURE;
             }
 
             // Add the other bits: names, emails, and phone/fax.
             if (!AddAutofillProfilePieces(profile.guid(), profile, &db_)) {
               NOTREACHED();
@@ skipping 138 matching lines @@
 
     // Add successive versions here.  Each should set the version number and
     // compatible version number as appropriate, then fall through to the next
     // case.
 
     case kCurrentVersionNumber:
       // No migration needed.
       return sql::INIT_OK;
   }
 }