Move guid generation from chrome/common/ to base/.

chrome/browser/webdata/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 "chrome/browser/webdata/autofill_table.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/tuple.h"
 #include "chrome/browser/autofill/autofill_country.h"
 #include "chrome/browser/autofill/autofill_profile.h"
 #include "chrome/browser/autofill/autofill_type.h"
 #include "chrome/browser/autofill/credit_card.h"
 #include "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/password_manager/encryptor.h"
 #include "chrome/browser/webdata/autofill_change.h"
 #include "chrome/browser/webdata/autofill_entry.h"
-#include "chrome/common/guid.h"
 #include "sql/statement.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/forms/form_field.h"
 
 using base::Time;
 using webkit::forms::FormField;
 
 namespace {
 
 typedef std::vector<Tuple3<int64, string16, 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) {
   if (data.size() > AutofillTable::kMaxDataLength)
     return data.substr(0, AutofillTable::kMaxDataLength);
 
   return data;
 }
 
 void BindAutofillProfileToStatement(const AutofillProfile& profile,
                                     sql::Statement* s) {
-  DCHECK(guid::IsValidGUID(profile.guid()));
+  DCHECK(base::IsValidGUID(profile.guid()));
   s->BindString(0, profile.guid());
 
   string16 text = profile.GetInfo(COMPANY_NAME);
   s->BindString16(1, LimitDataSize(text));
   text = profile.GetInfo(ADDRESS_HOME_LINE1);
   s->BindString16(2, LimitDataSize(text));
   text = profile.GetInfo(ADDRESS_HOME_LINE2);
   s->BindString16(3, LimitDataSize(text));
   text = profile.GetInfo(ADDRESS_HOME_CITY);
   s->BindString16(4, LimitDataSize(text));
   text = profile.GetInfo(ADDRESS_HOME_STATE);
   s->BindString16(5, LimitDataSize(text));
   text = profile.GetInfo(ADDRESS_HOME_ZIP);
   s->BindString16(6, LimitDataSize(text));
   text = profile.GetInfo(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()));
+  DCHECK(base::IsValidGUID(profile->guid()));
 
   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 BindCreditCardToStatement(const CreditCard& credit_card,
                                sql::Statement* s) {
-  DCHECK(guid::IsValidGUID(credit_card.guid()));
+  DCHECK(base::IsValidGUID(credit_card.guid()));
   s->BindString(0, credit_card.guid());
 
   string16 text = credit_card.GetInfo(CREDIT_CARD_NAME);
   s->BindString16(1, LimitDataSize(text));
   text = credit_card.GetInfo(CREDIT_CARD_EXP_MONTH);
   s->BindString16(2, LimitDataSize(text));
   text = credit_card.GetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR);
   s->BindString16(3, LimitDataSize(text));
   text = credit_card.GetInfo(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()));
+  DCHECK(base::IsValidGUID(credit_card->guid()));
 
   credit_card->SetInfo(CREDIT_CARD_NAME, s.ColumnString16(1));
   credit_card->SetInfo(CREDIT_CARD_EXP_MONTH, s.ColumnString16(2));
   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);
@@ skipping 746 matching lines @@
   BindAutofillProfileToStatement(profile, &s);
 
   if (!s.Run())
     return false;
 
   return AddAutofillProfilePieces(profile, db_);
 }
 
 bool AutofillTable::GetAutofillProfile(const std::string& guid,
                                        AutofillProfile** profile) {
-  DCHECK(guid::IsValidGUID(guid));
+  DCHECK(base::IsValidGUID(guid));
   DCHECK(profile);
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid, company_name, address_line_1, address_line_2, city, state,"
       " zipcode, country, country_code, date_modified "
       "FROM autofill_profiles "
       "WHERE guid=?"));
   s.BindString(0, guid);
 
   if (!s.Step())
     return false;
@@ skipping 27 matching lines @@
     AutofillProfile* profile = NULL;
     if (!GetAutofillProfile(guid, &profile))
       return false;
     profiles->push_back(profile);
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::UpdateAutofillProfile(const AutofillProfile& profile) {
-  DCHECK(guid::IsValidGUID(profile.guid()));
+  DCHECK(base::IsValidGUID(profile.guid()));
 
   // Don't update anything until the trash has been emptied.  There may be
   // pending modifications to process.
   if (!IsAutofillProfilesTrashEmpty())
     return true;
 
   AutofillProfile* tmp_profile = NULL;
   if (!GetAutofillProfile(profile.guid(), &tmp_profile))
     return false;
 
@@ skipping 14 matching lines @@
   new_profile.SetMultiInfo(EMAIL_ADDRESS, values);
 
   old_profile->GetMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values);
   values[0] = new_profile.GetInfo(PHONE_HOME_WHOLE_NUMBER);
   new_profile.SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, values);
 
   return UpdateAutofillProfileMulti(new_profile);
 }
 
 bool AutofillTable::UpdateAutofillProfileMulti(const AutofillProfile& profile) {
-  DCHECK(guid::IsValidGUID(profile.guid()));
+  DCHECK(base::IsValidGUID(profile.guid()));
 
   // Don't update anything until the trash has been emptied.  There may be
   // pending modifications to process.
   if (!IsAutofillProfilesTrashEmpty())
     return true;
 
   AutofillProfile* tmp_profile = NULL;
   if (!GetAutofillProfile(profile.guid(), &tmp_profile))
     return false;
 
@@ skipping 17 matching lines @@
     return result;
 
   // Remove the old names, emails, and phone numbers.
   if (!RemoveAutofillProfilePieces(profile.guid(), db_))
     return false;
 
   return AddAutofillProfilePieces(profile, db_);
 }
 
 bool AutofillTable::RemoveAutofillProfile(const std::string& guid) {
-  DCHECK(guid::IsValidGUID(guid));
+  DCHECK(base::IsValidGUID(guid));
 
   if (IsAutofillGUIDInTrash(guid)) {
     sql::Statement s_trash(db_->GetUniqueStatement(
         "DELETE FROM autofill_profiles_trash WHERE guid = ?"));
     s_trash.BindString(0, guid);
 
     bool success = s_trash.Run();
     DCHECK_GT(db_->GetLastChangeCount(), 0) << "Expected item in trash";
     return success;
   }
@@ skipping 43 matching lines @@
 
   if (!s.Run())
     return false;
 
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   return true;
 }
 
 bool AutofillTable::GetCreditCard(const std::string& guid,
                                   CreditCard** credit_card) {
-  DCHECK(guid::IsValidGUID(guid));
+  DCHECK(base::IsValidGUID(guid));
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified "
       "FROM credit_cards "
       "WHERE guid = ?"));
   s.BindString(0, guid);
 
   if (!s.Step())
     return false;
 
