[Autofill] Remove direct use of base::Time::Now() in Autofill

components/autofill/core/browser/webdata/autofill_table.cc

 // Copyright 2013 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/autofill/core/browser/webdata/autofill_table.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 13 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/webdata/autofill_change.h"
 #include "components/autofill/core/browser/webdata/autofill_entry.h"
+#include "components/autofill/core/common/autofill_clock.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/autofill_util.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/os_crypt/os_crypt.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/model/metadata_batch.h"
 #include "components/sync/protocol/entity_metadata.pb.h"
 #include "components/sync/protocol/model_type_state.pb.h"
 #include "components/webdata/common/web_database.h"
 #include "sql/statement.h"
@@ skipping 430 matching lines @@
     case 71:
       *update_compatible_version = true;
       return MigrateToVersion71AddHasConvertedAndBillingAddressIdMetadata();
   }
   return true;
 }
 
 bool AutofillTable::AddFormFieldValues(
     const std::vector<FormFieldData>& elements,
     std::vector<AutofillChange>* changes) {
-  return AddFormFieldValuesTime(elements, changes, Time::Now());
+  return AddFormFieldValuesTime(elements, changes, AutofillClock::Now());
 }
 
 bool AutofillTable::AddFormFieldValue(const FormFieldData& element,
                                       std::vector<AutofillChange>* changes) {
-  return AddFormFieldValueTime(element, changes, Time::Now());
+  return AddFormFieldValueTime(element, changes, AutofillClock::Now());
 }
 
 bool AutofillTable::GetFormValuesForElementName(
     const base::string16& name,
     const base::string16& prefix,
     std::vector<base::string16>* values,
     int limit) {
   DCHECK(values);
   bool succeeded = false;
 
@@ skipping 167 matching lines @@
   if (!transaction.Commit())
     return false;
 
   *changes = tentative_changes;
   return true;
 }
 
 bool AutofillTable::RemoveExpiredFormElements(
     std::vector<AutofillChange>* changes) {
   Time expiration_time =
-      Time::Now() - TimeDelta::FromDays(kExpirationPeriodInDays);
+      AutofillClock::Now() - TimeDelta::FromDays(kExpirationPeriodInDays);
 
   // Query for the name and value of all form elements that were last used
   // before the |expiration_time|.
   sql::Statement select_for_delete(db_->GetUniqueStatement(
       "SELECT name, value FROM autofill WHERE date_last_used < ?"));
   select_for_delete.BindInt64(0, expiration_time.ToTimeT());
   std::vector<AutofillChange> tentative_changes;
   while (select_for_delete.Step()) {
     base::string16 name = select_for_delete.ColumnString16(0);
     base::string16 value = select_for_delete.ColumnString16(1);
@@ skipping 191 matching lines @@
 bool AutofillTable::AddAutofillProfile(const AutofillProfile& profile) {
   if (IsAutofillGUIDInTrash(profile.guid()))
     return true;
 
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO autofill_profiles"
       "(guid, company_name, street_address, dependent_locality, city, state,"
       " zipcode, sorting_code, country_code, use_count, use_date, "
       " date_modified, origin, language_code)"
       "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)"));
-  BindAutofillProfileToStatement(profile, Time::Now(), &s);
+  BindAutofillProfileToStatement(profile, AutofillClock::Now(), &s);
 
   if (!s.Run())
     return false;
 
   return AddAutofillProfilePieces(profile, db_);
 }
 
 std::unique_ptr<AutofillProfile> AutofillTable::GetAutofillProfile(
     const std::string& guid) {
   DCHECK(base::IsValidGUID(guid));
@@ skipping 69 matching lines @@
       "LEFT OUTER JOIN server_address_metadata USING (id)"));
 
   while (s.Step()) {
     int index = 0;
     std::unique_ptr<AutofillProfile> profile =
         base::MakeUnique<AutofillProfile>(AutofillProfile::SERVER_PROFILE,
                                           s.ColumnString(index++));
     profile->set_use_count(s.ColumnInt64(index++));
     profile->set_use_date(Time::FromInternalValue(s.ColumnInt64(index++)));
     // Modification date is not tracked for server profiles. Explicitly set it
-    // here to override the default value of Time::Now().
+    // here to override the default value of AutofillClock::Now().
     profile->set_modification_date(Time());
 
     base::string16 recipient_name = s.ColumnString16(index++);
     profile->SetRawInfo(COMPANY_NAME, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_STATE, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_CITY, s.ColumnString16(index++));
     profile->SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
                         s.ColumnString16(index++));
     index++;  // Skip address_4 which we haven't added to AutofillProfile yet.
@@ skipping 90 matching lines @@
     return false;
 
   bool update_modification_date = *old_profile != profile;
 
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE autofill_profiles "
       "SET guid=?, company_name=?, street_address=?, dependent_locality=?, "
       "    city=?, state=?, zipcode=?, sorting_code=?, country_code=?, "
       "    use_count=?, use_date=?, date_modified=?, origin=?, language_code=? "
       "WHERE guid=?"));
