[Payment Request] Moves PaymentRequest into the payments namespace

ios/chrome/browser/payments/payment_request.mm

 // 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 "ios/chrome/browser/payments/payment_request.h"
 
 #include <algorithm>
 
 #include "base/containers/adapters.h"
 #include "base/memory/ptr_util.h"
@@ skipping 33 matching lines @@
       new autofill::ChromeMetadataSource(I18N_ADDRESS_VALIDATION_DATA_URL,
                                          url_context_getter));
 }
 
 std::unique_ptr<::i18n::addressinput::Storage> GetAddressInputStorage() {
   return autofill::ValidationRulesStorageFactory::CreateStorage();
 }
 
 }  // namespace
 
+namespace payments {
+
 PaymentRequest::PaymentRequest(
     const web::PaymentRequest& web_payment_request,
     ios::ChromeBrowserState* browser_state,
     autofill::PersonalDataManager* personal_data_manager,
     id<PaymentRequestUIDelegate> payment_request_ui_delegate)
     : web_payment_request_(web_payment_request),
       browser_state_(browser_state),
       personal_data_manager_(personal_data_manager),
       payment_request_ui_delegate_(payment_request_ui_delegate),
-      address_normalizer_(new payments::AddressNormalizerImpl(
+      address_normalizer_(new AddressNormalizerImpl(
           GetAddressInputSource(
               personal_data_manager_->GetURLRequestContextGetter()),
           GetAddressInputStorage())),
       selected_shipping_profile_(nullptr),
       selected_contact_profile_(nullptr),
       selected_payment_method_(nullptr),
       selected_shipping_option_(nullptr),
       profile_comparator_(GetApplicationContext()->GetApplicationLocale(),
                           *this) {
   PopulateAvailableShippingOptions();
@@ skipping 19 matching lines @@
     if (!contact_profiles_.empty() &&
         profile_comparator_.IsContactInfoComplete(contact_profiles_[0])) {
       selected_contact_profile_ = contact_profiles_[0];
     }
   }
 
   // TODO(crbug.com/702063): Change this code to prioritize payment methods by
   // use count and other means.
   auto first_complete_payment_method =
       std::find_if(payment_methods_.begin(), payment_methods_.end(),
-                   [this](payments::PaymentInstrument* payment_method) {
+                   [this](PaymentInstrument* payment_method) {
                      return payment_method->IsCompleteForPayment();
                    });
   if (first_complete_payment_method != payment_methods_.end())
     selected_payment_method_ = *first_complete_payment_method;
 }
 
 PaymentRequest::~PaymentRequest() {}
 
 autofill::PersonalDataManager* PaymentRequest::GetPersonalDataManager() {
   return personal_data_manager_;
@@ skipping 18 matching lines @@
 }
 
 void PaymentRequest::DoFullCardRequest(
     const autofill::CreditCard& credit_card,
     base::WeakPtr<autofill::payments::FullCardRequest::ResultDelegate>
         result_delegate) {
   [payment_request_ui_delegate_ requestFullCreditCard:credit_card
                                        resultDelegate:result_delegate];
 }
 
-payments::AddressNormalizer* PaymentRequest::GetAddressNormalizer() {
+AddressNormalizer* PaymentRequest::GetAddressNormalizer() {
   return address_normalizer_;
 }
 
 autofill::RegionDataLoader* PaymentRequest::GetRegionDataLoader() {
   return new autofill::RegionDataLoaderImpl(
       GetAddressInputSource(
           personal_data_manager_->GetURLRequestContextGetter())
           .release(),
       GetAddressInputStorage().release(),
       GetApplicationContext()->GetApplicationLocale());
@@ skipping 31 matching lines @@
 }
 
 bool PaymentRequest::request_payer_phone() const {
   return web_payment_request_.options.request_payer_phone;
 }
 
 bool PaymentRequest::request_payer_email() const {
   return web_payment_request_.options.request_payer_email;
 }
 
-payments::PaymentShippingType PaymentRequest::shipping_type() const {
+PaymentShippingType PaymentRequest::shipping_type() const {
   return web_payment_request_.options.shipping_type;
 }
 
-payments::CurrencyFormatter* PaymentRequest::GetOrCreateCurrencyFormatter() {
+CurrencyFormatter* PaymentRequest::GetOrCreateCurrencyFormatter() {
   if (!currency_formatter_) {
-    currency_formatter_.reset(new payments::CurrencyFormatter(
+    currency_formatter_.reset(new CurrencyFormatter(
         base::UTF16ToASCII(web_payment_request_.details.total.amount.currency),
         base::UTF16ToASCII(
             web_payment_request_.details.total.amount.currency_system),
         GetApplicationContext()->GetApplicationLocale()));
   }
   return currency_formatter_.get();
 }
 
 autofill::AutofillProfile* PaymentRequest::AddAutofillProfile(
     const autofill::AutofillProfile& profile) {
@@ skipping 33 matching lines @@
 
   // Contact profiles are deduped and ordered by completeness.
   contact_profiles_ =
       profile_comparator_.FilterProfilesForContact(raw_profiles_for_filtering);
 
   // Shipping profiles are ordered by completeness.
   shipping_profiles_ =
       profile_comparator_.FilterProfilesForShipping(raw_profiles_for_filtering);
 }
 
-payments::AutofillPaymentInstrument*
-PaymentRequest::AddAutofillPaymentInstrument(
+AutofillPaymentInstrument* PaymentRequest::AddAutofillPaymentInstrument(
     const autofill::CreditCard& credit_card) {
   std::string basic_card_issuer_network =
       autofill::data_util::GetPaymentRequestData(credit_card.network())
           .basic_card_issuer_network;
 
   if (!base::ContainsValue(supported_card_networks_,
                            basic_card_issuer_network) ||
       !supported_card_types_set_.count(credit_card.card_type())) {
     return nullptr;
   }
@@ skipping 11 matching lines @@
 
   // Whether the card type (credit, debit, prepaid) matches the type that the
   // merchant has requested exactly. This should be false for unknown card
   // types, if the merchant cannot accept some card types.
   bool matches_merchant_card_type_exactly =
       credit_card.card_type() != autofill::CreditCard::CARD_TYPE_UNKNOWN ||
       supported_card_types_set_.size() == kTotalNumberOfCardTypes;
 
   // AutofillPaymentInstrument makes a copy of |credit_card| so it is
   // effectively owned by this object.
-  payment_method_cache_.push_back(
-      base::MakeUnique<payments::AutofillPaymentInstrument>(
-          method_name, credit_card, matches_merchant_card_type_exactly,
-          billing_profiles(), GetApplicationContext()->GetApplicationLocale(),
-          this));
+  payment_method_cache_.push_back(base::MakeUnique<AutofillPaymentInstrument>(
+      method_name, credit_card, matches_merchant_card_type_exactly,
+      billing_profiles(), GetApplicationContext()->GetApplicationLocale(),
+      this));
 
   PopulateAvailablePaymentMethods();
 
-  return static_cast<payments::AutofillPaymentInstrument*>(
+  return static_cast<AutofillPaymentInstrument*>(
       payment_method_cache_.back().get());
 }
 
-payments::PaymentsProfileComparator* PaymentRequest::profile_comparator() {
+PaymentsProfileComparator* PaymentRequest::profile_comparator() {
   return &profile_comparator_;
 }
 
 bool PaymentRequest::CanMakePayment() const {
-  for (payments::PaymentInstrument* payment_method : payment_methods_) {
+  for (PaymentInstrument* payment_method : payment_methods_) {
     if (payment_method->IsValidForCanMakePayment()) {
       return true;
     }
   }
   return false;
 }
 
 void PaymentRequest::RecordUseStats() {
   if (request_shipping()) {
     DCHECK(selected_shipping_profile_);
     personal_data_manager_->RecordUseOf(*selected_shipping_profile_);
   }
 
   if (request_payer_name() || request_payer_email() || request_payer_phone()) {
     DCHECK(selected_contact_profile_);
     // If the same address was used for both contact and shipping, the stats
     // should be updated only once.
     if (!request_shipping() || (selected_shipping_profile_->guid() !=
                                 selected_contact_profile_->guid())) {
       personal_data_manager_->RecordUseOf(*selected_contact_profile_);
     }
   }
 
   selected_payment_method_->RecordUse();
 }
 
 void PaymentRequest::PopulatePaymentMethodCache() {
-  for (const payments::PaymentMethodData& method_data_entry :
+  for (const PaymentMethodData& method_data_entry :
        web_payment_request_.method_data) {
     for (const std::string& method : method_data_entry.supported_methods) {
       stringified_method_data_[method].insert(method_data_entry.data);
     }
   }
 
   // TODO(crbug.com/709036): Validate method data.
-  payments::data_util::ParseBasicCardSupportedNetworks(
-      web_payment_request_.method_data, &supported_card_networks_,
-      &basic_card_specified_networks_);
+  data_util::ParseBasicCardSupportedNetworks(web_payment_request_.method_data,
+                                             &supported_card_networks_,
+                                             &basic_card_specified_networks_);
 
-  payments::data_util::ParseSupportedCardTypes(web_payment_request_.method_data,
-                                               &supported_card_types_set_);
+  data_util::ParseSupportedCardTypes(web_payment_request_.method_data,
+                                     &supported_card_types_set_);
 
   const std::vector<autofill::CreditCard*>& credit_cards_to_suggest =
       personal_data_manager_->GetCreditCardsToSuggest();
   // Return early if the user has no stored credit cards.
   if (credit_cards_to_suggest.empty())
     return;
 
   // TODO(crbug.com/602666): Determine number of possible payments so
   // that we can appropriate reserve space in the following vector.
 
@@ skipping 32 matching lines @@
 void PaymentRequest::SetSelectedShippingOption() {
   // If more than one option has |selected| set, the last one in the sequence
   // should be treated as the selected item.
   for (auto* shipping_option : base::Reversed(shipping_options_)) {
     if (shipping_option->selected) {
       selected_shipping_option_ = shipping_option;
       break;
     }
   }
 }
+
+}  // namespace payments