[Payments] Return basic-card as the method name when possible.

components/payments/core/payment_request_data_util.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 "components/payments/core/payment_request_data_util.h"
 
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_profile.h"
@@ skipping 84 matching lines @@
   return response;
 }
 
 void ParseBasicCardSupportedNetworks(
     const std::vector<PaymentMethodData>& method_data,
     std::vector<std::string>* out_supported_networks,
     std::set<std::string>* out_basic_card_specified_networks) {
   DCHECK(out_supported_networks->empty());
   DCHECK(out_basic_card_specified_networks->empty());
 
-  std::set<std::string> card_networks{"amex",     "diners",     "discover",
-                                      "jcb",      "mastercard", "mir",
-                                      "unionpay", "visa"};
+  const std::set<std::string> kBasicCardNetworks{
+      "amex",       "diners", "discover", "jcb",
+      "mastercard", "mir",    "unionpay", "visa"};
+  std::set<std::string> remaining_card_networks(kBasicCardNetworks);
   for (const PaymentMethodData& method_data_entry : method_data) {
     if (method_data_entry.supported_methods.empty())
       return;
 
     for (const std::string& method : method_data_entry.supported_methods) {
       if (method.empty())
         continue;
 
+      const char kBasicCardMethodName[] = "basic-card";
       // If a card network is specified right in "supportedMethods", add it.
-      const char kBasicCardMethodName[] = "basic-card";
-      auto card_it = card_networks.find(method);
-      if (card_it != card_networks.end()) {
+      auto card_it = remaining_card_networks.find(method);
+      if (card_it != remaining_card_networks.end()) {
         out_supported_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);
+        // |method| removed from |remaining_card_networks| so that it is not
+        // doubly added to |out_supported_networks|.
+        remaining_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.
           out_supported_networks->insert(out_supported_networks->end(),
-                                         card_networks.begin(),
-                                         card_networks.end());
-          out_basic_card_specified_networks->insert(card_networks.begin(),
-                                                    card_networks.end());
+                                         remaining_card_networks.begin(),
+                                         remaining_card_networks.end());
+          out_basic_card_specified_networks->insert(kBasicCardNetworks.begin(),
+                                                    kBasicCardNetworks.end());
           // Clear the set so that no further networks are added to
           // |out_supported_networks|.
-          card_networks.clear();
+          remaining_card_networks.clear();
         } else {
           // The merchant has specified a few basic card supported networks. Use
           // the mapping to transform to known basic-card types.
           for (const std::string& supported_network :
                method_data_entry.supported_networks) {
             // Make sure that the network was not already added to
-            // |out_supported_networks|. If it's still in |card_networks| it's
-            // fair game.
-            auto it = card_networks.find(supported_network);
-            if (it != card_networks.end()) {
+            // |out_supported_networks|. If it's still in
+            // |remaining_card_networks| it's fair game.
+            auto it = remaining_card_networks.find(supported_network);
+            if (it != remaining_card_networks.end()) {
               out_supported_networks->push_back(supported_network);
+              remaining_card_networks.erase(it);
+            }
+            if (kBasicCardNetworks.find(supported_network) !=
+                kBasicCardNetworks.end()) {
               out_basic_card_specified_networks->insert(supported_network);
-              card_networks.erase(it);
             }
           }
         }
       }
     }
   }
 }
 
 std::string FormatPhoneForDisplay(const std::string& phone_number,
                                   const std::string& country_code) {
   return FormatPhoneNumber(phone_number, country_code,
                            PhoneNumberUtil::PhoneNumberFormat::INTERNATIONAL);
 }
 
 std::string FormatPhoneForResponse(const std::string& phone_number,
                                    const std::string& country_code) {
   return FormatPhoneNumber(phone_number, country_code,
                            PhoneNumberUtil::PhoneNumberFormat::E164);
 }
 
 }  // namespace data_util
 }  // namespace payments