@@ skipping 15 matching lines @@
     CreditCard* credit_card = NULL;
     if (!GetCreditCard(guid, &credit_card))
       return false;
     credit_cards->push_back(credit_card);
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::UpdateCreditCard(const CreditCard& credit_card) {
-  DCHECK(guid::IsValidGUID(credit_card.guid()));
+  DCHECK(base::IsValidGUID(credit_card.guid()));
 
   CreditCard* tmp_credit_card = NULL;
   if (!GetCreditCard(credit_card.guid(), &tmp_credit_card))
     return false;
 
   // Preserve appropriate modification dates by not updating unchanged cards.
   scoped_ptr<CreditCard> old_credit_card(tmp_credit_card);
   if (*old_credit_card == credit_card)
     return true;
 
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE credit_cards "
       "SET guid=?, name_on_card=?, expiration_month=?, "
       "    expiration_year=?, card_number_encrypted=?, date_modified=? "
       "WHERE guid=?"));
   BindCreditCardToStatement(credit_card, &s);
   s.BindString(6, credit_card.guid());
 
   bool result = s.Run();
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   return result;
 }
 
 bool AutofillTable::RemoveCreditCard(const std::string& guid) {
-  DCHECK(guid::IsValidGUID(guid));
+  DCHECK(base::IsValidGUID(guid));
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM credit_cards WHERE guid = ?"));
   s.BindString(0, guid);
 
   return s.Run();
 }
 
 bool AutofillTable::RemoveAutofillProfilesAndCreditCardsModifiedBetween(
     const Time& delete_begin,
     const Time& delete_end,
@@ skipping 492 matching lines @@
 
     // Set all the |guid| fields to valid values.
 
     sql::Statement s(db_->GetUniqueStatement("SELECT unique_id "
                                              "FROM autofill_profiles"));
 
     while (s.Step()) {
       sql::Statement update_s(
           db_->GetUniqueStatement("UPDATE autofill_profiles "
                                   "SET guid=? WHERE unique_id=?"));
-      update_s.BindString(0, guid::GenerateGUID());
+      update_s.BindString(0, base::GenerateGUID());
       update_s.BindInt(1, s.ColumnInt(0));
 
       if (!update_s.Run())
         return false;
     }
     if (!s.Succeeded())
       return false;
   }
 
   // Note that we need to check for the guid column's existence due to the
   // fact that for a version 22 database the |autofill_profiles| table
   // gets created fresh with |InitAutofillProfilesTable|.
   if (!db_->DoesColumnExist("credit_cards", "guid")) {
     if (!db_->Execute("ALTER TABLE credit_cards ADD COLUMN "
                       "guid VARCHAR NOT NULL DEFAULT \"\"")) {
       return false;
     }
 
     // Set all the |guid| fields to valid values.
 
     sql::Statement s(db_->GetUniqueStatement("SELECT unique_id "
                                              "FROM credit_cards"));
 
     while (s.Step()) {
       sql::Statement update_s(
           db_->GetUniqueStatement("UPDATE credit_cards "
                                   "set guid=? WHERE unique_id=?"));
-      update_s.BindString(0, guid::GenerateGUID());
+      update_s.BindString(0, base::GenerateGUID());
       update_s.BindInt(1, s.ColumnInt(0));
 
       if (!update_s.Run())
         return false;
     }
     if (!s.Succeeded())
       return false;
   }
 
   return true;
@@ skipping 92 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, date_modified "
         "FROM autofill_profiles"));
 
     while (s.Step()) {
       AutofillProfile profile;
       profile.set_guid(s.ColumnString(0));
-      DCHECK(guid::IsValidGUID(profile.guid()));
+      DCHECK(base::IsValidGUID(profile.guid()));
 
       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, s.ColumnString16(6));
       profile.SetInfo(ADDRESS_HOME_LINE2, s.ColumnString16(7));
       profile.SetInfo(ADDRESS_HOME_CITY, s.ColumnString16(8));
       profile.SetInfo(ADDRESS_HOME_STATE, s.ColumnString16(9));
@@ skipping 182 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;
 }