[Payment Request] Moves PaymentRequest into the payments namespace

ios/chrome/browser/payments/payment_request_unittest.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 "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_task_environment.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/autofill_type.h"
@@ skipping 21 matching lines @@
   MockTestPersonalDataManager() : TestPersonalDataManager() {}
   MOCK_METHOD1(RecordUseOf, void(const autofill::AutofillDataModel&));
 };
 
 MATCHER_P(GuidMatches, guid, "") {
   return arg.guid() == guid;
 }
 
 }  // namespace
 
+namespace payments {
+
 class PaymentRequestTest : public testing::Test {
  protected:
   // Returns PaymentDetails with one shipping option that's selected.
   web::PaymentDetails CreateDetailsWithShippingOption() {
     web::PaymentDetails details;
     std::vector<web::PaymentShippingOption> shipping_options;
     web::PaymentShippingOption option1;
     option1.id = base::UTF8ToUTF16("option:1");
     option1.selected = true;
     shipping_options.push_back(std::move(option1));
@@ skipping 21 matching lines @@
 // currency code and currency system.
 TEST_F(PaymentRequestTest, CreatesCurrencyFormatterCorrectly) {
   ASSERT_EQ("en", GetApplicationContext()->GetApplicationLocale());
 
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
   web_payment_request.details.total.amount.currency = base::ASCIIToUTF16("USD");
   TestPaymentRequest payment_request1(web_payment_request,
                                       &personal_data_manager);
-  payments::CurrencyFormatter* currency_formatter =
+  CurrencyFormatter* currency_formatter =
       payment_request1.GetOrCreateCurrencyFormatter();
   EXPECT_EQ(base::UTF8ToUTF16("$55.00"), currency_formatter->Format("55.00"));
   EXPECT_EQ("USD", currency_formatter->formatted_currency_code());
 
   web_payment_request.details.total.amount.currency = base::ASCIIToUTF16("JPY");
   TestPaymentRequest payment_request2(web_payment_request,
                                       &personal_data_manager);
   currency_formatter = payment_request2.GetOrCreateCurrencyFormatter();
   EXPECT_EQ(base::UTF8ToUTF16("¥55"), currency_formatter->Format("55.00"));
   EXPECT_EQ("JPY", currency_formatter->formatted_currency_code());
 
   web_payment_request.details.total.amount.currency_system =
       base::ASCIIToUTF16("NOT_ISO4217");
   web_payment_request.details.total.amount.currency = base::ASCIIToUTF16("USD");
   TestPaymentRequest payment_request3(web_payment_request,
                                       &personal_data_manager);
   currency_formatter = payment_request3.GetOrCreateCurrencyFormatter();
   EXPECT_EQ(base::UTF8ToUTF16("55.00"), currency_formatter->Format("55.00"));
   EXPECT_EQ("USD", currency_formatter->formatted_currency_code());
 }
 
 // Tests that the accepted card networks are identified correctly.
 TEST_F(PaymentRequestTest, AcceptedPaymentNetworks) {
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
-  payments::PaymentMethodData method_datum1;
+  PaymentMethodData method_datum1;
   method_datum1.supported_methods.push_back("visa");
   web_payment_request.method_data.push_back(method_datum1);
-  payments::PaymentMethodData method_datum2;
+  PaymentMethodData method_datum2;
   method_datum2.supported_methods.push_back("mastercard");
   web_payment_request.method_data.push_back(method_datum2);
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
   ASSERT_EQ(2U, payment_request.supported_card_networks().size());
   EXPECT_EQ("visa", payment_request.supported_card_networks()[0]);
   EXPECT_EQ("mastercard", payment_request.supported_card_networks()[1]);
 }
 
 // Test that parsing supported methods (with invalid values and duplicates)
 // works as expected.
 TEST_F(PaymentRequestTest, SupportedMethods) {
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
-  payments::PaymentMethodData method_datum1;
+  PaymentMethodData method_datum1;
   method_datum1.supported_methods.push_back("visa");
   method_datum1.supported_methods.push_back("mastercard");
   method_datum1.supported_methods.push_back("invalid");
   method_datum1.supported_methods.push_back("");
   method_datum1.supported_methods.push_back("visa");
   web_payment_request.method_data.push_back(method_datum1);
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
   ASSERT_EQ(2U, payment_request.supported_card_networks().size());
   EXPECT_EQ("visa", payment_request.supported_card_networks()[0]);
   EXPECT_EQ("mastercard", payment_request.supported_card_networks()[1]);
 }
 
 // Test that parsing supported methods in different method data entries (with
 // invalid values and duplicates) works as expected.
 TEST_F(PaymentRequestTest, SupportedMethods_MultipleEntries) {
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
-  payments::PaymentMethodData method_datum1;
+  PaymentMethodData method_datum1;
   method_datum1.supported_methods.push_back("visa");
   web_payment_request.method_data.push_back(method_datum1);
-  payments::PaymentMethodData method_datum2;
+  PaymentMethodData method_datum2;
   method_datum2.supported_methods.push_back("mastercard");
   web_payment_request.method_data.push_back(method_datum2);
-  payments::PaymentMethodData method_datum3;
+  PaymentMethodData method_datum3;
   method_datum3.supported_methods.push_back("");
   web_payment_request.method_data.push_back(method_datum3);
-  payments::PaymentMethodData method_datum4;
+  PaymentMethodData method_datum4;
   method_datum4.supported_methods.push_back("visa");
   web_payment_request.method_data.push_back(method_datum4);
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
   ASSERT_EQ(2U, payment_request.supported_card_networks().size());
   EXPECT_EQ("visa", payment_request.supported_card_networks()[0]);
   EXPECT_EQ("mastercard", payment_request.supported_card_networks()[1]);
 }
 
 // Test that only specifying basic-card means that all are supported.
 TEST_F(PaymentRequestTest, SupportedMethods_OnlyBasicCard) {
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
-  payments::PaymentMethodData method_datum1;
+  PaymentMethodData method_datum1;
   method_datum1.supported_methods.push_back("basic-card");
   web_payment_request.method_data.push_back(method_datum1);
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
 
   // All of the basic card networks are supported.
   ASSERT_EQ(8U, payment_request.supported_card_networks().size());
   EXPECT_EQ("amex", payment_request.supported_card_networks()[0]);
   EXPECT_EQ("diners", payment_request.supported_card_networks()[1]);
   EXPECT_EQ("discover", payment_request.supported_card_networks()[2]);
   EXPECT_EQ("jcb", payment_request.supported_card_networks()[3]);
   EXPECT_EQ("mastercard", payment_request.supported_card_networks()[4]);
   EXPECT_EQ("mir", payment_request.supported_card_networks()[5]);
   EXPECT_EQ("unionpay", payment_request.supported_card_networks()[6]);
   EXPECT_EQ("visa", payment_request.supported_card_networks()[7]);
 }
 
 // Test that specifying a method AND basic-card means that all are supported,
 // but with the method as first.
 TEST_F(PaymentRequestTest, SupportedMethods_BasicCard_WithSpecificMethod) {
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
-  payments::PaymentMethodData method_datum1;
+  PaymentMethodData method_datum1;
   method_datum1.supported_methods.push_back("jcb");
   method_datum1.supported_methods.push_back("basic-card");
   web_payment_request.method_data.push_back(method_datum1);
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
 
   // All of the basic card networks are supported, but JCB is first because it
   // was specified first.
   EXPECT_EQ(8u, payment_request.supported_card_networks().size());
   EXPECT_EQ("jcb", payment_request.supported_card_networks()[0]);
   EXPECT_EQ("amex", payment_request.supported_card_networks()[1]);
   EXPECT_EQ("diners", payment_request.supported_card_networks()[2]);
   EXPECT_EQ("discover", payment_request.supported_card_networks()[3]);
   EXPECT_EQ("mastercard", payment_request.supported_card_networks()[4]);
   EXPECT_EQ("mir", payment_request.supported_card_networks()[5]);
   EXPECT_EQ("unionpay", payment_request.supported_card_networks()[6]);
   EXPECT_EQ("visa", payment_request.supported_card_networks()[7]);
 }
 
 // Test that specifying basic-card with a supported network (with previous
 // supported methods) will work as expected
 TEST_F(PaymentRequestTest, SupportedMethods_BasicCard_Overlap) {
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
-  payments::PaymentMethodData method_datum1;
+  PaymentMethodData method_datum1;
   method_datum1.supported_methods.push_back("mastercard");
   method_datum1.supported_methods.push_back("visa");
   web_payment_request.method_data.push_back(method_datum1);
-  payments::PaymentMethodData method_datum2;
+  PaymentMethodData method_datum2;
   method_datum2.supported_methods.push_back("basic-card");
   method_datum2.supported_networks.push_back("visa");
   method_datum2.supported_networks.push_back("mastercard");
   method_datum2.supported_networks.push_back("unionpay");
   web_payment_request.method_data.push_back(method_datum2);
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
 
   EXPECT_EQ(3u, payment_request.supported_card_networks().size());
   EXPECT_EQ("mastercard", payment_request.supported_card_networks()[0]);
   EXPECT_EQ("visa", payment_request.supported_card_networks()[1]);
   EXPECT_EQ("unionpay", payment_request.supported_card_networks()[2]);
 }
 
 // Test that specifying basic-card with supported networks after specifying
 // some methods
 TEST_F(PaymentRequestTest, SupportedMethods_BasicCard_WithSupportedNetworks) {
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
-  payments::PaymentMethodData method_datum1;
+  PaymentMethodData method_datum1;
   method_datum1.supported_methods.push_back("basic-card");
   method_datum1.supported_networks.push_back("visa");
   method_datum1.supported_networks.push_back("unionpay");
   web_payment_request.method_data.push_back(method_datum1);
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
 
   // Only the specified networks are supported.
   EXPECT_EQ(2u, payment_request.supported_card_networks().size());
   EXPECT_EQ("visa", payment_request.supported_card_networks()[0]);
   EXPECT_EQ("unionpay", payment_request.supported_card_networks()[1]);
 }
 
 // Tests that an autofill payment instrumnt e.g., credit cards can be added
 // to the list of available payment methods.
 TEST_F(PaymentRequestTest, AddAutofillPaymentInstrument) {
   web::PaymentRequest web_payment_request;
-  payments::PaymentMethodData method_datum;
+  PaymentMethodData method_datum;
   method_datum.supported_methods.push_back("basic-card");
   method_datum.supported_networks.push_back("visa");
   method_datum.supported_networks.push_back("amex");
   web_payment_request.method_data.push_back(method_datum);
 
   autofill::TestPersonalDataManager personal_data_manager;
 
   autofill::CreditCard credit_card_1 = autofill::test::GetCreditCard();
   personal_data_manager.AddTestingCreditCard(&credit_card_1);
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
   EXPECT_EQ(1U, payment_request.payment_methods().size());
 
   autofill::CreditCard credit_card_2 = autofill::test::GetCreditCard2();
-  payments::AutofillPaymentInstrument* added_credit_card =
+  AutofillPaymentInstrument* added_credit_card =
       payment_request.AddAutofillPaymentInstrument(credit_card_2);
 
   EXPECT_EQ(2U, payment_request.payment_methods().size());
   EXPECT_EQ(credit_card_2, *added_credit_card->credit_card());
 }
 
 // Tests that a profile can be added to the list of available profiles.
 TEST_F(PaymentRequestTest, AddAutofillProfile) {
   web::PaymentRequest web_payment_request;
   web_payment_request.options = CreatePaymentOptions(
@@ skipping 206 matching lines @@
   credit_card.SetExpirationYear(2016);  // Expired.
   credit_card.set_billing_address_id(billing_address.guid());
 
   web::PaymentRequest web_payment_request =
       payment_request_test_util::CreateTestWebPaymentRequest();
 
   // credit_card is selected because expired cards are valid for payment.
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
   EXPECT_EQ(payment_request.selected_payment_method()->type(),
-            payments::PaymentInstrument::Type::AUTOFILL);
-  payments::AutofillPaymentInstrument* payment_instrument =
-      static_cast<payments::AutofillPaymentInstrument*>(
+            PaymentInstrument::Type::AUTOFILL);
+  AutofillPaymentInstrument* payment_instrument =
+      static_cast<AutofillPaymentInstrument*>(
           payment_request.selected_payment_method());
   EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid());
 }
 
 // Test that loading complete payment methods works as expected.
 TEST_F(PaymentRequestTest, SelectedPaymentMethod_Complete) {
   autofill::TestPersonalDataManager personal_data_manager;
   autofill::AutofillProfile billing_address = autofill::test::GetFullProfile();
   personal_data_manager.AddTestingProfile(&billing_address);
   autofill::CreditCard credit_card = autofill::test::GetCreditCard();
   credit_card.set_use_count(5U);
   personal_data_manager.AddTestingCreditCard(&credit_card);
   credit_card.set_billing_address_id(billing_address.guid());
   autofill::CreditCard credit_card2 = autofill::test::GetCreditCard2();
   credit_card2.set_use_count(15U);
   personal_data_manager.AddTestingCreditCard(&credit_card2);
   credit_card2.set_billing_address_id(billing_address.guid());
 
   web::PaymentRequest web_payment_request =
       payment_request_test_util::CreateTestWebPaymentRequest();
 
   // credit_card2 is selected because it has the most use count (Frecency
   // model).
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
-  payments::AutofillPaymentInstrument* payment_instrument =
-      static_cast<payments::AutofillPaymentInstrument*>(
+  AutofillPaymentInstrument* payment_instrument =
+      static_cast<AutofillPaymentInstrument*>(
           payment_request.selected_payment_method());
   EXPECT_EQ(credit_card2.guid(), payment_instrument->credit_card()->guid());
 }
 
 // Test that loading incomplete payment methods works as expected.
 TEST_F(PaymentRequestTest, SelectedPaymentMethod_Incomplete) {
   autofill::TestPersonalDataManager personal_data_manager;
   autofill::AutofillProfile billing_address = autofill::test::GetFullProfile();
   personal_data_manager.AddTestingProfile(&billing_address);
   autofill::CreditCard credit_card = autofill::test::GetCreditCard();
   credit_card.set_use_count(5U);
   personal_data_manager.AddTestingCreditCard(&credit_card);
   credit_card.set_billing_address_id(billing_address.guid());
   autofill::CreditCard credit_card2 = autofill::test::GetCreditCard2();
   credit_card2.set_use_count(15U);
   personal_data_manager.AddTestingCreditCard(&credit_card2);
 
   web::PaymentRequest web_payment_request =
       payment_request_test_util::CreateTestWebPaymentRequest();
 
   // Even though credit_card2 has more use counts, credit_card is selected
   // because it is complete.
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
-  payments::AutofillPaymentInstrument* payment_instrument =
-      static_cast<payments::AutofillPaymentInstrument*>(
+  AutofillPaymentInstrument* payment_instrument =
+      static_cast<AutofillPaymentInstrument*>(
           payment_request.selected_payment_method());
   EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid());
 }
 
 // Test that the use counts of the data models are updated as expected when
 // different autofill profiles are used as the shipping address and the contact
 // info.
 TEST_F(PaymentRequestTest, RecordUseStats_RequestShippingAndContactInfo) {
   MockTestPersonalDataManager personal_data_manager;
   // Add a profile that is incomplete for a contact info, but is used more
   // frequently so is selected as the default shipping address.
   autofill::AutofillProfile address = autofill::test::GetFullProfile();
   address.SetInfo(autofill::AutofillType(autofill::EMAIL_ADDRESS),
                   base::string16(), "en-US");
   address.set_use_count(10U);
   personal_data_manager.AddTestingProfile(&address);
   autofill::AutofillProfile contact_info = autofill::test::GetFullProfile2();
   contact_info.set_use_count(5U);
   personal_data_manager.AddTestingProfile(&contact_info);
   autofill::CreditCard credit_card = autofill::test::GetCreditCard();
   personal_data_manager.AddTestingCreditCard(&credit_card);
   credit_card.set_billing_address_id(address.guid());
 
   web::PaymentRequest web_payment_request =
       payment_request_test_util::CreateTestWebPaymentRequest();
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
-  payments::AutofillPaymentInstrument* payment_instrument =
-      static_cast<payments::AutofillPaymentInstrument*>(
+  AutofillPaymentInstrument* payment_instrument =
+      static_cast<AutofillPaymentInstrument*>(
           payment_request.selected_payment_method());
   EXPECT_EQ(address.guid(),
             payment_request.selected_shipping_profile()->guid());
   EXPECT_EQ(contact_info.guid(),
             payment_request.selected_contact_profile()->guid());
   EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid());
 
   EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid())))
       .Times(1);
   EXPECT_CALL(personal_data_manager,
@@ skipping 14 matching lines @@
   personal_data_manager.AddTestingProfile(&address);
   autofill::CreditCard credit_card = autofill::test::GetCreditCard();
   personal_data_manager.AddTestingCreditCard(&credit_card);
   credit_card.set_billing_address_id(address.guid());
 
   web::PaymentRequest web_payment_request =
       payment_request_test_util::CreateTestWebPaymentRequest();
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
-  payments::AutofillPaymentInstrument* payment_instrument =
-      static_cast<payments::AutofillPaymentInstrument*>(
+  AutofillPaymentInstrument* payment_instrument =
+      static_cast<AutofillPaymentInstrument*>(
           payment_request.selected_payment_method());
   EXPECT_EQ(address.guid(),
             payment_request.selected_shipping_profile()->guid());
   EXPECT_EQ(address.guid(), payment_request.selected_contact_profile()->guid());
   EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid());
 
   // Even though |address| is used for contact info, shipping address, and
   // credit_card's billing address, the stats should be updated only once.
   EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid())))
       .Times(1);
