[ tor-browser ].git.dasho

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