Convert string16 -> base::string16 in components/

components/webdata/autofill/autofill_table.cc

 // Copyright (c) 2012 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 "components/webdata/autofill/autofill_table.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 16 matching lines @@
 #include "components/webdata/autofill/autofill_entry.h"
 #include "components/webdata/common/web_database.h"
 #include "components/webdata/encryptor/encryptor.h"
 #include "sql/statement.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::Time;
 
 namespace {
 
-typedef std::vector<Tuple3<int64, string16, string16> > AutofillElementList;
+typedef std::vector<Tuple3<int64, base::string16, base::string16> >
+    AutofillElementList;
 
 // TODO(dhollowa): Find a common place for this.  It is duplicated in
 // personal_data_manager.cc.
 template<typename T>
 T* address_of(T& v) {
   return &v;
 }
 
-string16 LimitDataSize(const string16& data) {
+base::string16 LimitDataSize(const base::string16& data) {
   if (data.size() > AutofillTable::kMaxDataLength)
     return data.substr(0, AutofillTable::kMaxDataLength);
 
   return data;
 }
 
 void BindAutofillProfileToStatement(const AutofillProfile& profile,
                                     sql::Statement* s,
                                     const std::string& app_locale) {
   DCHECK(base::IsValidGUID(profile.guid()));
   s->BindString(0, profile.guid());
 
-  string16 text = profile.GetRawInfo(COMPANY_NAME);
+  base::string16 text = profile.GetRawInfo(COMPANY_NAME);
   s->BindString16(1, LimitDataSize(text));
   text = profile.GetRawInfo(ADDRESS_HOME_LINE1);
   s->BindString16(2, LimitDataSize(text));
   text = profile.GetRawInfo(ADDRESS_HOME_LINE2);
   s->BindString16(3, LimitDataSize(text));
   text = profile.GetRawInfo(ADDRESS_HOME_CITY);
   s->BindString16(4, LimitDataSize(text));
   text = profile.GetRawInfo(ADDRESS_HOME_STATE);
   s->BindString16(5, LimitDataSize(text));
   text = profile.GetRawInfo(ADDRESS_HOME_ZIP);
@@ skipping 22 matching lines @@
   // Intentionally skip column 9, which stores the profile's modification date.
 
   return profile;
 }
 
 void BindCreditCardToStatement(const CreditCard& credit_card,
                                sql::Statement* s) {
   DCHECK(base::IsValidGUID(credit_card.guid()));
   s->BindString(0, credit_card.guid());
 
-  string16 text = credit_card.GetRawInfo(CREDIT_CARD_NAME);
+  base::string16 text = credit_card.GetRawInfo(CREDIT_CARD_NAME);
   s->BindString16(1, LimitDataSize(text));
   text = credit_card.GetRawInfo(CREDIT_CARD_EXP_MONTH);
   s->BindString16(2, LimitDataSize(text));
   text = credit_card.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR);
   s->BindString16(3, LimitDataSize(text));
   text = credit_card.GetRawInfo(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(base::IsValidGUID(credit_card->guid()));
 
   credit_card->SetRawInfo(CREDIT_CARD_NAME, s.ColumnString16(1));
   credit_card->SetRawInfo(CREDIT_CARD_EXP_MONTH, s.ColumnString16(2));
   credit_card->SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, s.ColumnString16(3));
   int encrypted_number_len = s.ColumnByteLength(4);
-  string16 credit_card_number;
+  base::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->SetRawInfo(CREDIT_CARD_NUMBER, credit_card_number);
   // Intentionally skip column 5, which stores the modification date.
 
   return credit_card;
 }
 
 bool AddAutofillProfileNamesToProfile(sql::Connection* db,
                                       AutofillProfile* profile) {
   sql::Statement s(db->GetUniqueStatement(
       "SELECT guid, first_name, middle_name, last_name "
       "FROM autofill_profile_names "
       "WHERE guid=?"));
   s.BindString(0, profile->guid());
 
   if (!s.is_valid())
     return false;
 
-  std::vector<string16> first_names;
-  std::vector<string16> middle_names;
-  std::vector<string16> last_names;
+  std::vector<base::string16> first_names;
+  std::vector<base::string16> middle_names;
+  std::vector<base::string16> last_names;
   while (s.Step()) {
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     first_names.push_back(s.ColumnString16(1));
     middle_names.push_back(s.ColumnString16(2));
     last_names.push_back(s.ColumnString16(3));
   }
   if (!s.Succeeded())
     return false;
 
   profile->SetRawMultiInfo(NAME_FIRST, first_names);
   profile->SetRawMultiInfo(NAME_MIDDLE, middle_names);
   profile->SetRawMultiInfo(NAME_LAST, last_names);
   return true;
 }
 
 bool AddAutofillProfileEmailsToProfile(sql::Connection* db,
                                        AutofillProfile* profile) {
   sql::Statement s(db->GetUniqueStatement(
       "SELECT guid, email "
       "FROM autofill_profile_emails "
       "WHERE guid=?"));
   s.BindString(0, profile->guid());
 
   if (!s.is_valid())
     return false;
 
-  std::vector<string16> emails;
+  std::vector<base::string16> emails;
   while (s.Step()) {
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     emails.push_back(s.ColumnString16(1));
   }
   if (!s.Succeeded())
     return false;
 
   profile->SetRawMultiInfo(EMAIL_ADDRESS, emails);
   return true;
 }
 
 bool AddAutofillProfilePhonesToProfile(sql::Connection* db,
                                        AutofillProfile* profile) {
   sql::Statement s(db->GetUniqueStatement(
       "SELECT guid, type, number "
       "FROM autofill_profile_phones "
       "WHERE guid=? AND type=?"));
 
   // Value used to be either [(0, phone), (1, fax)] but fax has been removed.
   s.BindString(0, profile->guid());
   s.BindInt(1, 0);
 
   if (!s.is_valid())
     return false;
 
-  std::vector<string16> numbers;
+  std::vector<base::string16> numbers;
   while (s.Step()) {
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     numbers.push_back(s.ColumnString16(2));
   }
   if (!s.Succeeded())
     return false;
 
   profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, numbers);
   return true;
 }
 
 bool AddAutofillProfileNames(const AutofillProfile& profile,
                              sql::Connection* db) {
-  std::vector<string16> first_names;
+  std::vector<base::string16> first_names;
   profile.GetRawMultiInfo(NAME_FIRST, &first_names);
-  std::vector<string16> middle_names;
+  std::vector<base::string16> middle_names;
   profile.GetRawMultiInfo(NAME_MIDDLE, &middle_names);
-  std::vector<string16> last_names;
+  std::vector<base::string16> last_names;
   profile.GetRawMultiInfo(NAME_LAST, &last_names);
   DCHECK_EQ(first_names.size(), middle_names.size());
   DCHECK_EQ(middle_names.size(), last_names.size());
 
   for (size_t i = 0; i < first_names.size(); ++i) {
     // Add the new name.
     sql::Statement s(db->GetUniqueStatement(
       "INSERT INTO autofill_profile_names"
       " (guid, first_name, middle_name, last_name) "
       "VALUES (?,?,?,?)"));
     s.BindString(0, profile.guid());
     s.BindString16(1, first_names[i]);
     s.BindString16(2, middle_names[i]);
     s.BindString16(3, last_names[i]);
 
     if (!s.Run())
       return false;
   }
   return true;
 }
 
 bool AddAutofillProfileEmails(const AutofillProfile& profile,
                               sql::Connection* db) {
-  std::vector<string16> emails;
+  std::vector<base::string16> emails;
   profile.GetRawMultiInfo(EMAIL_ADDRESS, &emails);
 
   for (size_t i = 0; i < emails.size(); ++i) {
     // Add the new email.
     sql::Statement s(db->GetUniqueStatement(
       "INSERT INTO autofill_profile_emails"
       " (guid, email) "
       "VALUES (?,?)"));
     s.BindString(0, profile.guid());
     s.BindString16(1, emails[i]);
 
     if (!s.Run())
       return false;
   }
 
   return true;
 }
 
 bool AddAutofillProfilePhones(const AutofillProfile& profile,
                               sql::Connection* db) {
-  std::vector<string16> numbers;
+  std::vector<base::string16> numbers;
   profile.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &numbers);
 
   for (size_t i = 0; i < numbers.size(); ++i) {
     // Add the new number.
     sql::Statement s(db->GetUniqueStatement(
       "INSERT INTO autofill_profile_phones"
       " (guid, type, number) "
       "VALUES (?,?,?)"));
     s.BindString(0, profile.guid());
     // Value used to be either [(0, phone), (1, fax)] but fax has been removed.
@@ skipping 131 matching lines @@
     const std::vector<FormFieldData>& elements,
     std::vector<AutofillChange>* changes) {
   return AddFormFieldValuesTime(elements, changes, Time::Now());
 }
 
 bool AutofillTable::AddFormFieldValue(const FormFieldData& element,
                                       std::vector<AutofillChange>* changes) {
   return AddFormFieldValueTime(element, changes, Time::Now());
 }
 
