Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 809 insertions, 0 deletions

diff --git a/dom/payments/PaymentRequestData.cpp b/dom/payments/PaymentRequestData.cpp
new file mode 100644
index 0000000000..4bf3699f2e
--- /dev/null
+++ b/dom/payments/PaymentRequestData.cpp
@@ -0,0 +1,809 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/PaymentRequestBinding.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "nsArrayUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIMutableArray.h"
+#include "nsUnicharUtils.h"
+#include "PaymentRequestData.h"
+#include "PaymentRequestUtils.h"
+
+namespace mozilla::dom::payments {
+
+/* PaymentMethodData */
+
+NS_IMPL_ISUPPORTS(PaymentMethodData, nsIPaymentMethodData)
+
+PaymentMethodData::PaymentMethodData(const nsAString& aSupportedMethods,
+                                     const nsAString& aData)
+    : mSupportedMethods(aSupportedMethods), mData(aData) {}
+
+nsresult PaymentMethodData::Create(const IPCPaymentMethodData& aIPCMethodData,
+                                   nsIPaymentMethodData** aMethodData) {
+  NS_ENSURE_ARG_POINTER(aMethodData);
+  nsCOMPtr<nsIPaymentMethodData> methodData = new PaymentMethodData(
+      aIPCMethodData.supportedMethods(), aIPCMethodData.data());
+  methodData.forget(aMethodData);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentMethodData::GetSupportedMethods(nsAString& aSupportedMethods) {
+  aSupportedMethods = mSupportedMethods;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentMethodData::GetData(JSContext* aCx, JS::MutableHandle<JS::Value> aData) {
+  if (mData.IsEmpty()) {
+    aData.set(JS::NullValue());
+    return NS_OK;
+  }
+  nsresult rv = DeserializeToJSValue(mData, aCx, aData);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  return NS_OK;
+}
+
+/* PaymentCurrencyAmount */
+
+NS_IMPL_ISUPPORTS(PaymentCurrencyAmount, nsIPaymentCurrencyAmount)
+
+PaymentCurrencyAmount::PaymentCurrencyAmount(const nsAString& aCurrency,
+                                             const nsAString& aValue)
+    : mValue(aValue) {
+  /*
+   *  According to the spec
+   *  https://w3c.github.io/payment-request/#validity-checkers
+   *  Set amount.currency to the result of ASCII uppercasing amount.currency.
+   */
+  ToUpperCase(aCurrency, mCurrency);
+}
+
+nsresult PaymentCurrencyAmount::Create(
+    const IPCPaymentCurrencyAmount& aIPCAmount,
+    nsIPaymentCurrencyAmount** aAmount) {
+  NS_ENSURE_ARG_POINTER(aAmount);
+  nsCOMPtr<nsIPaymentCurrencyAmount> amount =
+      new PaymentCurrencyAmount(aIPCAmount.currency(), aIPCAmount.value());
+  amount.forget(aAmount);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentCurrencyAmount::GetCurrency(nsAString& aCurrency) {
+  aCurrency = mCurrency;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentCurrencyAmount::GetValue(nsAString& aValue) {
+  aValue = mValue;
+  return NS_OK;
+}
+
+/* PaymentItem */
+
+NS_IMPL_ISUPPORTS(PaymentItem, nsIPaymentItem)
+
+PaymentItem::PaymentItem(const nsAString& aLabel,
+                         nsIPaymentCurrencyAmount* aAmount, const bool aPending)
+    : mLabel(aLabel), mAmount(aAmount), mPending(aPending) {}
+
+nsresult PaymentItem::Create(const IPCPaymentItem& aIPCItem,
+                             nsIPaymentItem** aItem) {
+  NS_ENSURE_ARG_POINTER(aItem);
+  nsCOMPtr<nsIPaymentCurrencyAmount> amount;
+  nsresult rv =
+      PaymentCurrencyAmount::Create(aIPCItem.amount(), getter_AddRefs(amount));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  nsCOMPtr<nsIPaymentItem> item =
+      new PaymentItem(aIPCItem.label(), amount, aIPCItem.pending());
+  item.forget(aItem);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentItem::GetLabel(nsAString& aLabel) {
+  aLabel = mLabel;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentItem::GetAmount(nsIPaymentCurrencyAmount** aAmount) {
+  NS_ENSURE_ARG_POINTER(aAmount);
+  MOZ_ASSERT(mAmount);
+  nsCOMPtr<nsIPaymentCurrencyAmount> amount = mAmount;
+  amount.forget(aAmount);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentItem::GetPending(bool* aPending) {
+  NS_ENSURE_ARG_POINTER(aPending);
+  *aPending = mPending;
+  return NS_OK;
+}
+
+/* PaymentDetailsModifier */
+
+NS_IMPL_ISUPPORTS(PaymentDetailsModifier, nsIPaymentDetailsModifier)
+
+PaymentDetailsModifier::PaymentDetailsModifier(
+    const nsAString& aSupportedMethods, nsIPaymentItem* aTotal,
+    nsIArray* aAdditionalDisplayItems, const nsAString& aData)
+    : mSupportedMethods(aSupportedMethods),
+      mTotal(aTotal),
+      mAdditionalDisplayItems(aAdditionalDisplayItems),
+      mData(aData) {}
+
+nsresult PaymentDetailsModifier::Create(
+    const IPCPaymentDetailsModifier& aIPCModifier,
+    nsIPaymentDetailsModifier** aModifier) {
+  NS_ENSURE_ARG_POINTER(aModifier);
+  nsCOMPtr<nsIPaymentItem> total;
+  nsresult rv =
+      PaymentItem::Create(aIPCModifier.total(), getter_AddRefs(total));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIArray> displayItems;
+  if (aIPCModifier.additionalDisplayItemsPassed()) {
+    nsCOMPtr<nsIMutableArray> items = do_CreateInstance(NS_ARRAY_CONTRACTID);
+    MOZ_ASSERT(items);
+    for (const IPCPaymentItem& item : aIPCModifier.additionalDisplayItems()) {
+      nsCOMPtr<nsIPaymentItem> additionalItem;
+      rv = PaymentItem::Create(item, getter_AddRefs(additionalItem));
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+      rv = items->AppendElement(additionalItem);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+    }
+    displayItems = std::move(items);
+  }
+  nsCOMPtr<nsIPaymentDetailsModifier> modifier =
+      new PaymentDetailsModifier(aIPCModifier.supportedMethods(), total,
+                                 displayItems, aIPCModifier.data());
+  modifier.forget(aModifier);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetailsModifier::GetSupportedMethods(nsAString& aSupportedMethods) {
+  aSupportedMethods = mSupportedMethods;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetailsModifier::GetTotal(nsIPaymentItem** aTotal) {
+  NS_ENSURE_ARG_POINTER(aTotal);
+  MOZ_ASSERT(mTotal);
+  nsCOMPtr<nsIPaymentItem> total = mTotal;
+  total.forget(aTotal);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetailsModifier::GetAdditionalDisplayItems(
+    nsIArray** aAdditionalDisplayItems) {
+  NS_ENSURE_ARG_POINTER(aAdditionalDisplayItems);
+  nsCOMPtr<nsIArray> additionalItems = mAdditionalDisplayItems;
+  additionalItems.forget(aAdditionalDisplayItems);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetailsModifier::GetData(JSContext* aCx,
+                                JS::MutableHandle<JS::Value> aData) {
+  if (mData.IsEmpty()) {
+    aData.set(JS::NullValue());
+    return NS_OK;
+  }
+  nsresult rv = DeserializeToJSValue(mData, aCx, aData);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  return NS_OK;
+}
+
+/* PaymentShippingOption */
+
+NS_IMPL_ISUPPORTS(PaymentShippingOption, nsIPaymentShippingOption)
+
+PaymentShippingOption::PaymentShippingOption(const nsAString& aId,
+                                             const nsAString& aLabel,
+                                             nsIPaymentCurrencyAmount* aAmount,
+                                             const bool aSelected)
+    : mId(aId), mLabel(aLabel), mAmount(aAmount), mSelected(aSelected) {}
+
+nsresult PaymentShippingOption::Create(
+    const IPCPaymentShippingOption& aIPCOption,
+    nsIPaymentShippingOption** aOption) {
+  NS_ENSURE_ARG_POINTER(aOption);
+  nsCOMPtr<nsIPaymentCurrencyAmount> amount;
+  nsresult rv = PaymentCurrencyAmount::Create(aIPCOption.amount(),
+                                              getter_AddRefs(amount));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  nsCOMPtr<nsIPaymentShippingOption> option = new PaymentShippingOption(
+      aIPCOption.id(), aIPCOption.label(), amount, aIPCOption.selected());
+  option.forget(aOption);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentShippingOption::GetId(nsAString& aId) {
+  aId = mId;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentShippingOption::GetLabel(nsAString& aLabel) {
+  aLabel = mLabel;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentShippingOption::GetAmount(nsIPaymentCurrencyAmount** aAmount) {
+  NS_ENSURE_ARG_POINTER(aAmount);
+  MOZ_ASSERT(mAmount);
+  nsCOMPtr<nsIPaymentCurrencyAmount> amount = mAmount;
+  amount.forget(aAmount);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentShippingOption::GetSelected(bool* aSelected) {
+  NS_ENSURE_ARG_POINTER(aSelected);
+  *aSelected = mSelected;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentShippingOption::SetSelected(bool aSelected) {
+  mSelected = aSelected;
+  return NS_OK;
+}
+
+/* PaymentDetails */
+
+NS_IMPL_ISUPPORTS(PaymentDetails, nsIPaymentDetails)
+
+PaymentDetails::PaymentDetails(const nsAString& aId, nsIPaymentItem* aTotalItem,
+                               nsIArray* aDisplayItems,
+                               nsIArray* aShippingOptions, nsIArray* aModifiers,
+                               const nsAString& aError,
+                               const nsAString& aShippingAddressErrors,
+                               const nsAString& aPayerErrors,
+                               const nsAString& aPaymentMethodErrors)
+    : mId(aId),
+      mTotalItem(aTotalItem),
+      mDisplayItems(aDisplayItems),
+      mShippingOptions(aShippingOptions),
+      mModifiers(aModifiers),
+      mError(aError),
+      mShippingAddressErrors(aShippingAddressErrors),
+      mPayerErrors(aPayerErrors),
+      mPaymentMethodErrors(aPaymentMethodErrors) {}
+
+nsresult PaymentDetails::Create(const IPCPaymentDetails& aIPCDetails,
+                                nsIPaymentDetails** aDetails) {
+  NS_ENSURE_ARG_POINTER(aDetails);
+
+  nsCOMPtr<nsIPaymentItem> total;
+  nsresult rv = PaymentItem::Create(aIPCDetails.total(), getter_AddRefs(total));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIArray> displayItems;
+  nsCOMPtr<nsIMutableArray> items = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  MOZ_ASSERT(items);
+  for (const IPCPaymentItem& displayItem : aIPCDetails.displayItems()) {
+    nsCOMPtr<nsIPaymentItem> item;
+    rv = PaymentItem::Create(displayItem, getter_AddRefs(item));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+    rv = items->AppendElement(item);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+  displayItems = std::move(items);
+
+  nsCOMPtr<nsIArray> shippingOptions;
+  nsCOMPtr<nsIMutableArray> options = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  MOZ_ASSERT(options);
+  for (const IPCPaymentShippingOption& shippingOption :
+       aIPCDetails.shippingOptions()) {
+    nsCOMPtr<nsIPaymentShippingOption> option;
+    rv = PaymentShippingOption::Create(shippingOption, getter_AddRefs(option));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+    rv = options->AppendElement(option);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+  shippingOptions = std::move(options);
+
+  nsCOMPtr<nsIArray> modifiers;
+  nsCOMPtr<nsIMutableArray> detailsModifiers =
+      do_CreateInstance(NS_ARRAY_CONTRACTID);
+  MOZ_ASSERT(detailsModifiers);
+  for (const IPCPaymentDetailsModifier& modifier : aIPCDetails.modifiers()) {
+    nsCOMPtr<nsIPaymentDetailsModifier> detailsModifier;
+    rv = PaymentDetailsModifier::Create(modifier,
+                                        getter_AddRefs(detailsModifier));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+    rv = detailsModifiers->AppendElement(detailsModifier);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+  modifiers = std::move(detailsModifiers);
+
+  nsCOMPtr<nsIPaymentDetails> details = new PaymentDetails(
+      aIPCDetails.id(), total, displayItems, shippingOptions, modifiers,
+      aIPCDetails.error(), aIPCDetails.shippingAddressErrors(),
+      aIPCDetails.payerErrors(), aIPCDetails.paymentMethodErrors());
+
+  details.forget(aDetails);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetails::GetId(nsAString& aId) {
+  aId = mId;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetails::GetTotalItem(nsIPaymentItem** aTotalItem) {
+  NS_ENSURE_ARG_POINTER(aTotalItem);
+  MOZ_ASSERT(mTotalItem);
+  nsCOMPtr<nsIPaymentItem> total = mTotalItem;
+  total.forget(aTotalItem);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetails::GetDisplayItems(nsIArray** aDisplayItems) {
+  NS_ENSURE_ARG_POINTER(aDisplayItems);
+  nsCOMPtr<nsIArray> displayItems = mDisplayItems;
+  displayItems.forget(aDisplayItems);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetails::GetShippingOptions(nsIArray** aShippingOptions) {
+  NS_ENSURE_ARG_POINTER(aShippingOptions);
+  nsCOMPtr<nsIArray> options = mShippingOptions;
+  options.forget(aShippingOptions);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetails::GetModifiers(nsIArray** aModifiers) {
+  NS_ENSURE_ARG_POINTER(aModifiers);
+  nsCOMPtr<nsIArray> modifiers = mModifiers;
+  modifiers.forget(aModifiers);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetails::GetError(nsAString& aError) {
+  aError = mError;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetails::GetShippingAddressErrors(JSContext* aCx,
+                                         JS::MutableHandle<JS::Value> aErrors) {
+  AddressErrors errors;
+  errors.Init(mShippingAddressErrors);
+  if (!ToJSValue(aCx, errors, aErrors)) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetails::GetPayerErrors(JSContext* aCx,
+                               JS::MutableHandle<JS::Value> aErrors) {
+  PayerErrors errors;
+  errors.Init(mPayerErrors);
+  if (!ToJSValue(aCx, errors, aErrors)) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentDetails::GetPaymentMethodErrors(JSContext* aCx,
+                                       JS::MutableHandle<JS::Value> aErrors) {
+  if (mPaymentMethodErrors.IsEmpty()) {
+    aErrors.set(JS::NullValue());
+    return NS_OK;
+  }
+  nsresult rv = DeserializeToJSValue(mPaymentMethodErrors, aCx, aErrors);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  return NS_OK;
+}
+
+nsresult PaymentDetails::Update(nsIPaymentDetails* aDetails,
+                                const bool aRequestShipping) {
+  MOZ_ASSERT(aDetails);
+  /*
+   * According to the spec [1], update the attributes if they present in new
+   * details (i.e., PaymentDetailsUpdate); otherwise, keep original value.
+   * Note |id| comes only from initial details (i.e., PaymentDetailsInit) and
+   * |error| only from new details.
+   *
+   *   [1] https://www.w3.org/TR/payment-request/#updatewith-method
+   */
+
+  nsresult rv = aDetails->GetTotalItem(getter_AddRefs(mTotalItem));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIArray> displayItems;
+  rv = aDetails->GetDisplayItems(getter_AddRefs(displayItems));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  if (displayItems) {
+    mDisplayItems = displayItems;
+  }
+
+  if (aRequestShipping) {
+    nsCOMPtr<nsIArray> shippingOptions;
+    rv = aDetails->GetShippingOptions(getter_AddRefs(shippingOptions));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+    mShippingOptions = shippingOptions;
+  }
+
+  nsCOMPtr<nsIArray> modifiers;
+  rv = aDetails->GetModifiers(getter_AddRefs(modifiers));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  if (modifiers) {
+    mModifiers = modifiers;
+  }
+
+  rv = aDetails->GetError(mError);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  PaymentDetails* rowDetails = static_cast<PaymentDetails*>(aDetails);
+  MOZ_ASSERT(rowDetails);
+  mShippingAddressErrors = rowDetails->GetShippingAddressErrors();
+  mPayerErrors = rowDetails->GetPayerErrors();
+  mPaymentMethodErrors = rowDetails->GetPaymentMethodErrors();
+
+  return NS_OK;
+}
+
+const nsString& PaymentDetails::GetShippingAddressErrors() const {
+  return mShippingAddressErrors;
+}
+
+const nsString& PaymentDetails::GetPayerErrors() const { return mPayerErrors; }
+
+const nsString& PaymentDetails::GetPaymentMethodErrors() const {
+  return mPaymentMethodErrors;
+}
+
+nsresult PaymentDetails::UpdateErrors(const nsAString& aError,
+                                      const nsAString& aPayerErrors,
+                                      const nsAString& aPaymentMethodErrors,
+                                      const nsAString& aShippingAddressErrors) {
+  mError = aError;
+  mPayerErrors = aPayerErrors;
+  mPaymentMethodErrors = aPaymentMethodErrors;
+  mShippingAddressErrors = aShippingAddressErrors;
+  return NS_OK;
+}
+
+/* PaymentOptions */
+
+NS_IMPL_ISUPPORTS(PaymentOptions, nsIPaymentOptions)
+
+PaymentOptions::PaymentOptions(const bool aRequestPayerName,
+                               const bool aRequestPayerEmail,
+                               const bool aRequestPayerPhone,
+                               const bool aRequestShipping,
+                               const bool aRequestBillingAddress,
+                               const nsAString& aShippingType)
+    : mRequestPayerName(aRequestPayerName),
+      mRequestPayerEmail(aRequestPayerEmail),
+      mRequestPayerPhone(aRequestPayerPhone),
+      mRequestShipping(aRequestShipping),
+      mRequestBillingAddress(aRequestBillingAddress),
+      mShippingType(aShippingType) {}
+
+nsresult PaymentOptions::Create(const IPCPaymentOptions& aIPCOptions,
+                                nsIPaymentOptions** aOptions) {
+  NS_ENSURE_ARG_POINTER(aOptions);
+
+  nsCOMPtr<nsIPaymentOptions> options = new PaymentOptions(
+      aIPCOptions.requestPayerName(), aIPCOptions.requestPayerEmail(),
+      aIPCOptions.requestPayerPhone(), aIPCOptions.requestShipping(),
+      aIPCOptions.requestBillingAddress(), aIPCOptions.shippingType());
+  options.forget(aOptions);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentOptions::GetRequestPayerName(bool* aRequestPayerName) {
+  NS_ENSURE_ARG_POINTER(aRequestPayerName);
+  *aRequestPayerName = mRequestPayerName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentOptions::GetRequestPayerEmail(bool* aRequestPayerEmail) {
+  NS_ENSURE_ARG_POINTER(aRequestPayerEmail);
+  *aRequestPayerEmail = mRequestPayerEmail;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentOptions::GetRequestPayerPhone(bool* aRequestPayerPhone) {
+  NS_ENSURE_ARG_POINTER(aRequestPayerPhone);
+  *aRequestPayerPhone = mRequestPayerPhone;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentOptions::GetRequestShipping(bool* aRequestShipping) {
+  NS_ENSURE_ARG_POINTER(aRequestShipping);
+  *aRequestShipping = mRequestShipping;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentOptions::GetRequestBillingAddress(bool* aRequestBillingAddress) {
+  NS_ENSURE_ARG_POINTER(aRequestBillingAddress);
+  *aRequestBillingAddress = mRequestBillingAddress;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentOptions::GetShippingType(nsAString& aShippingType) {
+  aShippingType = mShippingType;
+  return NS_OK;
+}
+
+/* PaymentReqeust */
+
+NS_IMPL_ISUPPORTS(PaymentRequest, nsIPaymentRequest)
+
+PaymentRequest::PaymentRequest(const uint64_t aTopOuterWindowId,
+                               const nsAString& aRequestId,
+                               nsIPrincipal* aTopLevelPrincipal,
+                               nsIArray* aPaymentMethods,
+                               nsIPaymentDetails* aPaymentDetails,
+                               nsIPaymentOptions* aPaymentOptions,
+                               const nsAString& aShippingOption)
+    : mTopOuterWindowId(aTopOuterWindowId),
+      mRequestId(aRequestId),
+      mTopLevelPrincipal(aTopLevelPrincipal),
+      mPaymentMethods(aPaymentMethods),
+      mPaymentDetails(aPaymentDetails),
+      mPaymentOptions(aPaymentOptions),
+      mShippingOption(aShippingOption),
+      mState(eCreated) {}
+
+NS_IMETHODIMP
+PaymentRequest::GetTopOuterWindowId(uint64_t* aTopOuterWindowId) {
+  NS_ENSURE_ARG_POINTER(aTopOuterWindowId);
+  *aTopOuterWindowId = mTopOuterWindowId;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentRequest::GetTopLevelPrincipal(nsIPrincipal** aTopLevelPrincipal) {
+  NS_ENSURE_ARG_POINTER(aTopLevelPrincipal);
+  MOZ_ASSERT(mTopLevelPrincipal);
+  nsCOMPtr<nsIPrincipal> principal = mTopLevelPrincipal;
+  principal.forget(aTopLevelPrincipal);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentRequest::GetRequestId(nsAString& aRequestId) {
+  aRequestId = mRequestId;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentRequest::GetPaymentMethods(nsIArray** aPaymentMethods) {
+  NS_ENSURE_ARG_POINTER(aPaymentMethods);
+  MOZ_ASSERT(mPaymentMethods);
+  nsCOMPtr<nsIArray> methods = mPaymentMethods;
+  methods.forget(aPaymentMethods);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentRequest::GetPaymentDetails(nsIPaymentDetails** aPaymentDetails) {
+  NS_ENSURE_ARG_POINTER(aPaymentDetails);
+  MOZ_ASSERT(mPaymentDetails);
+  nsCOMPtr<nsIPaymentDetails> details = mPaymentDetails;
+  details.forget(aPaymentDetails);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentRequest::GetPaymentOptions(nsIPaymentOptions** aPaymentOptions) {
+  NS_ENSURE_ARG_POINTER(aPaymentOptions);
+  MOZ_ASSERT(mPaymentOptions);
+  nsCOMPtr<nsIPaymentOptions> options = mPaymentOptions;
+  options.forget(aPaymentOptions);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentRequest::GetShippingOption(nsAString& aShippingOption) {
+  aShippingOption = mShippingOption;
+  return NS_OK;
+}
+
+nsresult PaymentRequest::UpdatePaymentDetails(
+    nsIPaymentDetails* aPaymentDetails, const nsAString& aShippingOption) {
+  MOZ_ASSERT(aPaymentDetails);
+  bool requestShipping;
+  nsresult rv = mPaymentOptions->GetRequestShipping(&requestShipping);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  mShippingOption = aShippingOption;
+
+  PaymentDetails* rowDetails =
+      static_cast<PaymentDetails*>(mPaymentDetails.get());
+  MOZ_ASSERT(rowDetails);
+  return rowDetails->Update(aPaymentDetails, requestShipping);
+}
+
+void PaymentRequest::SetCompleteStatus(const nsAString& aCompleteStatus) {
+  mCompleteStatus = aCompleteStatus;
+}
+
+nsresult PaymentRequest::UpdateErrors(const nsAString& aError,
+                                      const nsAString& aPayerErrors,
+                                      const nsAString& aPaymentMethodErrors,
+                                      const nsAString& aShippingAddressErrors) {
+  PaymentDetails* rowDetails =
+      static_cast<PaymentDetails*>(mPaymentDetails.get());
+  MOZ_ASSERT(rowDetails);
+  return rowDetails->UpdateErrors(aError, aPayerErrors, aPaymentMethodErrors,
+                                  aShippingAddressErrors);
+}
+
+NS_IMETHODIMP
+PaymentRequest::GetCompleteStatus(nsAString& aCompleteStatus) {
+  aCompleteStatus = mCompleteStatus;
+  return NS_OK;
+}
+
+/* PaymentAddress */
+
+NS_IMPL_ISUPPORTS(PaymentAddress, nsIPaymentAddress)
+
+NS_IMETHODIMP
+PaymentAddress::Init(const nsAString& aCountry, nsIArray* aAddressLine,
+                     const nsAString& aRegion, const nsAString& aRegionCode,
+                     const nsAString& aCity,
+                     const nsAString& aDependentLocality,
+                     const nsAString& aPostalCode,
+                     const nsAString& aSortingCode,
+                     const nsAString& aOrganization,
+                     const nsAString& aRecipient, const nsAString& aPhone) {
+  mCountry = aCountry;
+  mAddressLine = aAddressLine;
+  mRegion = aRegion;
+  mRegionCode = aRegionCode;
+  mCity = aCity;
+  mDependentLocality = aDependentLocality;
+  mPostalCode = aPostalCode;
+  mSortingCode = aSortingCode;
+  mOrganization = aOrganization;
+  mRecipient = aRecipient;
+  mPhone = aPhone;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetCountry(nsAString& aCountry) {
+  aCountry = mCountry;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetAddressLine(nsIArray** aAddressLine) {
+  NS_ENSURE_ARG_POINTER(aAddressLine);
+  nsCOMPtr<nsIArray> addressLine = mAddressLine;
+  addressLine.forget(aAddressLine);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetRegion(nsAString& aRegion) {
+  aRegion = mRegion;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetRegionCode(nsAString& aRegionCode) {
+  aRegionCode = mRegionCode;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetCity(nsAString& aCity) {
+  aCity = mCity;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetDependentLocality(nsAString& aDependentLocality) {
+  aDependentLocality = mDependentLocality;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetPostalCode(nsAString& aPostalCode) {
+  aPostalCode = mPostalCode;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetSortingCode(nsAString& aSortingCode) {
+  aSortingCode = mSortingCode;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetOrganization(nsAString& aOrganization) {
+  aOrganization = mOrganization;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetRecipient(nsAString& aRecipient) {
+  aRecipient = mRecipient;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PaymentAddress::GetPhone(nsAString& aPhone) {
+  aPhone = mPhone;
+  return NS_OK;
+}
+
+}  // namespace mozilla::dom::payments