Layered component for web payments

components/payments/content/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 "components/payments/content/payment_request.h"
+
+#include <unordered_map>
+#include <utility>
 
 #include "base/memory/ptr_util.h"
-#include "components/payments/payment_details_validation.h"
-#include "components/payments/payment_request_web_contents_manager.h"
+#include "components/autofill/core/browser/personal_data_manager.h"
+#include "components/payments/content/payment_details_validation.h"
+#include "components/payments/content/payment_request_web_contents_manager.h"
+#include "components/payments/core/currency_formatter.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),
       selected_credit_card_(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> method_data,
     payments::mojom::PaymentDetailsPtr details,
     payments::mojom::PaymentOptionsPtr options) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 59 matching lines @@
     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();
 }
 
 const std::vector<autofill::AutofillProfile*>&
-    PaymentRequest::shipping_profiles() {
+PaymentRequest::shipping_profiles() {
   return shipping_profiles_;
 }
 
 const std::vector<autofill::AutofillProfile*>&
-    PaymentRequest::contact_profiles() {
+PaymentRequest::contact_profiles() {
   return contact_profiles_;
 }
 
 void PaymentRequest::PopulateProfileCache() {
   std::vector<autofill::AutofillProfile*> profiles =
       personal_data_manager()->GetProfilesToSuggest();
 
   // PaymentRequest may outlive the Profiles returned by the Data Manager.
   // Thus, we store copies, and return a vector of pointers to these copies
   // whenever Profiles are requested. The same is true for credit cards.
@@ skipping 34 matching lines @@
 }
 
 void PaymentRequest::PopulateValidatedMethodData(
     const std::vector<payments::mojom::PaymentMethodDataPtr>& method_data) {
   if (method_data.empty()) {
     LOG(ERROR) << "Invalid payment methods or data";
     OnConnectionTerminated();
     return;
   }
 
+  // Identifier for the basic card payment method in the PaymentMethodData.
+  const char* const kBasicCardMethodName = "basic-card";
   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();
@@ skipping 18 matching lines @@
           // 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.
+          using ::payments::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]);
               card_networks.erase(card_it);
             }
           }
         }
       }
     }
   }
 }
 
 }  // namespace payments