@@ skipping 15 matching lines @@
   credit_card.set_billing_address_id(address.guid());
 
   web::PaymentRequest web_payment_request =
       payment_request_test_util::CreateTestWebPaymentRequest();
   web_payment_request.options.request_payer_name = false;
   web_payment_request.options.request_payer_email = false;
   web_payment_request.options.request_payer_phone = false;
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
-  payments::AutofillPaymentInstrument* payment_instrument =
-      static_cast<payments::AutofillPaymentInstrument*>(
+  AutofillPaymentInstrument* payment_instrument =
+      static_cast<AutofillPaymentInstrument*>(
           payment_request.selected_payment_method());
   EXPECT_EQ(address.guid(),
             payment_request.selected_shipping_profile()->guid());
   EXPECT_EQ(nullptr, payment_request.selected_contact_profile());
   EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid());
 
   EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid())))
       .Times(1);
   EXPECT_CALL(personal_data_manager,
               RecordUseOf(GuidMatches(credit_card.guid())))
@@ skipping 11 matching lines @@
   autofill::CreditCard credit_card = autofill::test::GetCreditCard();
   personal_data_manager.AddTestingCreditCard(&credit_card);
   credit_card.set_billing_address_id(address.guid());
 
   web::PaymentRequest web_payment_request =
       payment_request_test_util::CreateTestWebPaymentRequest();
   web_payment_request.options.request_shipping = false;
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
-  payments::AutofillPaymentInstrument* payment_instrument =
-      static_cast<payments::AutofillPaymentInstrument*>(
+  AutofillPaymentInstrument* payment_instrument =
+      static_cast<AutofillPaymentInstrument*>(
           payment_request.selected_payment_method());
   EXPECT_EQ(nullptr, payment_request.selected_shipping_profile());
   EXPECT_EQ(address.guid(), payment_request.selected_contact_profile()->guid());
   EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid());
 
   EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid())))
       .Times(1);
   EXPECT_CALL(personal_data_manager,
               RecordUseOf(GuidMatches(credit_card.guid())))
       .Times(1);
