[Payments] Add validation for unsupported credit card types in editor.

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 <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
@@ skipping 171 matching lines @@
 
   // Add the card (will not add a duplicate).
   request()->personal_data_manager()->AddCreditCard(credit_card);
 
   return true;
 }
 
 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.
   return base::MakeUnique<
-      CreditCardEditorViewController::CreditCardValidationDelegate>(field,
-                                                                    this);
+      CreditCardEditorViewController::CreditCardValidationDelegate>(
+      field, this,
+      field.type == autofill::CREDIT_CARD_NUMBER
+          ? request()->supported_card_networks()
+          : std::vector<std::string>());
 }
 
 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);
       return std::unique_ptr<ui::ComboboxModel>(
           new PreselectedComboboxModel(months, default_index));
     }
     case autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR:
       return std::unique_ptr<ui::ComboboxModel>(
           new ui::SimpleComboboxModel(GetExpirationYearItems()));
     default:
       NOTREACHED();
       break;
   }
   return std::unique_ptr<ui::ComboboxModel>();
 }
 
 CreditCardEditorViewController::CreditCardValidationDelegate::
-    CreditCardValidationDelegate(const EditorField& field,
-                                 EditorViewController* controller)
-    : field_(field), controller_(controller) {}
+    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()) {}
 CreditCardEditorViewController::CreditCardValidationDelegate::
     ~CreditCardValidationDelegate() {}
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     ValidateTextfield(views::Textfield* textfield) {
   return ValidateValue(textfield->text());
 }
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     ValidateCombobox(views::Combobox* combobox) {
   return ValidateValue(combobox->GetTextForRow(combobox->selected_index()));
 }
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     ValidateValue(const base::string16& value) {
   if (!value.empty()) {
     base::string16 error_message;
     bool is_valid =
-        autofill::IsValidForType(value, field_.type, &error_message);
+        field_.type == autofill::CREDIT_CARD_NUMBER
+            ? autofill::IsValidCreditCardNumberForBasicCardNetworks(
+                  value, supported_card_networks_, &error_message)
+            : autofill::IsValidForType(value, field_.type, &error_message);
     controller_->DisplayErrorMessageForField(field_, error_message);
     return is_valid;
   }
 
   bool is_required_valid = !field_.required;
   const base::string16 displayed_message =
       is_required_valid ? base::ASCIIToUTF16("")
                         : l10n_util::GetStringUTF16(
                               IDS_PAYMENTS_FIELD_REQUIRED_VALIDATION_MESSAGE);
   controller_->DisplayErrorMessageForField(field_, displayed_message);
   return is_required_valid;
 }
 
 }  // namespace payments