gecko-dev/dom/payments/PaymentRequestData.cpp

/* -*- 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 "nsArrayUtils.h"
#include "nsIMutableArray.h"
#include "nsISupportsPrimitives.h"
#include "nsUnicharUtils.h"
#include "PaymentRequestData.h"
#include "PaymentRequestUtils.h"

namespace mozilla {
namespace dom {
namespace 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::MutableHandleValue 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,
                         const nsAString& aType)
  : mLabel(aLabel)
  , mAmount(aAmount)
  , mPending(aPending)
  , mType(aType)
{
}

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(), aIPCItem.type());
  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;
}

NS_IMETHODIMP
PaymentItem::GetType(nsAString& aType)
{
  aType = mType;
  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 = items.forget();
  }
  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::MutableHandleValue 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 = items.forget();

  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 = options.forget();

  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 = detailsModifiers.forget();

  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::MutableHandleValue aErrors)
{
  AddressErrors errors;
  errors.Init(mShippingAddressErrors);
  if (!ToJSValue(aCx, errors, aErrors)) {
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

NS_IMETHODIMP
PaymentDetails::GetPayer(JSContext* aCx, JS::MutableHandleValue aErrors)
{
  PayerErrors errors;
  errors.Init(mPayerErrors);
  if (!ToJSValue(aCx, errors, aErrors)) {
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

NS_IMETHODIMP
PaymentDetails::GetPaymentMethod(JSContext* aCx, JS::MutableHandleValue 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->GetPayer();
  mPaymentMethodErrors = rowDetails->GetPaymentMethod();

  return NS_OK;

}

const nsString&
PaymentDetails::GetShippingAddressErrors() const
{
  return mShippingAddressErrors;
}

const nsString&
PaymentDetails::GetPayer() const
{
  return mPayerErrors;
}

const nsString&
PaymentDetails::GetPaymentMethod() 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 nsAString& aShippingType)
  : mRequestPayerName(aRequestPayerName)
  , mRequestPayerEmail(aRequestPayerEmail)
  , mRequestPayerPhone(aRequestPayerPhone)
  , mRequestShipping(aRequestShipping)
  , 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.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::GetShippingType(nsAString& aShippingType)
{
  aShippingType = mShippingType;
  return NS_OK;
}

/* PaymentReqeust */

NS_IMPL_ISUPPORTS(PaymentRequest,
                  nsIPaymentRequest)

PaymentRequest::PaymentRequest(const uint64_t aTabId,
                               const nsAString& aRequestId,
                               nsIPrincipal* aTopLevelPrincipal,
                               nsIArray* aPaymentMethods,
                               nsIPaymentDetails* aPaymentDetails,
                               nsIPaymentOptions* aPaymentOptions,
                               const nsAString& aShippingOption)
  : mTabId(aTabId)
  , mRequestId(aRequestId)
  , mTopLevelPrincipal(aTopLevelPrincipal)
  , mPaymentMethods(aPaymentMethods)
  , mPaymentDetails(aPaymentDetails)
  , mPaymentOptions(aPaymentOptions)
  , mShippingOption(aShippingOption)
  , mState(eCreated)
{
}

NS_IMETHODIMP
PaymentRequest::GetTabId(uint64_t* aTabId)
{
  NS_ENSURE_ARG_POINTER(aTabId);
  *aTabId = mTabId;
  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;
}

} // end of namespace payment
} // end of namespace dom
} // end of namespace mozilla