@@ skipping 13 matching lines @@
 
   web::PaymentRequest web_payment_request =
       payment_request_test_util::CreateTestWebPaymentRequest();
   web_payment_request.options.request_shipping = false;
   web_payment_request.options.request_payer_name = false;
   web_payment_request.options.request_payer_email = false;
   web_payment_request.options.request_payer_phone = false;
 
   TestPaymentRequest payment_request(web_payment_request,
                                      &personal_data_manager);
-  payments::AutofillPaymentInstrument* payment_instrument =
-      static_cast<payments::AutofillPaymentInstrument*>(
+  AutofillPaymentInstrument* payment_instrument =
+      static_cast<AutofillPaymentInstrument*>(
           payment_request.selected_payment_method());
   EXPECT_EQ(nullptr, payment_request.selected_shipping_profile());
   EXPECT_EQ(nullptr, payment_request.selected_contact_profile());
   EXPECT_EQ(credit_card.guid(), payment_instrument->credit_card()->guid());
 
   EXPECT_CALL(personal_data_manager, RecordUseOf(GuidMatches(address.guid())))
       .Times(0);
   EXPECT_CALL(personal_data_manager,
               RecordUseOf(GuidMatches(credit_card.guid())))
       .Times(1);
 
   payment_request.RecordUseStats();
 }
+
+}  // namespace payments