dom/payments/PaymentRequestData.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/PaymentRequestBinding.h"
   8 #include "mozilla/dom/ToJSValue.h"
   9 #include "nsArrayUtils.h"
  10 #include "nsComponentManagerUtils.h"
  11 #include "nsIMutableArray.h"
  12 #include "nsUnicharUtils.h"
  13 #include "PaymentRequestData.h"
  14 #include "PaymentRequestUtils.h"
  15
  16 namespace mozilla::dom::payments {
  17
  18 /* PaymentMethodData */
  19
  20 NS_IMPL_ISUPPORTS(PaymentMethodData, nsIPaymentMethodData)
  21
  22 PaymentMethodData::PaymentMethodData(const nsAString& aSupportedMethods,
  23                                      const nsAString& aData)
  24     : mSupportedMethods(aSupportedMethods), mData(aData) {}
  25
  26 nsresult PaymentMethodData::Create(const IPCPaymentMethodData& aIPCMethodData,
  27                                    nsIPaymentMethodData** aMethodData) {
  28   NS_ENSURE_ARG_POINTER(aMethodData);
  29   nsCOMPtr<nsIPaymentMethodData> methodData = new PaymentMethodData(
  30       aIPCMethodData.supportedMethods(), aIPCMethodData.data());
  31   methodData.forget(aMethodData);
  32   return NS_OK;
  33 }
  34
  35 NS_IMETHODIMP
  36 PaymentMethodData::GetSupportedMethods(nsAString& aSupportedMethods) {
  37   aSupportedMethods = mSupportedMethods;
  38   return NS_OK;
  39 }
  40
  41 NS_IMETHODIMP
  42 PaymentMethodData::GetData(JSContext* aCx, JS::MutableHandle<JS::Value> aData) {
  43   if (mData.IsEmpty()) {
  44     aData.set(JS::NullValue());
  45     return NS_OK;
  46   }
  47   nsresult rv = DeserializeToJSValue(mData, aCx, aData);
  48   if (NS_WARN_IF(NS_FAILED(rv))) {
  49     return rv;
  50   }
  51   return NS_OK;
  52 }
  53
  54 /* PaymentCurrencyAmount */
  55
  56 NS_IMPL_ISUPPORTS(PaymentCurrencyAmount, nsIPaymentCurrencyAmount)
  57
  58 PaymentCurrencyAmount::PaymentCurrencyAmount(const nsAString& aCurrency,
  59                                              const nsAString& aValue)
  60     : mValue(aValue) {
  61   /*
  62    *  According to the spec
  63    *  https://w3c.github.io/payment-request/#validity-checkers
  64    *  Set amount.currency to the result of ASCII uppercasing amount.currency.
  65    */
  66   ToUpperCase(aCurrency, mCurrency);
  67 }
  68
  69 nsresult PaymentCurrencyAmount::Create(
  70     const IPCPaymentCurrencyAmount& aIPCAmount,
  71     nsIPaymentCurrencyAmount** aAmount) {
  72   NS_ENSURE_ARG_POINTER(aAmount);
  73   nsCOMPtr<nsIPaymentCurrencyAmount> amount =
  74       new PaymentCurrencyAmount(aIPCAmount.currency(), aIPCAmount.value());
  75   amount.forget(aAmount);
  76   return NS_OK;
  77 }
  78
  79 NS_IMETHODIMP
  80 PaymentCurrencyAmount::GetCurrency(nsAString& aCurrency) {
  81   aCurrency = mCurrency;
  82   return NS_OK;
  83 }
  84
  85 NS_IMETHODIMP
  86 PaymentCurrencyAmount::GetValue(nsAString& aValue) {
  87   aValue = mValue;
  88   return NS_OK;
  89 }
  90
  91 /* PaymentItem */
  92
  93 NS_IMPL_ISUPPORTS(PaymentItem, nsIPaymentItem)
  94
  95 PaymentItem::PaymentItem(const nsAString& aLabel,
  96                          nsIPaymentCurrencyAmount* aAmount, const bool aPending)
  97     : mLabel(aLabel), mAmount(aAmount), mPending(aPending) {}
  98
  99 nsresult PaymentItem::Create(const IPCPaymentItem& aIPCItem,
 100                              nsIPaymentItem** aItem) {
 101   NS_ENSURE_ARG_POINTER(aItem);
 102   nsCOMPtr<nsIPaymentCurrencyAmount> amount;
 103   nsresult rv =
 104       PaymentCurrencyAmount::Create(aIPCItem.amount(), getter_AddRefs(amount));
 105   if (NS_WARN_IF(NS_FAILED(rv))) {
 106     return rv;
 107   }
 108   nsCOMPtr<nsIPaymentItem> item =
 109       new PaymentItem(aIPCItem.label(), amount, aIPCItem.pending());
 110   item.forget(aItem);
 111   return NS_OK;
 112 }
 113
 114 NS_IMETHODIMP
 115 PaymentItem::GetLabel(nsAString& aLabel) {
 116   aLabel = mLabel;
 117   return NS_OK;
 118 }
 119
 120 NS_IMETHODIMP
 121 PaymentItem::GetAmount(nsIPaymentCurrencyAmount** aAmount) {
 122   NS_ENSURE_ARG_POINTER(aAmount);
 123   MOZ_ASSERT(mAmount);
 124   nsCOMPtr<nsIPaymentCurrencyAmount> amount = mAmount;
 125   amount.forget(aAmount);
 126   return NS_OK;
 127 }
 128
 129 NS_IMETHODIMP
 130 PaymentItem::GetPending(bool* aPending) {
 131   NS_ENSURE_ARG_POINTER(aPending);
 132   *aPending = mPending;
 133   return NS_OK;
 134 }
 135
 136 /* PaymentDetailsModifier */
 137
 138 NS_IMPL_ISUPPORTS(PaymentDetailsModifier, nsIPaymentDetailsModifier)
 139
 140 PaymentDetailsModifier::PaymentDetailsModifier(
 141     const nsAString& aSupportedMethods, nsIPaymentItem* aTotal,
 142     nsIArray* aAdditionalDisplayItems, const nsAString& aData)
 143     : mSupportedMethods(aSupportedMethods),
 144       mTotal(aTotal),
 145       mAdditionalDisplayItems(aAdditionalDisplayItems),
 146       mData(aData) {}
 147
 148 nsresult PaymentDetailsModifier::Create(
 149     const IPCPaymentDetailsModifier& aIPCModifier,
 150     nsIPaymentDetailsModifier** aModifier) {
 151   NS_ENSURE_ARG_POINTER(aModifier);
 152   nsCOMPtr<nsIPaymentItem> total;
 153   nsresult rv =
 154       PaymentItem::Create(aIPCModifier.total(), getter_AddRefs(total));
 155   if (NS_WARN_IF(NS_FAILED(rv))) {
 156     return rv;
 157   }
 158
 159   nsCOMPtr<nsIArray> displayItems;
 160   if (aIPCModifier.additionalDisplayItemsPassed()) {
 161     nsCOMPtr<nsIMutableArray> items = do_CreateInstance(NS_ARRAY_CONTRACTID);
 162     MOZ_ASSERT(items);
 163     for (const IPCPaymentItem& item : aIPCModifier.additionalDisplayItems()) {
 164       nsCOMPtr<nsIPaymentItem> additionalItem;
 165       rv = PaymentItem::Create(item, getter_AddRefs(additionalItem));
 166       if (NS_WARN_IF(NS_FAILED(rv))) {
 167         return rv;
 168       }
 169       rv = items->AppendElement(additionalItem);
 170       if (NS_WARN_IF(NS_FAILED(rv))) {
 171         return rv;
 172       }
 173     }
 174     displayItems = std::move(items);
 175   }
 176   nsCOMPtr<nsIPaymentDetailsModifier> modifier =
 177       new PaymentDetailsModifier(aIPCModifier.supportedMethods(), total,
 178                                  displayItems, aIPCModifier.data());
 179   modifier.forget(aModifier);
 180   return NS_OK;
 181 }
 182
 183 NS_IMETHODIMP
 184 PaymentDetailsModifier::GetSupportedMethods(nsAString& aSupportedMethods) {
 185   aSupportedMethods = mSupportedMethods;
 186   return NS_OK;
 187 }
 188
 189 NS_IMETHODIMP
 190 PaymentDetailsModifier::GetTotal(nsIPaymentItem** aTotal) {
 191   NS_ENSURE_ARG_POINTER(aTotal);
 192   MOZ_ASSERT(mTotal);
 193   nsCOMPtr<nsIPaymentItem> total = mTotal;
 194   total.forget(aTotal);
 195   return NS_OK;
 196 }
 197
 198 NS_IMETHODIMP
 199 PaymentDetailsModifier::GetAdditionalDisplayItems(
 200     nsIArray** aAdditionalDisplayItems) {
 201   NS_ENSURE_ARG_POINTER(aAdditionalDisplayItems);
 202   nsCOMPtr<nsIArray> additionalItems = mAdditionalDisplayItems;
 203   additionalItems.forget(aAdditionalDisplayItems);
 204   return NS_OK;
 205 }
 206
 207 NS_IMETHODIMP
 208 PaymentDetailsModifier::GetData(JSContext* aCx,
 209                                 JS::MutableHandle<JS::Value> aData) {
 210   if (mData.IsEmpty()) {
 211     aData.set(JS::NullValue());
 212     return NS_OK;
 213   }
 214   nsresult rv = DeserializeToJSValue(mData, aCx, aData);
 215   if (NS_WARN_IF(NS_FAILED(rv))) {
 216     return rv;
 217   }
 218   return NS_OK;
 219 }
 220
 221 /* PaymentShippingOption */
 222
 223 NS_IMPL_ISUPPORTS(PaymentShippingOption, nsIPaymentShippingOption)
 224
 225 PaymentShippingOption::PaymentShippingOption(const nsAString& aId,
 226                                              const nsAString& aLabel,
 227                                              nsIPaymentCurrencyAmount* aAmount,
 228                                              const bool aSelected)
 229     : mId(aId), mLabel(aLabel), mAmount(aAmount), mSelected(aSelected) {}
 230
 231 nsresult PaymentShippingOption::Create(
 232     const IPCPaymentShippingOption& aIPCOption,
 233     nsIPaymentShippingOption** aOption) {
 234   NS_ENSURE_ARG_POINTER(aOption);
 235   nsCOMPtr<nsIPaymentCurrencyAmount> amount;
 236   nsresult rv = PaymentCurrencyAmount::Create(aIPCOption.amount(),
 237                                               getter_AddRefs(amount));
 238   if (NS_WARN_IF(NS_FAILED(rv))) {
 239     return rv;
 240   }
 241   nsCOMPtr<nsIPaymentShippingOption> option = new PaymentShippingOption(
 242       aIPCOption.id(), aIPCOption.label(), amount, aIPCOption.selected());
 243   option.forget(aOption);
 244   return NS_OK;
 245 }
 246
 247 NS_IMETHODIMP
 248 PaymentShippingOption::GetId(nsAString& aId) {
 249   aId = mId;
 250   return NS_OK;
 251 }
 252
 253 NS_IMETHODIMP
 254 PaymentShippingOption::GetLabel(nsAString& aLabel) {
 255   aLabel = mLabel;
 256   return NS_OK;
 257 }
 258
 259 NS_IMETHODIMP
 260 PaymentShippingOption::GetAmount(nsIPaymentCurrencyAmount** aAmount) {
 261   NS_ENSURE_ARG_POINTER(aAmount);
 262   MOZ_ASSERT(mAmount);
 263   nsCOMPtr<nsIPaymentCurrencyAmount> amount = mAmount;
 264   amount.forget(aAmount);
 265   return NS_OK;
 266 }
 267
 268 NS_IMETHODIMP
 269 PaymentShippingOption::GetSelected(bool* aSelected) {
 270   NS_ENSURE_ARG_POINTER(aSelected);
 271   *aSelected = mSelected;
 272   return NS_OK;
 273 }
 274
 275 NS_IMETHODIMP
 276 PaymentShippingOption::SetSelected(bool aSelected) {
 277   mSelected = aSelected;
 278   return NS_OK;
 279 }
 280
 281 /* PaymentDetails */
 282
 283 NS_IMPL_ISUPPORTS(PaymentDetails, nsIPaymentDetails)
 284
 285 PaymentDetails::PaymentDetails(const nsAString& aId, nsIPaymentItem* aTotalItem,
 286                                nsIArray* aDisplayItems,
 287                                nsIArray* aShippingOptions, nsIArray* aModifiers,
 288                                const nsAString& aError,
 289                                const nsAString& aShippingAddressErrors,
 290                                const nsAString& aPayerErrors,
 291                                const nsAString& aPaymentMethodErrors)
 292     : mId(aId),
 293       mTotalItem(aTotalItem),
 294       mDisplayItems(aDisplayItems),
 295       mShippingOptions(aShippingOptions),
 296       mModifiers(aModifiers),
 297       mError(aError),
 298       mShippingAddressErrors(aShippingAddressErrors),
 299       mPayerErrors(aPayerErrors),
 300       mPaymentMethodErrors(aPaymentMethodErrors) {}
 301
 302 nsresult PaymentDetails::Create(const IPCPaymentDetails& aIPCDetails,
 303                                 nsIPaymentDetails** aDetails) {
 304   NS_ENSURE_ARG_POINTER(aDetails);
 305
 306   nsCOMPtr<nsIPaymentItem> total;
 307   nsresult rv = PaymentItem::Create(aIPCDetails.total(), getter_AddRefs(total));
 308   if (NS_WARN_IF(NS_FAILED(rv))) {
 309     return rv;
 310   }
 311
 312   nsCOMPtr<nsIArray> displayItems;
 313   nsCOMPtr<nsIMutableArray> items = do_CreateInstance(NS_ARRAY_CONTRACTID);
 314   MOZ_ASSERT(items);
 315   for (const IPCPaymentItem& displayItem : aIPCDetails.displayItems()) {
 316     nsCOMPtr<nsIPaymentItem> item;
 317     rv = PaymentItem::Create(displayItem, getter_AddRefs(item));
 318     if (NS_WARN_IF(NS_FAILED(rv))) {
 319       return rv;
 320     }
 321     rv = items->AppendElement(item);
 322     if (NS_WARN_IF(NS_FAILED(rv))) {
 323       return rv;
 324     }
 325   }
 326   displayItems = std::move(items);
 327
 328   nsCOMPtr<nsIArray> shippingOptions;
 329   nsCOMPtr<nsIMutableArray> options = do_CreateInstance(NS_ARRAY_CONTRACTID);
 330   MOZ_ASSERT(options);
 331   for (const IPCPaymentShippingOption& shippingOption :
 332        aIPCDetails.shippingOptions()) {
 333     nsCOMPtr<nsIPaymentShippingOption> option;
 334     rv = PaymentShippingOption::Create(shippingOption, getter_AddRefs(option));
 335     if (NS_WARN_IF(NS_FAILED(rv))) {
 336       return rv;
 337     }
 338     rv = options->AppendElement(option);
 339     if (NS_WARN_IF(NS_FAILED(rv))) {
 340       return rv;
 341     }
 342   }
 343   shippingOptions = std::move(options);
 344
 345   nsCOMPtr<nsIArray> modifiers;
 346   nsCOMPtr<nsIMutableArray> detailsModifiers =
 347       do_CreateInstance(NS_ARRAY_CONTRACTID);
 348   MOZ_ASSERT(detailsModifiers);
 349   for (const IPCPaymentDetailsModifier& modifier : aIPCDetails.modifiers()) {
 350     nsCOMPtr<nsIPaymentDetailsModifier> detailsModifier;
 351     rv = PaymentDetailsModifier::Create(modifier,
 352                                         getter_AddRefs(detailsModifier));
 353     if (NS_WARN_IF(NS_FAILED(rv))) {
 354       return rv;
 355     }
 356     rv = detailsModifiers->AppendElement(detailsModifier);
 357     if (NS_WARN_IF(NS_FAILED(rv))) {
 358       return rv;
 359     }
 360   }
 361   modifiers = std::move(detailsModifiers);
 362
 363   nsCOMPtr<nsIPaymentDetails> details = new PaymentDetails(
 364       aIPCDetails.id(), total, displayItems, shippingOptions, modifiers,
 365       aIPCDetails.error(), aIPCDetails.shippingAddressErrors(),
 366       aIPCDetails.payerErrors(), aIPCDetails.paymentMethodErrors());
 367
 368   details.forget(aDetails);
 369   return NS_OK;
 370 }
 371
 372 NS_IMETHODIMP
 373 PaymentDetails::GetId(nsAString& aId) {
 374   aId = mId;
 375   return NS_OK;
 376 }
 377
 378 NS_IMETHODIMP
 379 PaymentDetails::GetTotalItem(nsIPaymentItem** aTotalItem) {
 380   NS_ENSURE_ARG_POINTER(aTotalItem);
 381   MOZ_ASSERT(mTotalItem);
 382   nsCOMPtr<nsIPaymentItem> total = mTotalItem;
 383   total.forget(aTotalItem);
 384   return NS_OK;
 385 }
 386
 387 NS_IMETHODIMP
 388 PaymentDetails::GetDisplayItems(nsIArray** aDisplayItems) {
 389   NS_ENSURE_ARG_POINTER(aDisplayItems);
 390   nsCOMPtr<nsIArray> displayItems = mDisplayItems;
 391   displayItems.forget(aDisplayItems);
 392   return NS_OK;
 393 }
 394
 395 NS_IMETHODIMP
 396 PaymentDetails::GetShippingOptions(nsIArray** aShippingOptions) {
 397   NS_ENSURE_ARG_POINTER(aShippingOptions);
 398   nsCOMPtr<nsIArray> options = mShippingOptions;
 399   options.forget(aShippingOptions);
 400   return NS_OK;
 401 }
 402
 403 NS_IMETHODIMP
 404 PaymentDetails::GetModifiers(nsIArray** aModifiers) {
 405   NS_ENSURE_ARG_POINTER(aModifiers);
 406   nsCOMPtr<nsIArray> modifiers = mModifiers;
 407   modifiers.forget(aModifiers);
 408   return NS_OK;
 409 }
 410
 411 NS_IMETHODIMP
 412 PaymentDetails::GetError(nsAString& aError) {
 413   aError = mError;
 414   return NS_OK;
 415 }
 416
 417 NS_IMETHODIMP
 418 PaymentDetails::GetShippingAddressErrors(JSContext* aCx,
 419                                          JS::MutableHandle<JS::Value> aErrors) {
 420   AddressErrors errors;
 421   errors.Init(mShippingAddressErrors);
 422   if (!ToJSValue(aCx, errors, aErrors)) {
 423     return NS_ERROR_FAILURE;
 424   }
 425   return NS_OK;
 426 }
 427
 428 NS_IMETHODIMP
 429 PaymentDetails::GetPayerErrors(JSContext* aCx,
 430                                JS::MutableHandle<JS::Value> aErrors) {
 431   PayerErrors errors;
 432   errors.Init(mPayerErrors);
 433   if (!ToJSValue(aCx, errors, aErrors)) {
 434     return NS_ERROR_FAILURE;
 435   }
 436   return NS_OK;
 437 }
 438
 439 NS_IMETHODIMP
 440 PaymentDetails::GetPaymentMethodErrors(JSContext* aCx,
 441                                        JS::MutableHandle<JS::Value> aErrors) {
 442   if (mPaymentMethodErrors.IsEmpty()) {
 443     aErrors.set(JS::NullValue());
 444     return NS_OK;
 445   }
 446   nsresult rv = DeserializeToJSValue(mPaymentMethodErrors, aCx, aErrors);
 447   if (NS_WARN_IF(NS_FAILED(rv))) {
 448     return rv;
 449   }
 450   return NS_OK;
 451 }
 452
 453 nsresult PaymentDetails::Update(nsIPaymentDetails* aDetails,
 454                                 const bool aRequestShipping) {
 455   MOZ_ASSERT(aDetails);
 456   /*
 457    * According to the spec [1], update the attributes if they present in new
 458    * details (i.e., PaymentDetailsUpdate); otherwise, keep original value.
 459    * Note |id| comes only from initial details (i.e., PaymentDetailsInit) and
 460    * |error| only from new details.
 461    *
 462    *   [1] https://www.w3.org/TR/payment-request/#updatewith-method
 463    */
 464
 465   nsresult rv = aDetails->GetTotalItem(getter_AddRefs(mTotalItem));
 466   if (NS_WARN_IF(NS_FAILED(rv))) {
 467     return rv;
 468   }
 469
 470   nsCOMPtr<nsIArray> displayItems;
 471   rv = aDetails->GetDisplayItems(getter_AddRefs(displayItems));
 472   if (NS_WARN_IF(NS_FAILED(rv))) {
 473     return rv;
 474   }
 475   if (displayItems) {
 476     mDisplayItems = displayItems;
 477   }
 478
 479   if (aRequestShipping) {
 480     nsCOMPtr<nsIArray> shippingOptions;
 481     rv = aDetails->GetShippingOptions(getter_AddRefs(shippingOptions));
 482     if (NS_WARN_IF(NS_FAILED(rv))) {
 483       return rv;
 484     }
 485     mShippingOptions = shippingOptions;
 486   }
 487
 488   nsCOMPtr<nsIArray> modifiers;
 489   rv = aDetails->GetModifiers(getter_AddRefs(modifiers));
 490   if (NS_WARN_IF(NS_FAILED(rv))) {
 491     return rv;
 492   }
 493   if (modifiers) {
 494     mModifiers = modifiers;
 495   }
 496
 497   rv = aDetails->GetError(mError);
 498   if (NS_WARN_IF(NS_FAILED(rv))) {
 499     return rv;
 500   }
 501
 502   PaymentDetails* rowDetails = static_cast<PaymentDetails*>(aDetails);
 503   MOZ_ASSERT(rowDetails);
 504   mShippingAddressErrors = rowDetails->GetShippingAddressErrors();
 505   mPayerErrors = rowDetails->GetPayerErrors();
 506   mPaymentMethodErrors = rowDetails->GetPaymentMethodErrors();
 507
 508   return NS_OK;
 509 }
 510
 511 const nsString& PaymentDetails::GetShippingAddressErrors() const {
 512   return mShippingAddressErrors;
 513 }
 514
 515 const nsString& PaymentDetails::GetPayerErrors() const { return mPayerErrors; }
 516
 517 const nsString& PaymentDetails::GetPaymentMethodErrors() const {
 518   return mPaymentMethodErrors;
 519 }
 520
 521 nsresult PaymentDetails::UpdateErrors(const nsAString& aError,
 522                                       const nsAString& aPayerErrors,
 523                                       const nsAString& aPaymentMethodErrors,
 524                                       const nsAString& aShippingAddressErrors) {
 525   mError = aError;
 526   mPayerErrors = aPayerErrors;
 527   mPaymentMethodErrors = aPaymentMethodErrors;
 528   mShippingAddressErrors = aShippingAddressErrors;
 529   return NS_OK;
 530 }
 531
 532 /* PaymentOptions */
 533
 534 NS_IMPL_ISUPPORTS(PaymentOptions, nsIPaymentOptions)
 535
 536 PaymentOptions::PaymentOptions(const bool aRequestPayerName,
 537                                const bool aRequestPayerEmail,
 538                                const bool aRequestPayerPhone,
 539                                const bool aRequestShipping,
 540                                const bool aRequestBillingAddress,
 541                                const nsAString& aShippingType)
 542     : mRequestPayerName(aRequestPayerName),
 543       mRequestPayerEmail(aRequestPayerEmail),
 544       mRequestPayerPhone(aRequestPayerPhone),
 545       mRequestShipping(aRequestShipping),
 546       mRequestBillingAddress(aRequestBillingAddress),
 547       mShippingType(aShippingType) {}
 548
 549 nsresult PaymentOptions::Create(const IPCPaymentOptions& aIPCOptions,
 550                                 nsIPaymentOptions** aOptions) {
 551   NS_ENSURE_ARG_POINTER(aOptions);
 552
 553   nsCOMPtr<nsIPaymentOptions> options = new PaymentOptions(
 554       aIPCOptions.requestPayerName(), aIPCOptions.requestPayerEmail(),
 555       aIPCOptions.requestPayerPhone(), aIPCOptions.requestShipping(),
 556       aIPCOptions.requestBillingAddress(), aIPCOptions.shippingType());
 557   options.forget(aOptions);
 558   return NS_OK;
 559 }
 560
 561 NS_IMETHODIMP
 562 PaymentOptions::GetRequestPayerName(bool* aRequestPayerName) {
 563   NS_ENSURE_ARG_POINTER(aRequestPayerName);
 564   *aRequestPayerName = mRequestPayerName;
 565   return NS_OK;
 566 }
 567
 568 NS_IMETHODIMP
 569 PaymentOptions::GetRequestPayerEmail(bool* aRequestPayerEmail) {
 570   NS_ENSURE_ARG_POINTER(aRequestPayerEmail);
 571   *aRequestPayerEmail = mRequestPayerEmail;
 572   return NS_OK;
 573 }
 574
 575 NS_IMETHODIMP
 576 PaymentOptions::GetRequestPayerPhone(bool* aRequestPayerPhone) {
 577   NS_ENSURE_ARG_POINTER(aRequestPayerPhone);
 578   *aRequestPayerPhone = mRequestPayerPhone;
 579   return NS_OK;
 580 }
 581
 582 NS_IMETHODIMP
 583 PaymentOptions::GetRequestShipping(bool* aRequestShipping) {
 584   NS_ENSURE_ARG_POINTER(aRequestShipping);
 585   *aRequestShipping = mRequestShipping;
 586   return NS_OK;
 587 }
 588
 589 NS_IMETHODIMP
 590 PaymentOptions::GetRequestBillingAddress(bool* aRequestBillingAddress) {
 591   NS_ENSURE_ARG_POINTER(aRequestBillingAddress);
 592   *aRequestBillingAddress = mRequestBillingAddress;
 593   return NS_OK;
 594 }
 595
 596 NS_IMETHODIMP
 597 PaymentOptions::GetShippingType(nsAString& aShippingType) {
 598   aShippingType = mShippingType;
 599   return NS_OK;
 600 }
 601
 602 /* PaymentReqeust */
 603
 604 NS_IMPL_ISUPPORTS(PaymentRequest, nsIPaymentRequest)
 605
 606 PaymentRequest::PaymentRequest(const uint64_t aTopOuterWindowId,
 607                                const nsAString& aRequestId,
 608                                nsIPrincipal* aTopLevelPrincipal,
 609                                nsIArray* aPaymentMethods,
 610                                nsIPaymentDetails* aPaymentDetails,
 611                                nsIPaymentOptions* aPaymentOptions,
 612                                const nsAString& aShippingOption)
 613     : mTopOuterWindowId(aTopOuterWindowId),
 614       mRequestId(aRequestId),
 615       mTopLevelPrincipal(aTopLevelPrincipal),
 616       mPaymentMethods(aPaymentMethods),
 617       mPaymentDetails(aPaymentDetails),
 618       mPaymentOptions(aPaymentOptions),
 619       mShippingOption(aShippingOption),
 620       mState(eCreated) {}
 621
 622 NS_IMETHODIMP
 623 PaymentRequest::GetTopOuterWindowId(uint64_t* aTopOuterWindowId) {
 624   NS_ENSURE_ARG_POINTER(aTopOuterWindowId);
 625   *aTopOuterWindowId = mTopOuterWindowId;
 626   return NS_OK;
 627 }
 628
 629 NS_IMETHODIMP
 630 PaymentRequest::GetTopLevelPrincipal(nsIPrincipal** aTopLevelPrincipal) {
 631   NS_ENSURE_ARG_POINTER(aTopLevelPrincipal);
 632   MOZ_ASSERT(mTopLevelPrincipal);
 633   nsCOMPtr<nsIPrincipal> principal = mTopLevelPrincipal;
 634   principal.forget(aTopLevelPrincipal);
 635   return NS_OK;
 636 }
 637
 638 NS_IMETHODIMP
 639 PaymentRequest::GetRequestId(nsAString& aRequestId) {
 640   aRequestId = mRequestId;
 641   return NS_OK;
 642 }
 643
 644 NS_IMETHODIMP
 645 PaymentRequest::GetPaymentMethods(nsIArray** aPaymentMethods) {
 646   NS_ENSURE_ARG_POINTER(aPaymentMethods);
 647   MOZ_ASSERT(mPaymentMethods);
 648   nsCOMPtr<nsIArray> methods = mPaymentMethods;
 649   methods.forget(aPaymentMethods);
 650   return NS_OK;
 651 }
 652
 653 NS_IMETHODIMP
 654 PaymentRequest::GetPaymentDetails(nsIPaymentDetails** aPaymentDetails) {
 655   NS_ENSURE_ARG_POINTER(aPaymentDetails);
 656   MOZ_ASSERT(mPaymentDetails);
 657   nsCOMPtr<nsIPaymentDetails> details = mPaymentDetails;
 658   details.forget(aPaymentDetails);
 659   return NS_OK;
 660 }
 661
 662 NS_IMETHODIMP
 663 PaymentRequest::GetPaymentOptions(nsIPaymentOptions** aPaymentOptions) {
 664   NS_ENSURE_ARG_POINTER(aPaymentOptions);
 665   MOZ_ASSERT(mPaymentOptions);
 666   nsCOMPtr<nsIPaymentOptions> options = mPaymentOptions;
 667   options.forget(aPaymentOptions);
 668   return NS_OK;
 669 }
 670
 671 NS_IMETHODIMP
 672 PaymentRequest::GetShippingOption(nsAString& aShippingOption) {
 673   aShippingOption = mShippingOption;
 674   return NS_OK;
 675 }
 676
 677 nsresult PaymentRequest::UpdatePaymentDetails(
 678     nsIPaymentDetails* aPaymentDetails, const nsAString& aShippingOption) {
 679   MOZ_ASSERT(aPaymentDetails);
 680   bool requestShipping;
 681   nsresult rv = mPaymentOptions->GetRequestShipping(&requestShipping);
 682   if (NS_WARN_IF(NS_FAILED(rv))) {
 683     return rv;
 684   }
 685   mShippingOption = aShippingOption;
 686
 687   PaymentDetails* rowDetails =
 688       static_cast<PaymentDetails*>(mPaymentDetails.get());
 689   MOZ_ASSERT(rowDetails);
 690   return rowDetails->Update(aPaymentDetails, requestShipping);
 691 }
 692
 693 void PaymentRequest::SetCompleteStatus(const nsAString& aCompleteStatus) {
 694   mCompleteStatus = aCompleteStatus;
 695 }
 696
 697 nsresult PaymentRequest::UpdateErrors(const nsAString& aError,
 698                                       const nsAString& aPayerErrors,
 699                                       const nsAString& aPaymentMethodErrors,
 700                                       const nsAString& aShippingAddressErrors) {
 701   PaymentDetails* rowDetails =
 702       static_cast<PaymentDetails*>(mPaymentDetails.get());
 703   MOZ_ASSERT(rowDetails);
 704   return rowDetails->UpdateErrors(aError, aPayerErrors, aPaymentMethodErrors,
 705                                   aShippingAddressErrors);
 706 }
 707
 708 NS_IMETHODIMP
 709 PaymentRequest::GetCompleteStatus(nsAString& aCompleteStatus) {
 710   aCompleteStatus = mCompleteStatus;
 711   return NS_OK;
 712 }
 713
 714 /* PaymentAddress */
 715
 716 NS_IMPL_ISUPPORTS(PaymentAddress, nsIPaymentAddress)
 717
 718 NS_IMETHODIMP
 719 PaymentAddress::Init(const nsAString& aCountry, nsIArray* aAddressLine,
 720                      const nsAString& aRegion, const nsAString& aRegionCode,
 721                      const nsAString& aCity,
 722                      const nsAString& aDependentLocality,
 723                      const nsAString& aPostalCode,
 724                      const nsAString& aSortingCode,
 725                      const nsAString& aOrganization,
 726                      const nsAString& aRecipient, const nsAString& aPhone) {
 727   mCountry = aCountry;
 728   mAddressLine = aAddressLine;
 729   mRegion = aRegion;
 730   mRegionCode = aRegionCode;
 731   mCity = aCity;
 732   mDependentLocality = aDependentLocality;
 733   mPostalCode = aPostalCode;
 734   mSortingCode = aSortingCode;
 735   mOrganization = aOrganization;
 736   mRecipient = aRecipient;
 737   mPhone = aPhone;
 738   return NS_OK;
 739 }
 740
 741 NS_IMETHODIMP
 742 PaymentAddress::GetCountry(nsAString& aCountry) {
 743   aCountry = mCountry;
 744   return NS_OK;
 745 }
 746
 747 NS_IMETHODIMP
 748 PaymentAddress::GetAddressLine(nsIArray** aAddressLine) {
 749   NS_ENSURE_ARG_POINTER(aAddressLine);
 750   nsCOMPtr<nsIArray> addressLine = mAddressLine;
 751   addressLine.forget(aAddressLine);
 752   return NS_OK;
 753 }
 754
 755 NS_IMETHODIMP
 756 PaymentAddress::GetRegion(nsAString& aRegion) {
 757   aRegion = mRegion;
 758   return NS_OK;
 759 }
 760
 761 NS_IMETHODIMP
 762 PaymentAddress::GetRegionCode(nsAString& aRegionCode) {
 763   aRegionCode = mRegionCode;
 764   return NS_OK;
 765 }
 766
 767 NS_IMETHODIMP
 768 PaymentAddress::GetCity(nsAString& aCity) {
 769   aCity = mCity;
 770   return NS_OK;
 771 }
 772
 773 NS_IMETHODIMP
 774 PaymentAddress::GetDependentLocality(nsAString& aDependentLocality) {
 775   aDependentLocality = mDependentLocality;
 776   return NS_OK;
 777 }
 778
 779 NS_IMETHODIMP
 780 PaymentAddress::GetPostalCode(nsAString& aPostalCode) {
 781   aPostalCode = mPostalCode;
 782   return NS_OK;
 783 }
 784
 785 NS_IMETHODIMP
 786 PaymentAddress::GetSortingCode(nsAString& aSortingCode) {
 787   aSortingCode = mSortingCode;
 788   return NS_OK;
 789 }
 790
 791 NS_IMETHODIMP
 792 PaymentAddress::GetOrganization(nsAString& aOrganization) {
 793   aOrganization = mOrganization;
 794   return NS_OK;
 795 }
 796
 797 NS_IMETHODIMP
 798 PaymentAddress::GetRecipient(nsAString& aRecipient) {
 799   aRecipient = mRecipient;
 800   return NS_OK;
 801 }
 802
 803 NS_IMETHODIMP
 804 PaymentAddress::GetPhone(nsAString& aPhone) {
 805   aPhone = mPhone;
 806   return NS_OK;
 807 }
 808
 809 }  // namespace mozilla::dom::payments