Reduce boxing and unboxing of AutofillFieldType

chrome/browser/webdata/web_database_unittest.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 <list>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 87 matching lines @@
                                     AutofillProfile* profile,
                                     string16* label,
                                     int* unique_id,
                                     int64* date_modified) {
   DCHECK(profile);
   DCHECK(label);
   DCHECK(unique_id);
   DCHECK(date_modified);
   *label = s.ColumnString16(0);
   *unique_id = s.ColumnInt(1);
-  profile->SetInfo(AutofillType(NAME_FIRST), s.ColumnString16(2));
-  profile->SetInfo(AutofillType(NAME_MIDDLE), s.ColumnString16(3));
-  profile->SetInfo(AutofillType(NAME_LAST),s.ColumnString16(4));
-  profile->SetInfo(AutofillType(EMAIL_ADDRESS), s.ColumnString16(5));
-  profile->SetInfo(AutofillType(COMPANY_NAME), s.ColumnString16(6));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_LINE1), s.ColumnString16(7));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_LINE2), s.ColumnString16(8));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_CITY), s.ColumnString16(9));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_STATE), s.ColumnString16(10));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_ZIP), s.ColumnString16(11));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_COUNTRY), s.ColumnString16(12));
-  profile->SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER), s.ColumnString16(13));
-  profile->SetInfo(AutofillType(PHONE_FAX_WHOLE_NUMBER), s.ColumnString16(14));
+  profile->SetInfo(NAME_FIRST, s.ColumnString16(2));
+  profile->SetInfo(NAME_MIDDLE, s.ColumnString16(3));
+  profile->SetInfo(NAME_LAST,s.ColumnString16(4));
+  profile->SetInfo(EMAIL_ADDRESS, s.ColumnString16(5));
+  profile->SetInfo(COMPANY_NAME, s.ColumnString16(6));
+  profile->SetInfo(ADDRESS_HOME_LINE1, s.ColumnString16(7));
+  profile->SetInfo(ADDRESS_HOME_LINE2, s.ColumnString16(8));
+  profile->SetInfo(ADDRESS_HOME_CITY, s.ColumnString16(9));
+  profile->SetInfo(ADDRESS_HOME_STATE, s.ColumnString16(10));
+  profile->SetInfo(ADDRESS_HOME_ZIP, s.ColumnString16(11));
+  profile->SetInfo(ADDRESS_HOME_COUNTRY, s.ColumnString16(12));
+  profile->SetInfo(PHONE_HOME_WHOLE_NUMBER, s.ColumnString16(13));
+  profile->SetInfo(PHONE_FAX_WHOLE_NUMBER, s.ColumnString16(14));
   *date_modified = s.ColumnInt64(15);
   profile->set_guid(s.ColumnString(16));
   EXPECT_TRUE(guid::IsValidGUID(profile->guid()));
 }
 
 void AutofillProfile32FromStatement(const sql::Statement& s,
                                     AutofillProfile* profile,
                                     string16* label,
                                     int64* date_modified) {
   DCHECK(profile);
   DCHECK(label);
   DCHECK(date_modified);
   profile->set_guid(s.ColumnString(0));
   EXPECT_TRUE(guid::IsValidGUID(profile->guid()));
   *label = s.ColumnString16(1);
-  profile->SetInfo(AutofillType(NAME_FIRST), s.ColumnString16(2));
-  profile->SetInfo(AutofillType(NAME_MIDDLE), s.ColumnString16(3));
-  profile->SetInfo(AutofillType(NAME_LAST),s.ColumnString16(4));
-  profile->SetInfo(AutofillType(EMAIL_ADDRESS), s.ColumnString16(5));
-  profile->SetInfo(AutofillType(COMPANY_NAME), s.ColumnString16(6));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_LINE1), s.ColumnString16(7));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_LINE2), s.ColumnString16(8));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_CITY), s.ColumnString16(9));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_STATE), s.ColumnString16(10));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_ZIP), s.ColumnString16(11));
-  profile->SetInfo(AutofillType(ADDRESS_HOME_COUNTRY), s.ColumnString16(12));
-  profile->SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER), s.ColumnString16(13));
-  profile->SetInfo(AutofillType(PHONE_FAX_WHOLE_NUMBER), s.ColumnString16(14));
+  profile->SetInfo(NAME_FIRST, s.ColumnString16(2));
+  profile->SetInfo(NAME_MIDDLE, s.ColumnString16(3));
+  profile->SetInfo(NAME_LAST,s.ColumnString16(4));
+  profile->SetInfo(EMAIL_ADDRESS, s.ColumnString16(5));
+  profile->SetInfo(COMPANY_NAME, s.ColumnString16(6));
+  profile->SetInfo(ADDRESS_HOME_LINE1, s.ColumnString16(7));
+  profile->SetInfo(ADDRESS_HOME_LINE2, s.ColumnString16(8));
+  profile->SetInfo(ADDRESS_HOME_CITY, s.ColumnString16(9));
+  profile->SetInfo(ADDRESS_HOME_STATE, s.ColumnString16(10));
+  profile->SetInfo(ADDRESS_HOME_ZIP, s.ColumnString16(11));
+  profile->SetInfo(ADDRESS_HOME_COUNTRY, s.ColumnString16(12));
+  profile->SetInfo(PHONE_HOME_WHOLE_NUMBER, s.ColumnString16(13));
+  profile->SetInfo(PHONE_FAX_WHOLE_NUMBER, s.ColumnString16(14));
   *date_modified = s.ColumnInt64(15);
 }
 
 void AutofillProfile33FromStatement(const sql::Statement& s,
                                     AutofillProfile* profile,
                                     int64* date_modified) {
   DCHECK(profile);
   DCHECK(date_modified);
   profile->set_guid(s.ColumnString(0));
   EXPECT_TRUE(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(AutofillType(ADDRESS_HOME_COUNTRY), s.ColumnString16(7));
+  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));
+  profile->SetInfo(ADDRESS_HOME_COUNTRY, s.ColumnString16(7));
   *date_modified = s.ColumnInt64(8);
 }
 
 void CreditCard31FromStatement(const sql::Statement& s,
                               CreditCard* credit_card,
                               string16* label,
                               int* unique_id,
                               std::string* encrypted_number,
                               int64* date_modified) {
   DCHECK(credit_card);
   DCHECK(label);
   DCHECK(unique_id);
   DCHECK(encrypted_number);
   DCHECK(date_modified);
   *label = s.ColumnString16(0);
   *unique_id = s.ColumnInt(1);
-  credit_card->SetInfo(AutofillType(CREDIT_CARD_NAME), s.ColumnString16(2));
-  credit_card->SetInfo(AutofillType(CREDIT_CARD_TYPE), s.ColumnString16(3));
-  credit_card->SetInfo(AutofillType(CREDIT_CARD_EXP_MONTH),
+  credit_card->SetInfo(CREDIT_CARD_NAME, s.ColumnString16(2));
+  credit_card->SetInfo(CREDIT_CARD_TYPE, s.ColumnString16(3));
+  credit_card->SetInfo(CREDIT_CARD_EXP_MONTH,
                        s.ColumnString16(5));
-  credit_card->SetInfo(AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR),
+  credit_card->SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR,
                        s.ColumnString16(6));
   int encrypted_number_len = s.ColumnByteLength(10);
   if (encrypted_number_len) {
     encrypted_number->resize(encrypted_number_len);
     memcpy(&(*encrypted_number)[0], s.ColumnBlob(10), encrypted_number_len);
   }
   *date_modified = s.ColumnInt64(12);
   credit_card->set_guid(s.ColumnString(13));
   EXPECT_TRUE(guid::IsValidGUID(credit_card->guid()));
 }
 
 void CreditCard32FromStatement(const sql::Statement& s,
                                CreditCard* credit_card,
                                std::string* encrypted_number,
                                int64* date_modified) {
   DCHECK(credit_card);
   DCHECK(encrypted_number);
   DCHECK(date_modified);
   credit_card->set_guid(s.ColumnString(0));
   EXPECT_TRUE(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);
   if (encrypted_number_len) {
     encrypted_number->resize(encrypted_number_len);
     memcpy(&(*encrypted_number)[0], s.ColumnBlob(4), encrypted_number_len);
   }
   *date_modified = s.ColumnInt64(5);
 }
 
 }  // namespace