-bool AutofillTable::GetFormValuesForElementName(const string16& name,
-                                                const string16& prefix,
-                                                std::vector<string16>* values,
-                                                int limit) {
+bool AutofillTable::GetFormValuesForElementName(
+    const base::string16& name,
+    const base::string16& prefix,
+    std::vector<base::string16>* values,
+    int limit) {
   DCHECK(values);
   sql::Statement s;
 
   if (prefix.empty()) {
     s.Assign(db_->GetUniqueStatement(
         "SELECT value FROM autofill "
         "WHERE name = ? "
         "ORDER BY count DESC "
         "LIMIT ?"));
     s.BindString16(0, name);
     s.BindInt(1, limit);
   } else {
-    string16 prefix_lower = base::i18n::ToLower(prefix);
-    string16 next_prefix = prefix_lower;
+    base::string16 prefix_lower = base::i18n::ToLower(prefix);
+    base::string16 next_prefix = prefix_lower;
     next_prefix[next_prefix.length() - 1]++;
 
     s.Assign(db_->GetUniqueStatement(
         "SELECT value FROM autofill "
         "WHERE name = ? AND "
         "value_lower >= ? AND "
         "value_lower < ? "
         "ORDER BY count DESC "
         "LIMIT ?"));
     s.BindString16(0, name);
@@ skipping 270 matching lines @@
   return s.Run();
 }
 
 bool AutofillTable::AddFormFieldValuesTime(
     const std::vector<FormFieldData>& elements,
     std::vector<AutofillChange>* changes,
     Time time) {
   // Only add one new entry for each unique element name.  Use |seen_names| to
   // track this.  Add up to |kMaximumUniqueNames| unique entries per form.
   const size_t kMaximumUniqueNames = 256;
-  std::set<string16> seen_names;
+  std::set<base::string16> seen_names;
   bool result = true;
   for (std::vector<FormFieldData>::const_iterator itr = elements.begin();
        itr != elements.end(); ++itr) {
     if (seen_names.size() >= kMaximumUniqueNames)
       break;
     if (seen_names.find(itr->name) != seen_names.end())
       continue;
     result = result && AddFormFieldValueTime(*itr, changes, time);
     seen_names.insert(itr->name);
   }
@@ skipping 24 matching lines @@
 
 bool AutofillTable::GetAllAutofillEntries(std::vector<AutofillEntry>* entries) {
   DCHECK(entries);
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT name, value, date_created FROM autofill a JOIN "
       "autofill_dates ad ON a.pair_id=ad.pair_id"));
 
   bool first_entry = true;
   AutofillKey* current_key_ptr = NULL;
   std::vector<Time>* timestamps_ptr = NULL;
-  string16 name, value;
+  base::string16 name, value;
   Time time;
   while (s.Step()) {
     name = s.ColumnString16(0);
     value = s.ColumnString16(1);
     time = Time::FromTimeT(s.ColumnInt64(2));
 
     if (first_entry) {
       current_key_ptr = new AutofillKey(name, value);
 
       timestamps_ptr = new std::vector<Time>;
@@ skipping 22 matching lines @@
   if (!first_entry) {
     AutofillEntry entry(*current_key_ptr, *timestamps_ptr);
     entries->push_back(entry);
     delete current_key_ptr;
     delete timestamps_ptr;
   }
 
   return s.Succeeded();
 }
 
-bool AutofillTable::GetAutofillTimestamps(const string16& name,
-                                          const string16& value,
+bool AutofillTable::GetAutofillTimestamps(const base::string16& name,
+                                          const base::string16& value,
                                           std::vector<Time>* timestamps) {
   DCHECK(timestamps);
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT date_created FROM autofill a JOIN "
       "autofill_dates ad ON a.pair_id=ad.pair_id "
       "WHERE a.name = ? AND a.value = ?"));
   s.BindString16(0, name);
   s.BindString16(1, value);
 
   while (s.Step())
@@ skipping 79 matching lines @@
 
   AutofillChange::Type change_type =
       count == 0 ? AutofillChange::ADD : AutofillChange::UPDATE;
   changes->push_back(
       AutofillChange(change_type,
                      AutofillKey(element.name, element.value)));
   return true;
 }
 
 
-bool AutofillTable::RemoveFormElement(const string16& name,
-                                      const string16& value) {
+bool AutofillTable::RemoveFormElement(const base::string16& name,
+                                      const base::string16& value) {
   // Find the id for that pair.
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT pair_id FROM autofill WHERE  name = ? AND value= ?"));
   s.BindString16(0, name);
   s.BindString16(1, value);
 
   if (s.Step())
     return RemoveFormElementForID(s.ColumnInt64(0));
   return false;
 }
@@ skipping 75 matching lines @@
   AutofillProfile* tmp_profile = NULL;
   if (!GetAutofillProfile(profile.guid(), &tmp_profile))
     return false;
 
   // Preserve appropriate modification dates by not updating unchanged profiles.
   scoped_ptr<AutofillProfile> old_profile(tmp_profile);
   if (old_profile->Compare(profile) == 0)
     return true;
 
   AutofillProfile new_profile(profile);
-  std::vector<string16> values;
+  std::vector<base::string16> values;
 
   old_profile->GetRawMultiInfo(NAME_FULL, &values);
   values[0] = new_profile.GetRawInfo(NAME_FULL);
   new_profile.SetRawMultiInfo(NAME_FULL, values);
 
   old_profile->GetRawMultiInfo(EMAIL_ADDRESS, &values);
   values[0] = new_profile.GetRawInfo(EMAIL_ADDRESS);
   new_profile.SetRawMultiInfo(EMAIL_ADDRESS, values);
 
   old_profile->GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values);
@@ skipping 914 matching lines @@
 
     // Set all the |country_code| fields to match existing |country| values.
     sql::Statement s(db_->GetUniqueStatement("SELECT guid, country "
                                              "FROM autofill_profiles"));
 
     while (s.Step()) {
       sql::Statement update_s(
           db_->GetUniqueStatement("UPDATE autofill_profiles "
                                   "SET country_code=? WHERE guid=?"));
 
-      string16 country = s.ColumnString16(1);
+      base::string16 country = s.ColumnString16(1);
       update_s.BindString(0, AutofillCountry::GetCountryCode(country,
                                                              app_locale_));
       update_s.BindString(1, s.ColumnString(0));
 
       if (!update_s.Run())
         return false;
     }
     if (!s.Succeeded())
       return false;
   }
@@ skipping 81 matching lines @@
         "WHERE guid=?"));
     s_date.BindInt64(0, date_item->second);
     s_date.BindString(1, iter->guid());
 
     if (!s_date.Run())
       return false;
   }
 
   return true;
 }