Prevent existing card number to be used for new credit cards in the Payment Request

chrome/browser/ui/views/payments/credit_card_editor_view_controller.cc

 // Copyright 2017 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/ui/views/payments/credit_card_editor_view_controller.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 153 matching lines @@
     PaymentRequestDialogView* dialog,
     BackNavigationType back_navigation,
     int next_ui_tag,
     base::OnceClosure on_edited,
     base::OnceCallback<void(const autofill::CreditCard&)> on_added,
     autofill::CreditCard* credit_card)
     : EditorViewController(spec, state, dialog, back_navigation),
       on_edited_(std::move(on_edited)),
       on_added_(std::move(on_added)),
       credit_card_to_edit_(credit_card),
-      add_billing_address_button_tag_(next_ui_tag) {}
+      add_billing_address_button_tag_(next_ui_tag),
+      supported_card_networks_(spec->supported_card_networks().begin(),
+                               spec->supported_card_networks().end()) {}
 
 CreditCardEditorViewController::~CreditCardEditorViewController() {}
 
 // Creates the "Cards accepted" view with a row of icons at the top of the
 // credit card editor.
 // +----------------------------------------------+
 // | Cards Accepted                               |
 // |                                              |
 // | | VISA | | MC | | AMEX |                     |
 // +----------------------------------------------+
