Add support for method selection in the Payment Request UI on iOS.

ios/web/payments/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 "ios/web/public/payments/payment_request.h"
 
 #include "base/values.h"
 
 namespace {
 
 // All of these are defined here (even though most are only used once each) so
 // the format details are easy to locate and update or compare to the spec doc.
 // (https://w3c.github.io/browser-payment-api/).
+static const char kAddressCountry[] = "country";
+static const char kAddressAddressLine[] = "addressLine";
+static const char kAddressRegion[] = "region";
+static const char kAddressCity[] = "city";
+static const char kAddressDependentLocality[] = "dependentLocality";
+static const char kAddressPostalCode[] = "postalCode";
+static const char kAddressSortingCode[] = "sortingCode";
+static const char kAddressLanguageCode[] = "languageCode";
+static const char kAddressOrganization[] = "organization";
+static const char kAddressRecipient[] = "recipient";
+static const char kAddressCareOf[] = "careOf";
+static const char kAddressPhone[] = "phone";
 static const char kMethodData[] = "methodData";
 static const char kSupportedMethods[] = "supportedMethods";
 static const char kData[] = "data";
 static const char kPaymentDetails[] = "details";
 static const char kPaymentDetailsTotal[] = "total";
 static const char kPaymentDetailsTotalAmount[] = "amount";
 static const char kPaymentDetailsTotalAmountCurrency[] = "currency";
 static const char kPaymentDetailsTotalAmountValue[] = "value";
 static const char kMethodName[] = "methodName";
+static const char kCardCardholderName[] = "cardholderName";
+static const char kCardCardNumber[] = "cardNumber";
+static const char kCardExpiryMonth[] = "expiryMonth";
+static const char kCardExpiryYear[] = "expiryYear";
+static const char kCardCardSecurityCode[] = "cardSecurityCode";
+static const char kCardBillingAddress[] = "billingAddress";
 
 }  // namespace
 
 namespace web {
 
 PaymentAddress::PaymentAddress() {}
 PaymentAddress::PaymentAddress(const PaymentAddress& other) = default;
 PaymentAddress::~PaymentAddress() = default;
 
 bool PaymentAddress::operator==(const PaymentAddress& other) const {
   return this->country == other.country &&
          this->address_line == other.address_line &&
          this->region == other.region && this->city == other.city &&
          this->dependent_locality == other.dependent_locality &&
          this->postal_code == other.postal_code &&
          this->sorting_code == other.sorting_code &&
          this->language_code == other.language_code &&
          this->organization == other.organization &&
          this->recipient == other.recipient && this->care_of == other.care_of &&
          this->phone == other.phone;
 }
 
 bool PaymentAddress::operator!=(const PaymentAddress& other) const {
   return !(*this == other);
 }
 
+void PaymentAddress::ToDictionaryValue(base::DictionaryValue* value) const {
+  DCHECK(value);
+  value->Clear();
+
+  if (!this->country.empty())
+    value->SetString(kAddressCountry, this->country);
+
+  if (!this->address_line.empty()) {
+    std::unique_ptr<base::ListValue> address_line(new base::ListValue);
+    for (base::string16 address_line_string : this->address_line) {
+      address_line->AppendString(address_line_string);
+    }
+    value->Set(kAddressAddressLine, std::move(address_line));
+  }
+
+  if (!this->region.empty())
+    value->SetString(kAddressRegion, this->region);
+  if (!this->city.empty())
+    value->SetString(kAddressCity, this->city);
+  if (!this->dependent_locality.empty())
+    value->SetString(kAddressDependentLocality, this->dependent_locality);
+  if (!this->postal_code.empty())
+    value->SetString(kAddressPostalCode, this->postal_code);
+  if (!this->sorting_code.empty())
+    value->SetString(kAddressSortingCode, this->sorting_code);
+  if (!this->language_code.empty())
+    value->SetString(kAddressLanguageCode, this->language_code);
+  if (!this->organization.empty())
+    value->SetString(kAddressOrganization, this->organization);
+  if (!this->recipient.empty())
+    value->SetString(kAddressRecipient, this->recipient);
+  if (!this->care_of.empty())
+    value->SetString(kAddressCareOf, this->care_of);
+  if (!this->phone.empty())
+    value->SetString(kAddressPhone, this->phone);
+}
+
 PaymentMethodData::PaymentMethodData() {}
 PaymentMethodData::PaymentMethodData(const PaymentMethodData& other) = default;
 PaymentMethodData::~PaymentMethodData() = default;
 
 bool PaymentMethodData::operator==(const PaymentMethodData& other) const {
   return this->supported_methods == other.supported_methods &&
          this->data == other.data;
 }
 
 bool PaymentMethodData::operator!=(const PaymentMethodData& other) const {
@@ skipping 151 matching lines @@
                                &this->details.total.amount.value);
       }
     }
   }
 
   // TODO(crbug.com/602666): Parse the remaining elements.
 
   return true;
 }
 
