[Payments] Add the "Cards accepted" row at the top of CC editor.

components/payments/payment_request.cc

 // Copyright 2016 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/payments/payment_request.h"
 
 #include "base/memory/ptr_util.h"
 #include "components/payments/payment_details_validation.h"
 #include "components/payments/payment_request_web_contents_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 
+using payments::mojom::BasicCardNetwork;
+
 namespace payments {
 
+namespace {
+
+// Identifier for the basic card payment method in the PaymentMethodData.
+const char* const kBasicCardMethodName = "basic-card";
+
+}  // namespace
+
 PaymentRequest::PaymentRequest(
     content::WebContents* web_contents,
     std::unique_ptr<PaymentRequestDelegate> delegate,
     PaymentRequestWebContentsManager* manager,
     mojo::InterfaceRequest<payments::mojom::PaymentRequest> request)
     : web_contents_(web_contents),
       delegate_(std::move(delegate)),
       manager_(manager),
       binding_(this, std::move(request)),
       selected_shipping_profile_(nullptr),
       selected_contact_profile_(nullptr) {
   // OnConnectionTerminated will be called when the Mojo pipe is closed. This
   // will happen as a result of many renderer-side events (both successful and
   // erroneous in nature).
   // TODO(crbug.com/683636): Investigate using
   // set_connection_error_with_reason_handler with Binding::CloseWithReason.
   binding_.set_connection_error_handler(base::Bind(
       &PaymentRequest::OnConnectionTerminated, base::Unretained(this)));
 
 }
 
 PaymentRequest::~PaymentRequest() {}
 
 void PaymentRequest::Init(
     payments::mojom::PaymentRequestClientPtr client,
-    std::vector<payments::mojom::PaymentMethodDataPtr> methodData,
+    std::vector<payments::mojom::PaymentMethodDataPtr> method_data,
     payments::mojom::PaymentDetailsPtr details,
     payments::mojom::PaymentOptionsPtr options) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   std::string error;
   if (!payments::validatePaymentDetails(details, &error)) {
     LOG(ERROR) << error;
     OnConnectionTerminated();
     return;
   }
   client_ = std::move(client);
   details_ = std::move(details);
+  PopulateValidatedMethodData(method_data);
   PopulateProfileCache();
   SetDefaultProfileSelections();
 }
 
 void PaymentRequest::Show() {
   if (!client_.is_bound() || !binding_.is_bound()) {
     LOG(ERROR) << "Attempted Show(), but binding(s) missing.";
     OnConnectionTerminated();
     return;
   }
@@ skipping 91 matching lines @@
 }
 
 void PaymentRequest::SetDefaultProfileSelections() {
   if (!shipping_profiles().empty())
     set_selected_shipping_profile(shipping_profiles()[0]);
 
   if (!contact_profiles().empty())
     set_selected_contact_profile(contact_profiles()[0]);
 }
 
+void PaymentRequest::PopulateValidatedMethodData(
+    const std::vector<payments::mojom::PaymentMethodDataPtr>& method_data) {
+  if (method_data.empty()) {
+    LOG(ERROR) << "Invalid payment methods or data";
+    OnConnectionTerminated();
+    return;
+  }
+
+  std::set<std::string> card_networks{"amex",     "diners",     "discover",
+                                      "jcb",      "mastercard", "mir",
+                                      "unionpay", "visa"};
+  for (const payments::mojom::PaymentMethodDataPtr& method_data_entry :
+       method_data) {
+    std::vector<std::string> supported_methods =
+        method_data_entry->supported_methods;
+    if (supported_methods.empty()) {
+      LOG(ERROR) << "Invalid payment methods or data";
+      OnConnectionTerminated();
+      return;
+    }
+
+    for (const std::string& method : supported_methods) {
+      if (method.empty())
+        continue;
+
+      // If a card network is specified right in "supportedMethods", add it.
+      auto card_it = card_networks.find(method);
+      if (card_it != card_networks.end()) {
+        supported_card_networks_.push_back(method);
+        // |method| removed from |card_networks| so that it is not doubly added
+        // to |supported_card_networks_| if "basic-card" is specified with no
+        // supported networks.
+        card_networks.erase(card_it);
+      } else if (method == kBasicCardMethodName) {
+        // For the "basic-card" method, check "supportedNetworks".
+        if (method_data_entry->supported_networks.empty()) {
+          // Empty |supported_networks| means all networks are supported.
+          supported_card_networks_.insert(supported_card_networks_.end(),
+                                          card_networks.begin(),
+                                          card_networks.end());
+          // Clear the set so that no further networks are added to
+          // |supported_card_networks_|.
+          card_networks.clear();
+        } else {
+          // The merchant has specified a few basic card supported networks. Use
+          // the mapping to transform to known basic-card types.
+          std::unordered_map<BasicCardNetwork, std::string> networks = {
+              {BasicCardNetwork::AMEX, "amex"},
+              {BasicCardNetwork::DINERS, "diners"},
+              {BasicCardNetwork::DISCOVER, "discover"},
+              {BasicCardNetwork::JCB, "jcb"},
+              {BasicCardNetwork::MASTERCARD, "mastercard"},
+              {BasicCardNetwork::MIR, "mir"},
+              {BasicCardNetwork::UNIONPAY, "unionpay"},
+              {BasicCardNetwork::VISA, "visa"}};
+          for (const BasicCardNetwork& supported_network :
+               method_data_entry->supported_networks) {
+            // Make sure that the network was not already added to
+            // |supported_card_networks_|.
+            auto card_it = card_networks.find(networks[supported_network]);
+            if (card_it != card_networks.end()) {
+              supported_card_networks_.push_back(networks[supported_network]);
+              card_networks.erase(card_it);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
 }  // namespace payments