-  BindAutofillProfileToStatement(
-      profile,
-      update_modification_date ? Time::Now() : old_profile->modification_date(),
-      &s);
+  BindAutofillProfileToStatement(profile,
+                                 update_modification_date
+                                     ? AutofillClock::Now()
+                                     : old_profile->modification_date(),
+                                 &s);
   s.BindString(14, profile.guid());
 
   bool result = s.Run();
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   if (!result)
     return result;
 
   // Remove the old names, emails, and phone numbers.
   if (!RemoveAutofillProfilePieces(profile.guid(), db_))
     return false;
@@ skipping 49 matching lines @@
   return s4.Run();
 }
 
 bool AutofillTable::AddCreditCard(const CreditCard& credit_card) {
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO credit_cards"
       "(guid, name_on_card, expiration_month, expiration_year, "
       " card_number_encrypted, use_count, use_date, date_modified, origin,"
       " billing_address_id)"
       "VALUES (?,?,?,?,?,?,?,?,?,?)"));
-  BindCreditCardToStatement(credit_card, Time::Now(), &s);
+  BindCreditCardToStatement(credit_card, AutofillClock::Now(), &s);
 
   if (!s.Run())
     return false;
 
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   return true;
 }
 
 std::unique_ptr<CreditCard> AutofillTable::GetCreditCard(
     const std::string& guid) {
@@ skipping 67 matching lines @@
 
     std::unique_ptr<CreditCard> card =
         base::MakeUnique<CreditCard>(record_type, server_id);
     card->SetRawInfo(
         CREDIT_CARD_NUMBER,
         record_type == CreditCard::MASKED_SERVER_CARD ? last_four
                                                       : full_card_number);
     card->set_use_count(s.ColumnInt64(index++));
     card->set_use_date(Time::FromInternalValue(s.ColumnInt64(index++)));
     // Modification date is not tracked for server cards. Explicitly set it here
-    // to override the default value of Time::Now().
+    // to override the default value of AutofillClock::Now().
     card->set_modification_date(Time());
 
     std::string card_type = s.ColumnString(index++);
     if (record_type == CreditCard::MASKED_SERVER_CARD) {
       // The type must be set after setting the number to override the
       // autodetected type.
       card->SetTypeForMaskedCard(card_type.c_str());
     } else {
       DCHECK_EQ(CreditCard::GetCreditCardType(full_card_number), card_type);
     }
@@ skipping 73 matching lines @@
           "id,"
           "card_number_encrypted,"
           "unmask_date)"
       "VALUES (?,?,?)"));
   s.BindString(0, masked.server_id());
 
   std::string encrypted_data;
   OSCrypt::EncryptString16(full_number, &encrypted_data);
   s.BindBlob(1, encrypted_data.data(),
              static_cast<int>(encrypted_data.length()));
-  s.BindInt64(2, Time::Now().ToInternalValue());  // unmask_date
+  s.BindInt64(2, AutofillClock::Now().ToInternalValue());  // unmask_date
 
   s.Run();
 
   CreditCard unmasked = masked;
   unmasked.set_record_type(CreditCard::FULL_SERVER_CARD);
   unmasked.SetNumber(full_number);
   unmasked.RecordAndLogUse();
   UpdateServerCardMetadata(unmasked);
 
   return db_->GetLastChangeCount() > 0;
@@ skipping 106 matching lines @@
     return false;
 
   bool update_modification_date = *old_credit_card != credit_card;
 
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE credit_cards "
       "SET guid=?, name_on_card=?, expiration_month=?,"
           "expiration_year=?, card_number_encrypted=?, use_count=?, use_date=?,"
           "date_modified=?, origin=?, billing_address_id=?"
       "WHERE guid=?1"));
-  BindCreditCardToStatement(
-      credit_card,
-      update_modification_date ? Time::Now() :
-                                 old_credit_card->modification_date(),
-      &s);
+  BindCreditCardToStatement(credit_card,
+                            update_modification_date
+                                ? AutofillClock::Now()
+                                : old_credit_card->modification_date(),
+                            &s);
 
   bool result = s.Run();
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   return result;
 }
 
 bool AutofillTable::RemoveCreditCard(const std::string& guid) {
   DCHECK(base::IsValidGUID(guid));
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM credit_cards WHERE guid = ?"));
@@ skipping 1034 matching lines @@
   if (!db_->Execute("DROP TABLE masked_credit_cards") ||
       !db_->Execute("ALTER TABLE masked_credit_cards_temp "
                     "RENAME TO masked_credit_cards")) {
     return false;
   }
 
   return transaction.Commit();
 }
 
 }  // namespace autofill