@@ skipping 1180 matching lines @@
   EXPECT_EQ(out_map.find(service)->second, "ham");
 }
 
 TEST_F(WebDatabaseTest, AutofillProfile) {
   WebDatabase db;
 
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   // Add a 'Home' profile.
   AutofillProfile home_profile;
-  home_profile.SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("John"));
-  home_profile.SetInfo(AutofillType(NAME_MIDDLE), ASCIIToUTF16("Q."));
-  home_profile.SetInfo(AutofillType(NAME_LAST), ASCIIToUTF16("Smith"));
-  home_profile.SetInfo(AutofillType(EMAIL_ADDRESS),
+  home_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("John"));
+  home_profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16("Q."));
+  home_profile.SetInfo(NAME_LAST, ASCIIToUTF16("Smith"));
+  home_profile.SetInfo(EMAIL_ADDRESS,
                        ASCIIToUTF16("js@smith.xyz"));
-  home_profile.SetInfo(AutofillType(COMPANY_NAME), ASCIIToUTF16("Google"));
-  home_profile.SetInfo(AutofillType(ADDRESS_HOME_LINE1),
+  home_profile.SetInfo(COMPANY_NAME, ASCIIToUTF16("Google"));
+  home_profile.SetInfo(ADDRESS_HOME_LINE1,
                        ASCIIToUTF16("1234 Apple Way"));
-  home_profile.SetInfo(AutofillType(ADDRESS_HOME_LINE2),
+  home_profile.SetInfo(ADDRESS_HOME_LINE2,
                        ASCIIToUTF16("unit 5"));
-  home_profile.SetInfo(AutofillType(ADDRESS_HOME_CITY),
+  home_profile.SetInfo(ADDRESS_HOME_CITY,
                        ASCIIToUTF16("Los Angeles"));
-  home_profile.SetInfo(AutofillType(ADDRESS_HOME_STATE), ASCIIToUTF16("CA"));
-  home_profile.SetInfo(AutofillType(ADDRESS_HOME_ZIP), ASCIIToUTF16("90025"));
-  home_profile.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("US"));
-  home_profile.SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER),
+  home_profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
+  home_profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
+  home_profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
+  home_profile.SetInfo(PHONE_HOME_WHOLE_NUMBER,
                        ASCIIToUTF16("18181234567"));
-  home_profile.SetInfo(AutofillType(PHONE_FAX_WHOLE_NUMBER),
+  home_profile.SetInfo(PHONE_FAX_WHOLE_NUMBER,
                        ASCIIToUTF16("1915243678"));
 
   Time pre_creation_time = Time::Now();
   EXPECT_TRUE(db.AddAutofillProfile(home_profile));
   Time post_creation_time = Time::Now();
 
   // Get the 'Home' profile.
   AutofillProfile* db_profile;
   ASSERT_TRUE(db.GetAutofillProfile(home_profile.guid(), &db_profile));
   EXPECT_EQ(home_profile, *db_profile);
   sql::Statement s_home(db.db_.GetUniqueStatement(
       "SELECT date_modified "
       "FROM autofill_profiles WHERE guid=?"));
   s_home.BindString(0, home_profile.guid());
   ASSERT_TRUE(s_home);
   ASSERT_TRUE(s_home.Step());
   EXPECT_GE(s_home.ColumnInt64(0), pre_creation_time.ToTimeT());
   EXPECT_LE(s_home.ColumnInt64(0), post_creation_time.ToTimeT());
   EXPECT_FALSE(s_home.Step());
   delete db_profile;
 
   // Add a 'Billing' profile.
   AutofillProfile billing_profile = home_profile;
   billing_profile.set_guid(guid::GenerateGUID());
-  billing_profile.SetInfo(AutofillType(ADDRESS_HOME_LINE1),
+  billing_profile.SetInfo(ADDRESS_HOME_LINE1,
                           ASCIIToUTF16("5678 Bottom Street"));
-  billing_profile.SetInfo(AutofillType(ADDRESS_HOME_LINE2),
+  billing_profile.SetInfo(ADDRESS_HOME_LINE2,
                           ASCIIToUTF16("suite 3"));
 
   pre_creation_time = Time::Now();
   EXPECT_TRUE(db.AddAutofillProfile(billing_profile));
   post_creation_time = Time::Now();
 
   // Get the 'Billing' profile.
   ASSERT_TRUE(db.GetAutofillProfile(billing_profile.guid(), &db_profile));
   EXPECT_EQ(billing_profile, *db_profile);
   sql::Statement s_billing(db.db_.GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
   s_billing.BindString(0, billing_profile.guid());
   ASSERT_TRUE(s_billing);
   ASSERT_TRUE(s_billing.Step());
   EXPECT_GE(s_billing.ColumnInt64(0), pre_creation_time.ToTimeT());
   EXPECT_LE(s_billing.ColumnInt64(0), post_creation_time.ToTimeT());
   EXPECT_FALSE(s_billing.Step());
   delete db_profile;
 
   // Update the 'Billing' profile, name only.
-  billing_profile.SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("Jane"));
+  billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
   Time pre_modification_time = Time::Now();
   EXPECT_TRUE(db.UpdateAutofillProfile(billing_profile));
   Time post_modification_time = Time::Now();
   ASSERT_TRUE(db.GetAutofillProfile(billing_profile.guid(), &db_profile));
   EXPECT_EQ(billing_profile, *db_profile);
   sql::Statement s_billing_updated(db.db_.GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
   s_billing_updated.BindString(0, billing_profile.guid());
   ASSERT_TRUE(s_billing_updated);
   ASSERT_TRUE(s_billing_updated.Step());
   EXPECT_GE(s_billing_updated.ColumnInt64(0),
             pre_modification_time.ToTimeT());
   EXPECT_LE(s_billing_updated.ColumnInt64(0),
             post_modification_time.ToTimeT());
   EXPECT_FALSE(s_billing_updated.Step());
   delete db_profile;
 
   // Update the 'Billing' profile.
-  billing_profile.SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("Janice"));
-  billing_profile.SetInfo(AutofillType(NAME_MIDDLE), ASCIIToUTF16("C."));
-  billing_profile.SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("Joplin"));
-  billing_profile.SetInfo(AutofillType(EMAIL_ADDRESS),
+  billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("Janice"));
+  billing_profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16("C."));
+  billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("Joplin"));
+  billing_profile.SetInfo(EMAIL_ADDRESS,
                           ASCIIToUTF16("jane@singer.com"));
-  billing_profile.SetInfo(AutofillType(COMPANY_NAME), ASCIIToUTF16("Indy"));
-  billing_profile.SetInfo(AutofillType(ADDRESS_HOME_LINE1),
+  billing_profile.SetInfo(COMPANY_NAME, ASCIIToUTF16("Indy"));
+  billing_profile.SetInfo(ADDRESS_HOME_LINE1,
                           ASCIIToUTF16("Open Road"));
-  billing_profile.SetInfo(AutofillType(ADDRESS_HOME_LINE2),
+  billing_profile.SetInfo(ADDRESS_HOME_LINE2,
                           ASCIIToUTF16("Route 66"));
-  billing_profile.SetInfo(AutofillType(ADDRESS_HOME_CITY),
+  billing_profile.SetInfo(ADDRESS_HOME_CITY,
                           ASCIIToUTF16("NFA"));
-  billing_profile.SetInfo(AutofillType(ADDRESS_HOME_STATE), ASCIIToUTF16("NY"));
-  billing_profile.SetInfo(AutofillType(ADDRESS_HOME_ZIP),
+  billing_profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("NY"));
+  billing_profile.SetInfo(ADDRESS_HOME_ZIP,
                           ASCIIToUTF16("10011"));
-  billing_profile.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY),
+  billing_profile.SetInfo(ADDRESS_HOME_COUNTRY,
                           ASCIIToUTF16("United States"));
-  billing_profile.SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER),
+  billing_profile.SetInfo(PHONE_HOME_WHOLE_NUMBER,
                           ASCIIToUTF16("18181230000"));
-  billing_profile.SetInfo(AutofillType(PHONE_FAX_WHOLE_NUMBER),
+  billing_profile.SetInfo(PHONE_FAX_WHOLE_NUMBER,
                           ASCIIToUTF16("1915240000"));
   Time pre_modification_time_2 = Time::Now();
   EXPECT_TRUE(db.UpdateAutofillProfile(billing_profile));
   Time post_modification_time_2 = Time::Now();
   ASSERT_TRUE(db.GetAutofillProfile(billing_profile.guid(), &db_profile));
   EXPECT_EQ(billing_profile, *db_profile);
   sql::Statement s_billing_updated_2(db.db_.GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
   s_billing_updated_2.BindString(0, billing_profile.guid());
   ASSERT_TRUE(s_billing_updated_2);
@@ skipping 10 matching lines @@
   EXPECT_FALSE(db.GetAutofillProfile(billing_profile.guid(), &db_profile));
 }
 
 TEST_F(WebDatabaseTest, CreditCard) {
   WebDatabase db;
 
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   // Add a 'Work' credit card.
   CreditCard work_creditcard;
-  work_creditcard.SetInfo(AutofillType(CREDIT_CARD_NAME),
+  work_creditcard.SetInfo(CREDIT_CARD_NAME,
                           ASCIIToUTF16("Jack Torrance"));
-  work_creditcard.SetInfo(AutofillType(CREDIT_CARD_NUMBER),
+  work_creditcard.SetInfo(CREDIT_CARD_NUMBER,
                           ASCIIToUTF16("1234567890123456"));
-  work_creditcard.SetInfo(AutofillType(CREDIT_CARD_EXP_MONTH),
+  work_creditcard.SetInfo(CREDIT_CARD_EXP_MONTH,
                           ASCIIToUTF16("04"));
-  work_creditcard.SetInfo(AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR),
+  work_creditcard.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR,
                           ASCIIToUTF16("2013"));
 
   Time pre_creation_time = Time::Now();
   EXPECT_TRUE(db.AddCreditCard(work_creditcard));
   Time post_creation_time = Time::Now();
 
   // Get the 'Work' credit card.
   CreditCard* db_creditcard;
   ASSERT_TRUE(db.GetCreditCard(work_creditcard.guid(), &db_creditcard));
   EXPECT_EQ(work_creditcard, *db_creditcard);
   sql::Statement s_work(db.db_.GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified "
       "FROM credit_cards WHERE guid=?"));
   s_work.BindString(0, work_creditcard.guid());
   ASSERT_TRUE(s_work);
   ASSERT_TRUE(s_work.Step());
   EXPECT_GE(s_work.ColumnInt64(5), pre_creation_time.ToTimeT());
   EXPECT_LE(s_work.ColumnInt64(5), post_creation_time.ToTimeT());
   EXPECT_FALSE(s_work.Step());
   delete db_creditcard;
 
   // Add a 'Target' credit card.
   CreditCard target_creditcard;
-  target_creditcard.SetInfo(AutofillType(CREDIT_CARD_NAME),
+  target_creditcard.SetInfo(CREDIT_CARD_NAME,
                             ASCIIToUTF16("Jack Torrance"));
-  target_creditcard.SetInfo(AutofillType(CREDIT_CARD_NUMBER),
+  target_creditcard.SetInfo(CREDIT_CARD_NUMBER,
                             ASCIIToUTF16("1111222233334444"));
-  target_creditcard.SetInfo(AutofillType(CREDIT_CARD_EXP_MONTH),
+  target_creditcard.SetInfo(CREDIT_CARD_EXP_MONTH,
                             ASCIIToUTF16("06"));
-  target_creditcard.SetInfo(AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR),
+  target_creditcard.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR,
                             ASCIIToUTF16("2012"));
 
   pre_creation_time = Time::Now();
   EXPECT_TRUE(db.AddCreditCard(target_creditcard));
   post_creation_time = Time::Now();
   ASSERT_TRUE(db.GetCreditCard(target_creditcard.guid(), &db_creditcard));
   EXPECT_EQ(target_creditcard, *db_creditcard);
   sql::Statement s_target(db.db_.GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified "
       "FROM credit_cards WHERE guid=?"));
   s_target.BindString(0, target_creditcard.guid());
   ASSERT_TRUE(s_target);
   ASSERT_TRUE(s_target.Step());
   EXPECT_GE(s_target.ColumnInt64(5), pre_creation_time.ToTimeT());
   EXPECT_LE(s_target.ColumnInt64(5), post_creation_time.ToTimeT());
   EXPECT_FALSE(s_target.Step());
   delete db_creditcard;
 
   // Update the 'Target' credit card.
-  target_creditcard.SetInfo(AutofillType(CREDIT_CARD_NAME),
+  target_creditcard.SetInfo(CREDIT_CARD_NAME,
                             ASCIIToUTF16("Charles Grady"));
   Time pre_modification_time = Time::Now();
   EXPECT_TRUE(db.UpdateCreditCard(target_creditcard));
   Time post_modification_time = Time::Now();
   ASSERT_TRUE(db.GetCreditCard(target_creditcard.guid(), &db_creditcard));
   EXPECT_EQ(target_creditcard, *db_creditcard);
   sql::Statement s_target_updated(db.db_.GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified "
       "FROM credit_cards WHERE guid=?"));
   s_target_updated.BindString(0, target_creditcard.guid());
   ASSERT_TRUE(s_target_updated);
   ASSERT_TRUE(s_target_updated.Step());
   EXPECT_GE(s_target_updated.ColumnInt64(5), pre_modification_time.ToTimeT());
   EXPECT_LE(s_target_updated.ColumnInt64(5), post_modification_time.ToTimeT());
   EXPECT_FALSE(s_target_updated.Step());
   delete db_creditcard;
 
   // Remove the 'Target' credit card.
   EXPECT_TRUE(db.RemoveCreditCard(target_creditcard.guid()));
   EXPECT_FALSE(db.GetCreditCard(target_creditcard.guid(), &db_creditcard));
 }
 
 TEST_F(WebDatabaseTest, UpdateAutofillProfile) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   // Add a profile to the db.
   AutofillProfile profile;
-  profile.SetInfo(AutofillType(NAME_FIRST), ASCIIToUTF16("John"));
-  profile.SetInfo(AutofillType(NAME_MIDDLE), ASCIIToUTF16("Q."));
-  profile.SetInfo(AutofillType(NAME_LAST), ASCIIToUTF16("Smith"));
-  profile.SetInfo(AutofillType(EMAIL_ADDRESS), ASCIIToUTF16("js@example.com"));
-  profile.SetInfo(AutofillType(COMPANY_NAME), ASCIIToUTF16("Google"));
-  profile.SetInfo(AutofillType(ADDRESS_HOME_LINE1),
+  profile.SetInfo(NAME_FIRST, ASCIIToUTF16("John"));
+  profile.SetInfo(NAME_MIDDLE, ASCIIToUTF16("Q."));
+  profile.SetInfo(NAME_LAST, ASCIIToUTF16("Smith"));
+  profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16("js@example.com"));
+  profile.SetInfo(COMPANY_NAME, ASCIIToUTF16("Google"));
+  profile.SetInfo(ADDRESS_HOME_LINE1,
                   ASCIIToUTF16("1234 Apple Way"));
-  profile.SetInfo(AutofillType(ADDRESS_HOME_LINE2), ASCIIToUTF16("unit 5"));
-  profile.SetInfo(AutofillType(ADDRESS_HOME_CITY), ASCIIToUTF16("Los Angeles"));
-  profile.SetInfo(AutofillType(ADDRESS_HOME_STATE), ASCIIToUTF16("CA"));
-  profile.SetInfo(AutofillType(ADDRESS_HOME_ZIP), ASCIIToUTF16("90025"));
-  profile.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("US"));
-  profile.SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER),
+  profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("unit 5"));
+  profile.SetInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("Los Angeles"));
+  profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
+  profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
+  profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
+  profile.SetInfo(PHONE_HOME_WHOLE_NUMBER,
                   ASCIIToUTF16("18181234567"));
-  profile.SetInfo(AutofillType(PHONE_FAX_WHOLE_NUMBER),
+  profile.SetInfo(PHONE_FAX_WHOLE_NUMBER,
                   ASCIIToUTF16("1915243678"));
   db.AddAutofillProfile(profile);
 
   // Set a mocked value for the profile's creation time.
   const time_t mock_creation_date = Time::Now().ToTimeT() - 13;
   sql::Statement s_mock_creation_date(db.db_.GetUniqueStatement(
       "UPDATE autofill_profiles SET date_modified = ?"));
   ASSERT_TRUE(s_mock_creation_date);
   s_mock_creation_date.BindInt64(0, mock_creation_date);
   ASSERT_TRUE(s_mock_creation_date.Run());
 
   // Get the profile.
   AutofillProfile* tmp_profile;
   ASSERT_TRUE(db.GetAutofillProfile(profile.guid(), &tmp_profile));
   scoped_ptr<AutofillProfile> db_profile(tmp_profile);
   EXPECT_EQ(profile, *db_profile);
   sql::Statement s_original(db.db_.GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles"));
   ASSERT_TRUE(s_original);
   ASSERT_TRUE(s_original.Step());
   EXPECT_EQ(mock_creation_date, s_original.ColumnInt64(0));
   EXPECT_FALSE(s_original.Step());
 
   // Now, update the profile and save the update to the database.
   // The modification date should change to reflect the update.
-  profile.SetInfo(AutofillType(EMAIL_ADDRESS), ASCIIToUTF16("js@smith.xyz"));
+  profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16("js@smith.xyz"));
   db.UpdateAutofillProfile(profile);
 
   // Get the profile.
   ASSERT_TRUE(db.GetAutofillProfile(profile.guid(), &tmp_profile));
   db_profile.reset(tmp_profile);
   EXPECT_EQ(profile, *db_profile);
   sql::Statement s_updated(db.db_.GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles"));
   ASSERT_TRUE(s_updated);
   ASSERT_TRUE(s_updated.Step());
@@ skipping 23 matching lines @@
   EXPECT_EQ(mock_modification_date, s_unchanged.ColumnInt64(0));
   EXPECT_FALSE(s_unchanged.Step());
 }
 
 TEST_F(WebDatabaseTest, UpdateCreditCard) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   // Add a credit card to the db.
   CreditCard credit_card;
-  credit_card.SetInfo(AutofillType(CREDIT_CARD_NAME),
+  credit_card.SetInfo(CREDIT_CARD_NAME,
                       ASCIIToUTF16("Jack Torrance"));
-  credit_card.SetInfo(AutofillType(CREDIT_CARD_NUMBER),
+  credit_card.SetInfo(CREDIT_CARD_NUMBER,
                       ASCIIToUTF16("1234567890123456"));
-  credit_card.SetInfo(AutofillType(CREDIT_CARD_EXP_MONTH),
+  credit_card.SetInfo(CREDIT_CARD_EXP_MONTH,
                       ASCIIToUTF16("04"));
-  credit_card.SetInfo(AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR),
+  credit_card.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR,
                       ASCIIToUTF16("2013"));
   db.AddCreditCard(credit_card);
 
   // Set a mocked value for the credit card's creation time.
   const time_t mock_creation_date = Time::Now().ToTimeT() - 13;
   sql::Statement s_mock_creation_date(db.db_.GetUniqueStatement(
       "UPDATE credit_cards SET date_modified = ?"));
   ASSERT_TRUE(s_mock_creation_date);
   s_mock_creation_date.BindInt64(0, mock_creation_date);
   ASSERT_TRUE(s_mock_creation_date.Run());
 
   // Get the credit card.
   CreditCard* tmp_credit_card;
   ASSERT_TRUE(db.GetCreditCard(credit_card.guid(), &tmp_credit_card));
   scoped_ptr<CreditCard> db_credit_card(tmp_credit_card);
   EXPECT_EQ(credit_card, *db_credit_card);
   sql::Statement s_original(db.db_.GetUniqueStatement(
       "SELECT date_modified FROM credit_cards"));
   ASSERT_TRUE(s_original);
   ASSERT_TRUE(s_original.Step());
   EXPECT_EQ(mock_creation_date, s_original.ColumnInt64(0));
   EXPECT_FALSE(s_original.Step());
 
   // Now, update the credit card and save the update to the database.
   // The modification date should change to reflect the update.
-  credit_card.SetInfo(AutofillType(CREDIT_CARD_EXP_MONTH), ASCIIToUTF16("01"));
+  credit_card.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01"));
   db.UpdateCreditCard(credit_card);
 
   // Get the credit card.
   ASSERT_TRUE(db.GetCreditCard(credit_card.guid(), &tmp_credit_card));
   db_credit_card.reset(tmp_credit_card);
   EXPECT_EQ(credit_card, *db_credit_card);
   sql::Statement s_updated(db.db_.GetUniqueStatement(
       "SELECT date_modified FROM credit_cards"));
   ASSERT_TRUE(s_updated);
   ASSERT_TRUE(s_updated.Step());
@@ skipping 1021 matching lines @@
             "SELECT guid, company_name, address_line_1, address_line_2, "
             "city, state, zipcode, country, date_modified "
             "FROM autofill_profiles"));
     ASSERT_TRUE(s1.Step());
 
     AutofillProfile profile_a;
     int64 profile_date_modified_a = 0;
     EXPECT_NO_FATAL_FAILURE(AutofillProfile33FromStatement(
         s1, &profile_a, &profile_date_modified_a));
     EXPECT_EQ(profile.guid(), profile_a.guid());
-    EXPECT_EQ(profile.GetFieldText(AutofillType(COMPANY_NAME)),
-              profile_a.GetFieldText(AutofillType(COMPANY_NAME)));
-    EXPECT_EQ(profile.GetFieldText(AutofillType(ADDRESS_HOME_LINE1)),
-              profile_a.GetFieldText(AutofillType(ADDRESS_HOME_LINE1)));
-    EXPECT_EQ(profile.GetFieldText(AutofillType(ADDRESS_HOME_LINE2)),
-              profile_a.GetFieldText(AutofillType(ADDRESS_HOME_LINE2)));
-    EXPECT_EQ(profile.GetFieldText(AutofillType(ADDRESS_HOME_CITY)),
-              profile_a.GetFieldText(AutofillType(ADDRESS_HOME_CITY)));
-    EXPECT_EQ(profile.GetFieldText(AutofillType(ADDRESS_HOME_STATE)),
-              profile_a.GetFieldText(AutofillType(ADDRESS_HOME_STATE)));
-    EXPECT_EQ(profile.GetFieldText(AutofillType(ADDRESS_HOME_ZIP)),
-              profile_a.GetFieldText(AutofillType(ADDRESS_HOME_ZIP)));
-    EXPECT_EQ(profile.GetFieldText(AutofillType(ADDRESS_HOME_COUNTRY)),
-              profile_a.GetFieldText(AutofillType(ADDRESS_HOME_COUNTRY)));
+    EXPECT_EQ(profile.GetFieldText(COMPANY_NAME),
+              profile_a.GetFieldText(COMPANY_NAME));
+    EXPECT_EQ(profile.GetFieldText(ADDRESS_HOME_LINE1),
+              profile_a.GetFieldText(ADDRESS_HOME_LINE1));
+    EXPECT_EQ(profile.GetFieldText(ADDRESS_HOME_LINE2),
+              profile_a.GetFieldText(ADDRESS_HOME_LINE2));
+    EXPECT_EQ(profile.GetFieldText(ADDRESS_HOME_CITY),
+              profile_a.GetFieldText(ADDRESS_HOME_CITY));
+    EXPECT_EQ(profile.GetFieldText(ADDRESS_HOME_STATE),
+              profile_a.GetFieldText(ADDRESS_HOME_STATE));
+    EXPECT_EQ(profile.GetFieldText(ADDRESS_HOME_ZIP),
+              profile_a.GetFieldText(ADDRESS_HOME_ZIP));
+    EXPECT_EQ(profile.GetFieldText(ADDRESS_HOME_COUNTRY),
+              profile_a.GetFieldText(ADDRESS_HOME_COUNTRY));
     EXPECT_EQ(profile_date_modified, profile_date_modified_a);
 
     sql::Statement s2(
         connection.GetUniqueStatement(
             "SELECT guid, name_on_card, expiration_month, "
             "expiration_year, card_number_encrypted, date_modified "
             "FROM credit_cards"));
     ASSERT_TRUE(s2.Step());
 
     CreditCard credit_card_a;
@@ skipping 409 matching lines @@
         "SELECT country_code FROM autofill_profiles"));
 
     ASSERT_TRUE(s.Step());
     std::string country_code = s.ColumnString(0);
     EXPECT_EQ("GB", country_code);
 
     // Should have only one.
     ASSERT_FALSE(s.Step());
   }
 }