+BasicCardResponse::BasicCardResponse() {}
+BasicCardResponse::BasicCardResponse(const BasicCardResponse& other) = default;
+BasicCardResponse::~BasicCardResponse() = default;
+
+bool BasicCardResponse::operator==(const BasicCardResponse& other) const {
+  return this->cardholder_name == other.cardholder_name &&
+         this->card_number == other.card_number &&
+         this->expiry_month == other.expiry_month &&
+         this->expiry_year == other.expiry_year &&
+         this->card_security_code == other.card_security_code &&
+         this->billing_address == other.billing_address;
+}
+
+bool BasicCardResponse::operator!=(const BasicCardResponse& other) const {
+  return !(*this == other);
+}
+
+void BasicCardResponse::ToDictionaryValue(base::DictionaryValue* value) const {

[Evan Stade, 2016/08/29 20:34:06]

why does this use an outparam instead of return value?

[Justin Donnelly, 2016/08/30 15:21:25]

No good reason, just habit of using out params. Changed.

Note that downstream code calls PaymentResponse's out param method so I'm
leaving in a version of that until the associated downstream CL lands then I'll
remove it.

+  DCHECK(value);
+  value->Clear();
+
+  if (!this->cardholder_name.empty())
+    value->SetString(kCardCardholderName, this->cardholder_name);
+  if (!this->card_number.empty())
+    value->SetString(kCardCardNumber, this->card_number);
+  if (!this->expiry_month.empty())
+    value->SetString(kCardExpiryMonth, this->expiry_month);
+  if (!this->expiry_year.empty())
+    value->SetString(kCardExpiryYear, this->expiry_year);
+  if (!this->card_security_code.empty())
+    value->SetString(kCardCardSecurityCode, this->card_security_code);
+
+  std::unique_ptr<base::DictionaryValue> address(new base::DictionaryValue);
+  this->billing_address.ToDictionaryValue(address.get());
+  value->Set(kCardBillingAddress, std::move(address));
+}
+
 PaymentResponse::PaymentResponse() {}
+PaymentResponse::PaymentResponse(const PaymentResponse& other) = default;
 PaymentResponse::~PaymentResponse() = default;
 
 bool PaymentResponse::operator==(const PaymentResponse& other) const {
   return this->method_name == other.method_name &&
          this->details == other.details;
 }
 
 bool PaymentResponse::operator!=(const PaymentResponse& other) const {
   return !(*this == other);
 }
 
 void PaymentResponse::ToDictionaryValue(base::DictionaryValue* value) const {
   DCHECK(value);
+  value->Clear();
+
   if (!this->method_name.empty())
     value->SetString(kMethodName, this->method_name);
-  if (!this->details.empty())
-    value->SetString(kPaymentDetails, this->details);
+
+  std::unique_ptr<base::DictionaryValue> details(new base::DictionaryValue);
+  this->details.ToDictionaryValue(details.get());
+  value->Set(kPaymentDetails, std::move(details));
 }
 
 }  // namespace web