Add use_count and use_date to unmasked server cards as well.

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 <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 553 matching lines @@
       return MigrateToVersion56AddProfileLanguageCodeForFormatting();
     case 57:
       *update_compatible_version = true;
       return MigrateToVersion57AddFullNameField();
     case 60:
       *update_compatible_version = false;
       return MigrateToVersion60AddServerCards();
     case 61:
       *update_compatible_version = false;
       return MigrateToVersion61AddUsageStats();
+    case 62:
+      *update_compatible_version = false;
+      return MigrateToVersion62AddUsageStatsForUnmaskedCards();
   }
   return true;
 }
 
 bool AutofillTable::AddFormFieldValues(
     const std::vector<FormFieldData>& elements,
     std::vector<AutofillChange>* changes) {
   return AddFormFieldValuesTime(elements, changes, Time::Now());
 }
 
@@ skipping 640 matching lines @@
 
 bool AutofillTable::GetServerCreditCards(
     std::vector<CreditCard*>* credit_cards) {
   credit_cards->clear();
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT "
       "card_number_encrypted, "  // 0
       "last_four,"     // 1
       "masked.id,"     // 2
-      "type,"          // 3
-      "status,"        // 4
-      "name_on_card,"  // 5
-      "exp_month,"     // 6
-      "exp_year "      // 7
+      "use_count,"     // 3
+      "use_date,"      // 4
+      "type,"          // 5
+      "status,"        // 6
+      "name_on_card,"  // 7
+      "exp_month,"     // 8
+      "exp_year "      // 9
       "FROM masked_credit_cards masked "
       "LEFT OUTER JOIN unmasked_credit_cards unmasked "
       "ON masked.id = unmasked.id"));
   while (s.Step()) {
     int index = 0;
 
     // If the card_number_encrypted field is nonempty, we can assume this card
     // is a full card, otherwise it's masked.
     base::string16 full_card_number = UnencryptedCardFromColumn(s, index++);
     base::string16 last_four = s.ColumnString16(index++);
     CreditCard::RecordType record_type = full_card_number.empty() ?
         CreditCard::MASKED_SERVER_CARD :
         CreditCard::FULL_SERVER_CARD;
     std::string server_id = s.ColumnString(index++);
 
     CreditCard* card = new CreditCard(record_type, server_id);
     card->SetRawInfo(
         CREDIT_CARD_NUMBER,
         record_type == CreditCard::MASKED_SERVER_CARD ? last_four
                                                       : full_card_number);
+    int64 use_count = s.ColumnInt64(index++);
+    int64 use_date = s.ColumnInt64(index++);
     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
       // autodectected type.
       card->SetTypeForMaskedCard(card_type.c_str());
+      DCHECK_EQ(0, use_count);
+      DCHECK_EQ(0, use_date);
     } else {
       DCHECK_EQ(CreditCard::GetCreditCardType(full_card_number), card_type);
+      card->set_use_count(use_count);
+      card->set_use_date(base::Time::FromInternalValue(use_date));
     }
 
     card->SetServerStatus(ServerStatusStringToEnum(s.ColumnString(index++)));
     card->SetRawInfo(CREDIT_CARD_NAME, s.ColumnString16(index++));
     card->SetRawInfo(CREDIT_CARD_EXP_MONTH, s.ColumnString16(index++));
     card->SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, s.ColumnString16(index++));
     credit_cards->push_back(card);
   }
 
   return s.Succeeded();
@@ skipping 73 matching lines @@
       unmasked_insert.Reset(true);
     }
   }
 }
 
 bool AutofillTable::UnmaskServerCreditCard(const std::string& id,
                                            const base::string16& full_number) {
   // Make sure there aren't duplicates for this card.
   MaskServerCreditCard(id);
   sql::Statement s(db_->GetUniqueStatement(
-      "INSERT INTO unmasked_credit_cards(id, card_number_encrypted) "
-      "VALUES (?,?)"));
+      "INSERT INTO unmasked_credit_cards(id, card_number_encrypted,"
+      "            use_count, use_date) "
+      "VALUES (?,?,?,?)"));
   s.BindString(0, id);
 
   std::string encrypted_data;
   OSCrypt::EncryptString16(full_number, &encrypted_data);
   s.BindBlob(1, encrypted_data.data(),
              static_cast<int>(encrypted_data.length()));
 
+  // Unmasking counts as a usage, so set the stats accordingly.
+  s.BindInt64(2, 1);
+  s.BindInt64(3, base::Time::Now().ToInternalValue());
+
   s.Run();
   return db_->GetLastChangeCount() > 0;
 }
 
 bool AutofillTable::MaskServerCreditCard(const std::string& id) {
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM unmasked_credit_cards WHERE id = ?"));
   s.BindString(0, id);
   s.Run();
   return db_->GetLastChangeCount() > 0;
 }
 