@@ skipping 229 matching lines @@
 std::unique_ptr<ValidationDelegate>
 CreditCardEditorViewController::CreateValidationDelegate(
     const EditorField& field) {
   // The supported card networks for non-cc-number types are not passed to avoid
   // the data copy in the delegate.
   if (field.type == autofill::CREDIT_CARD_EXP_MONTH ||
       field.type == autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR)
     return base::MakeUnique<ExpirationDateValidationDelegate>(
         this, state()->GetApplicationLocale());
   return base::MakeUnique<
-      CreditCardEditorViewController::CreditCardValidationDelegate>(
-      field, this,
-      field.type == autofill::CREDIT_CARD_NUMBER
-          ? spec()->supported_card_networks()
-          : std::vector<std::string>());
+      CreditCardEditorViewController::CreditCardValidationDelegate>(field,
+                                                                    this);
 }
 
 std::unique_ptr<ui::ComboboxModel>
 CreditCardEditorViewController::GetComboboxModelForType(
     const autofill::ServerFieldType& type) {
   switch (type) {
     case autofill::CREDIT_CARD_EXP_MONTH: {
       int default_index = 0;
       std::vector<base::string16> months =
           GetExpirationMonthItems(&default_index);
@@ skipping 24 matching lines @@
   // the content view added to it yet.
   views::Combobox* combobox = static_cast<views::Combobox*>(
       content_view->GetViewByID(GetInputFieldViewId(kBillingAddressType)));
   // When the combobox has a single item, it's because it has no addresses
   // (otherwise, it would have the select header, and a separator before the
   // first address to choose from).
   DCHECK(combobox);
   combobox->SetEnabled(combobox->GetRowCount() > 1);
 }
 
+bool CreditCardEditorViewController::IsValidCreditCardNumber(
+    const base::string16& card_number,
+    base::string16* error_message) {
+  if (!autofill::IsValidCreditCardNumberForBasicCardNetworks(
+          card_number, supported_card_networks_, error_message)) {

[Mathieu, 2017/05/24 02:40:20]

can we use spec()->supported_card_networks_set() here?

[MAD, 2017/05/24 14:10:08]

Done.

+    return false;
+  }
+  // Now check if another credit card has already been created with this number.
+  // TODO(crbug.com/725604): the UI should offer to load / update the existing
+  // credit card info.
+  autofill::CreditCard* existing_card =
+      state()->GetPersonalDataManager()->GetCreditCardByNumber(
+          base::UTF16ToASCII(card_number));
+  // If a card exists, it could be the one currently edited.
+  if (!existing_card || (credit_card_to_edit_ && credit_card_to_edit_->guid() ==
+                                                     existing_card->guid())) {
+    return true;
+  }
+  if (error_message) {
+    *error_message = l10n_util::GetStringUTF16(
+        IDS_PAYMENTS_VALIDATION_ALREADY_USED_CREDIT_CARD_NUMBER);
+  }
+  return false;
+}
+
 base::string16 CreditCardEditorViewController::GetSheetTitle() {
   if (!credit_card_to_edit_)
     return l10n_util::GetStringUTF16(IDS_PAYMENTS_ADD_CARD);
 
   // Gets the completion message, or empty if nothing is missing from the card.
   base::string16 title = autofill::GetCompletionMessageForCard(
       autofill::GetCompletionStatusForCard(
           *credit_card_to_edit_, state()->GetApplicationLocale(),
           state()->GetPersonalDataManager()->GetProfiles()));
   return title.empty() ? l10n_util::GetStringUTF16(IDS_PAYMENTS_EDIT_CARD)
@@ skipping 25 matching lines @@
       static_cast<autofill::AddressComboboxModel*>(address_combobox->model());
   int index = model->AddNewProfile(profile);
   // SetSelectedIndex doesn't trigger a perform action notification, which is
   // needed to update the valid state.
   address_combobox->SetSelectedRow(index);
   // But it needs to be blured at least once.
   address_combobox->OnBlur();
 }
 
 CreditCardEditorViewController::CreditCardValidationDelegate::
-    CreditCardValidationDelegate(
-        const EditorField& field,
-        EditorViewController* controller,
-        const std::vector<std::string>& supported_card_networks)
-    : field_(field),
-      controller_(controller),
-      supported_card_networks_(supported_card_networks.begin(),
-                               supported_card_networks.end()) {}
+    CreditCardValidationDelegate(const EditorField& field,
+                                 CreditCardEditorViewController* controller)
+    : field_(field), controller_(controller) {}
 CreditCardEditorViewController::CreditCardValidationDelegate::
     ~CreditCardValidationDelegate() {}
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     IsValidTextfield(views::Textfield* textfield) {
   return ValidateValue(textfield->text(), nullptr);
 }
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     IsValidCombobox(views::Combobox* combobox) {
@@ skipping 13 matching lines @@
   base::string16 error_message;
   bool is_valid = ValidateCombobox(combobox, nullptr);
   controller_->DisplayErrorMessageForField(field_.type, error_message);
   return is_valid;
 }
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     ValidateValue(const base::string16& value, base::string16* error_message) {
   if (!value.empty()) {
     base::string16 local_error_message;
-    bool is_valid =
-        field_.type == autofill::CREDIT_CARD_NUMBER
-            ? autofill::IsValidCreditCardNumberForBasicCardNetworks(
-                  value, supported_card_networks_, &local_error_message)
-            : autofill::IsValidForType(value, field_.type,
-                                       &local_error_message);
+    bool is_valid = false;
+    if (field_.type == autofill::CREDIT_CARD_NUMBER) {
+      is_valid =
+          controller_->IsValidCreditCardNumber(value, &local_error_message);
+    } else {
+      is_valid =
+          autofill::IsValidForType(value, field_.type, &local_error_message);
+    }
     if (error_message)
       *error_message = local_error_message;
     return is_valid;
   }
 
   if (error_message && field_.required) {
     *error_message = l10n_util::GetStringUTF16(
         IDS_PAYMENTS_FIELD_REQUIRED_VALIDATION_MESSAGE);
   }
   return !field_.required;
@@ skipping 20 matching lines @@
   return ValidateValue(combobox->GetTextForRow(combobox->selected_index()),
                        error_message);
 }
 
 bool CreditCardEditorViewController::GetSheetId(DialogViewID* sheet_id) {
   *sheet_id = DialogViewID::CREDIT_CARD_EDITOR_SHEET;
   return true;
 }
 
 }  // namespace payments