Stores server card as a full server card when upload to server succeeds.

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 1237 matching lines @@
 
     // 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++, *autofill_table_encryptor_);
     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++);
-
     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 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);
     }
 
     card->SetServerStatus(ServerStatusStringToEnum(s.ColumnString(index++)));
     card->SetRawInfo(CREDIT_CARD_NAME_FULL, s.ColumnString16(index++));
     card->SetRawInfo(CREDIT_CARD_EXP_MONTH, s.ColumnString16(index++));
     card->SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, s.ColumnString16(index++));
     card->set_billing_address_id(s.ColumnString(index++));
     credit_cards->push_back(std::move(card));
   }
-
   return s.Succeeded();
 }
 
-void AutofillTable::SetServerCreditCards(
+void AutofillTable::AddMaskedCreditCards(
     const std::vector<CreditCard>& credit_cards) {
-  sql::Transaction transaction(db_);
-  if (!transaction.Begin())
-    return;
-
-  // Delete all old values.
-  sql::Statement masked_delete(db_->GetUniqueStatement(
-      "DELETE FROM masked_credit_cards"));
-  masked_delete.Run();
-
   sql::Statement masked_insert(
       db_->GetUniqueStatement("INSERT INTO masked_credit_cards("
                               "id,"            // 0
                               "type,"          // 1
                               "status,"        // 2
                               "name_on_card,"  // 3
                               "last_four,"     // 4
                               "exp_month,"     // 5
                               "exp_year)"      // 6
                               "VALUES (?,?,?,?,?,?,?)"));
   for (const CreditCard& card : credit_cards) {
     DCHECK_EQ(CreditCard::MASKED_SERVER_CARD, card.record_type());
-
     masked_insert.BindString(0, card.server_id());
     masked_insert.BindString(1, card.type());
     masked_insert.BindString(2,
                              ServerStatusEnumToString(card.GetServerStatus()));
     masked_insert.BindString16(3, card.GetRawInfo(CREDIT_CARD_NAME_FULL));
     masked_insert.BindString16(4, card.LastFourDigits());
     masked_insert.BindString16(5, card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
     masked_insert.BindString16(6,
                                card.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 
     masked_insert.Run();
     masked_insert.Reset(true);
 
     // Save the use count and use date of the card.
     UpdateServerCardMetadata(card);
   }
+}
+
+void AutofillTable::SetServerCreditCards(
+    const std::vector<CreditCard>& credit_cards) {
+  sql::Transaction transaction(db_);
+  if (!transaction.Begin())
+    return;
+
+  // Delete all old values.
+  sql::Statement masked_delete(
+      db_->GetUniqueStatement("DELETE FROM masked_credit_cards"));
+  masked_delete.Run();
+
+  AddMaskedCreditCards(credit_cards);
 
   // Delete all items in the unmasked table that aren't in the new set.
   sql::Statement unmasked_delete(db_->GetUniqueStatement(
       "DELETE FROM unmasked_credit_cards WHERE id NOT IN "
           "(SELECT id FROM masked_credit_cards)"));
   unmasked_delete.Run();
   // Do the same for metadata.
   sql::Statement metadata_delete(db_->GetUniqueStatement(
       "DELETE FROM server_card_metadata WHERE id NOT IN "
           "(SELECT id FROM masked_credit_cards)"));
   metadata_delete.Run();
 
   transaction.Commit();
 }
 
-bool AutofillTable::UnmaskServerCreditCard(const CreditCard& masked,
-                                           const base::string16& full_number) {
+bool AutofillTable::AddServerCreditCard(const CreditCard& credit_card) {
+  DCHECK_EQ(CreditCard::FULL_SERVER_CARD, credit_card.record_type());
+  DCHECK(!credit_card.number().empty());
+  DCHECK(!credit_card.server_id().empty());
+
+  sql::Transaction transaction(db_);
+  if (!transaction.Begin())
+    return false;
+
   // Make sure there aren't duplicates for this card.
-  MaskServerCreditCard(masked.server_id());
+  DeleteFromUnmaskedCreditCards(credit_card.server_id());
+  DeleteFromMaskedCreditCards(credit_card.server_id());
+
+  CreditCard masked(credit_card);
+  masked.set_record_type(CreditCard::MASKED_SERVER_CARD);
+  masked.SetNumber(credit_card.LastFourDigits());
+  masked.RecordAndLogUse();
+  DCHECK(!masked.type().empty());
+  AddMaskedCreditCards({masked});

[Mathieu, 2017/04/24 18:11:55]

was it a practice before to have a copy of the card in both masked and unmasked
tables? It appears so, but I can't figure out why and I don't have strong
knowledge of this code.

[csashi, 2017/04/24 18:30:06]

From what I understand, yes.
If card is masked it has an entry only in masked table.
If card is unmasked it has an entry (joined by id) in both masked and unmasked
tables.

Please feel free to add other reviewers who may have more familiarity. Thanks!

[sebsg, 2017/04/24 19:18:23]

That's exacly it Sashi.

[csashi, 2017/04/24 20:09:01]

Acknowledged.

+
+  AddUnmaskedCreditCard(credit_card.server_id(), credit_card.number());
+
+  transaction.Commit();
+
+  return db_->GetLastChangeCount() > 0;
+}
+
+void AutofillTable::AddUnmaskedCreditCard(const std::string& id,
+                                          const base::string16& full_number) {
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO unmasked_credit_cards("
           "id,"
           "card_number_encrypted,"
           "unmask_date)"
       "VALUES (?,?,?)"));
-  s.BindString(0, masked.server_id());
+  s.BindString(0, id);
 
   std::string encrypted_data;
   autofill_table_encryptor_->EncryptString16(full_number, &encrypted_data);
   s.BindBlob(1, encrypted_data.data(),
              static_cast<int>(encrypted_data.length()));
   s.BindInt64(2, AutofillClock::Now().ToInternalValue());  // unmask_date
 
   s.Run();
+}
+
+bool AutofillTable::UnmaskServerCreditCard(const CreditCard& masked,
+                                           const base::string16& full_number) {
+  // Make sure there aren't duplicates for this card.
+  DeleteFromUnmaskedCreditCards(masked.server_id());
+
+  AddUnmaskedCreditCard(masked.server_id(), full_number);
 
   CreditCard unmasked = masked;
   unmasked.set_record_type(CreditCard::FULL_SERVER_CARD);
   unmasked.SetNumber(full_number);
   unmasked.RecordAndLogUse();
   UpdateServerCardMetadata(unmasked);
 
   return db_->GetLastChangeCount() > 0;
 }
 
-bool AutofillTable::MaskServerCreditCard(const std::string& id) {
+bool AutofillTable::DeleteFromMaskedCreditCards(const std::string& id) {
+  sql::Statement s(
+      db_->GetUniqueStatement("DELETE FROM masked_credit_cards WHERE id = ?"));
+  s.BindString(0, id);
+  s.Run();
+  return db_->GetLastChangeCount() > 0;
+}
+
+bool AutofillTable::DeleteFromUnmaskedCreditCards(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::MaskServerCreditCard(const std::string& id) {
+  return DeleteFromUnmaskedCreditCards(id);
+}
+
 bool AutofillTable::UpdateServerCardMetadata(const CreditCard& credit_card) {
   DCHECK_NE(CreditCard::LOCAL_CARD, credit_card.record_type());
-  sql::Transaction transaction(db_);
-  if (!transaction.Begin())
-    return false;
 
   sql::Statement remove(db_->GetUniqueStatement(
       "DELETE FROM server_card_metadata WHERE id = ?"));
   remove.BindString(0, credit_card.server_id());
   remove.Run();
 
   sql::Statement s(
       db_->GetUniqueStatement("INSERT INTO server_card_metadata(use_count, "
                               "use_date, billing_address_id, id)"
                               "VALUES (?,?,?,?)"));
   s.BindInt64(0, credit_card.use_count());
   s.BindInt64(1, credit_card.use_date().ToInternalValue());
   s.BindString(2, credit_card.billing_address_id());
   s.BindString(3, credit_card.server_id());
   s.Run();
 
-  transaction.Commit();
-
   return db_->GetLastChangeCount() > 0;
 }
 
 // TODO(crbug.com/680182): Record the address conversion status when a server
 // address gets converted.
 bool AutofillTable::UpdateServerAddressMetadata(
     const AutofillProfile& profile) {
   DCHECK_EQ(AutofillProfile::SERVER_PROFILE, profile.record_type());
 
   sql::Transaction transaction(db_);
@@ skipping 1120 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