+bool AutofillTable::UpdateUnmaskedCardUsageStats(
+    const CreditCard& credit_card) {
+  DCHECK_EQ(CreditCard::FULL_SERVER_CARD, credit_card.record_type());
+
+  sql::Statement s(db_->GetUniqueStatement(
+      "UPDATE unmasked_credit_cards "
+      "SET use_count=?, use_date=? "
+      "WHERE id=?"));
+  s.BindInt64(0, credit_card.use_count());
+  s.BindInt64(1, credit_card.use_date().ToInternalValue());
+  s.BindString(2, credit_card.server_id());
+  s.Run();
+  return db_->GetLastChangeCount() > 0;
+}
+
 bool AutofillTable::UpdateCreditCard(const CreditCard& credit_card) {
   DCHECK(base::IsValidGUID(credit_card.guid()));
 
   CreditCard* tmp_credit_card = NULL;
   if (!GetCreditCard(credit_card.guid(), &tmp_credit_card))
     return false;
 
   scoped_ptr<CreditCard> old_credit_card(tmp_credit_card);
   bool update_modification_date = *old_credit_card != credit_card;
 
@@ skipping 336 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 bool AutofillTable::InitUnmaskedCreditCardsTable() {
   if (!db_->DoesTableExist("unmasked_credit_cards")) {
     if (!db_->Execute("CREATE TABLE unmasked_credit_cards ("
                       "id VARCHAR,"
-                      "card_number_encrypted VARCHAR)")) {
+                      "card_number_encrypted VARCHAR, "
+                      "use_count INTEGER NOT NULL DEFAULT 0, "
+                      "use_date INTEGER NOT NULL DEFAULT 0)")) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool AutofillTable::InitServerAddressesTable() {
   if (!db_->DoesTableExist("server_addresses")) {
     if (!db_->Execute("CREATE TABLE server_addresses ("
@@ skipping 956 matching lines @@
   return db_->Execute("ALTER TABLE autofill_profiles "
                       "ADD COLUMN language_code VARCHAR");
 }
 
 bool AutofillTable::MigrateToVersion57AddFullNameField() {
   return db_->Execute("ALTER TABLE autofill_profile_names "
                       "ADD COLUMN full_name VARCHAR");
 }
 
 bool AutofillTable::MigrateToVersion60AddServerCards() {
-  return InitMaskedCreditCardsTable() &&
-         InitUnmaskedCreditCardsTable() &&
-         InitServerAddressesTable();
+  sql::Transaction transaction(db_);
+  if (!transaction.Begin())
+    return false;
+
+  if (!db_->DoesTableExist("masked_credit_cards") &&
+      !db_->Execute("CREATE TABLE masked_credit_cards ("
+                    "id VARCHAR,"
+                    "status VARCHAR,"
+                    "name_on_card VARCHAR,"
+                    "type VARCHAR,"
+                    "last_four VARCHAR,"
+                    "exp_month INTEGER DEFAULT 0,"
+                    "exp_year INTEGER DEFAULT 0)")) {
+    return false;
+  }
+
+  if (!db_->DoesTableExist("unmasked_credit_cards") &&
+      !db_->Execute("CREATE TABLE unmasked_credit_cards ("
+                    "id VARCHAR,"
+                    "card_number_encrypted VARCHAR)")) {
+    return false;
+  }
+
+  if (!db_->DoesTableExist("server_addresses") &&
+      !db_->Execute("CREATE TABLE server_addresses ("
+                    "id VARCHAR,"
+                    "company_name VARCHAR,"
+                    "street_address VARCHAR,"
+                    "address_1 VARCHAR,"
+                    "address_2 VARCHAR,"
+                    "address_3 VARCHAR,"
+                    "address_4 VARCHAR,"
+                    "postal_code VARCHAR,"
+                    "sorting_code VARCHAR,"
+                    "country_code VARCHAR,"
+                    "language_code VARCHAR)")) {
+    return false;
+  }
+
+  return transaction.Commit();
 }
 
 bool AutofillTable::MigrateToVersion61AddUsageStats() {
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return false;
 
   // Add use_count to autofill_profiles.
   if (!db_->DoesColumnExist("autofill_profiles", "use_count") &&
       !db_->Execute("ALTER TABLE autofill_profiles ADD COLUMN "
@@ skipping 18 matching lines @@
   // Add use_date to credit_cards.
   if (!db_->DoesColumnExist("credit_cards", "use_date") &&
       !db_->Execute("ALTER TABLE credit_cards ADD COLUMN "
                     "use_date INTEGER NOT NULL DEFAULT 0")) {
     return false;
   }
 
   return transaction.Commit();
 }
 
+bool AutofillTable::MigrateToVersion62AddUsageStatsForUnmaskedCards() {
+  sql::Transaction transaction(db_);
+  if (!transaction.Begin())
+    return false;
+
+  // Add use_count to unmasked_credit_cards.
+  if (!db_->DoesColumnExist("unmasked_credit_cards", "use_count") &&
+      !db_->Execute("ALTER TABLE unmasked_credit_cards ADD COLUMN "
+                    "use_count INTEGER NOT NULL DEFAULT 0")) {
+    return false;
+  }
+
+  // Add use_date to unmasked_credit_cards.
+  if (!db_->DoesColumnExist("unmasked_credit_cards", "use_date") &&
+      !db_->Execute("ALTER TABLE unmasked_credit_cards ADD COLUMN "
+                    "use_date INTEGER NOT NULL DEFAULT 0")) {
+    return false;
+  }
+
+  return transaction.Commit();
+}
+
 }  // namespace autofill