[Payments] Return the preferred payment method name to the merchant

components/payments/content/payment_request_spec.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/content/payment_request_spec.h"
 
 #include <utility>
 
 #include "base/logging.h"
 
 namespace payments {
 
-namespace {
-// Identifier for the basic card payment method in the PaymentMethodData.
-static const char* const kBasicCardMethodName = "basic-card";
-}  // namespace
+const char kBasicCardMethodName[] = "basic-card";
 
 PaymentRequestSpec::PaymentRequestSpec(
     mojom::PaymentOptionsPtr options,
     mojom::PaymentDetailsPtr details,
     std::vector<mojom::PaymentMethodDataPtr> method_data,
     Observer* observer,
     const std::string& app_locale)
     : options_(std::move(options)),
       details_(std::move(details)),
       app_locale_(app_locale) {
   if (observer)
     AddObserver(observer);
   PopulateValidatedMethodData(method_data);
 }
 PaymentRequestSpec::~PaymentRequestSpec() {}
 
 void PaymentRequestSpec::AddObserver(Observer* observer) {
   CHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void PaymentRequestSpec::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
+bool PaymentRequestSpec::IsMethodSupportedThroughBasicCard(
+    const std::string& method_name) {
+  return basic_card_specified_networks_.count(method_name) > 0;
+}
+
 base::string16 PaymentRequestSpec::GetFormattedCurrencyAmount(
     const std::string& amount) {
   CurrencyFormatter* formatter = GetOrCreateCurrencyFormatter(
       details_->total->amount->currency,
       details_->total->amount->currency_system, app_locale_);
   return formatter->Format(amount);
 }
 
 std::string PaymentRequestSpec::GetFormattedCurrencyCode() {
   CurrencyFormatter* formatter = GetOrCreateCurrencyFormatter(
@@ skipping 35 matching lines @@
         // 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());
+          basic_card_specified_networks_.insert(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.
           using mojom::BasicCardNetwork;
           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]);
+              basic_card_specified_networks_.insert(
+                  networks[supported_network]);
               card_networks.erase(card_it);
             }
           }
         }
       }
     }
   }
 
   supported_card_networks_set_.insert(supported_card_networks_.begin(),
                                       supported_card_networks_.end());
 }
 
 void PaymentRequestSpec::NotifyOnInvalidSpecProvided() {
   for (auto& observer : observers_)
     observer.OnInvalidSpecProvided();
 }
 
 CurrencyFormatter* PaymentRequestSpec::GetOrCreateCurrencyFormatter(
     const std::string& currency_code,
     const std::string& currency_system,
     const std::string& locale_name) {
   if (!currency_formatter_) {
     currency_formatter_.reset(
         new CurrencyFormatter(currency_code, currency_system, locale_name));
   }
   return currency_formatter_.get();
 }
 
 }  // namespace payments