dom/payments/PaymentRequestService.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 "BasicCardPayment.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/dom/BasicCardPaymentBinding.h"
#include "mozilla/dom/PaymentRequestParent.h"
#include "nsArrayUtils.h"
#include "nsComponentManagerUtils.h"
#include "nsCOMPtr.h"
#include "nsIMutableArray.h"
#include "nsServiceManagerUtils.h"
#include "nsSimpleEnumerator.h"
#include "PaymentRequestService.h"

namespace mozilla::dom {

StaticRefPtr<PaymentRequestService> gPaymentService;

namespace {

class PaymentRequestEnumerator final : public nsSimpleEnumerator {
 public:
  NS_DECL_NSISIMPLEENUMERATOR

  PaymentRequestEnumerator() : mIndex(0) {}

  const nsID& DefaultInterface() override {
    return NS_GET_IID(nsIPaymentRequest);
  }

 private:
  ~PaymentRequestEnumerator() override = default;
  uint32_t mIndex;
};

NS_IMETHODIMP
PaymentRequestEnumerator::HasMoreElements(bool* aReturn) {
  NS_ENSURE_ARG_POINTER(aReturn);
  *aReturn = false;
  if (NS_WARN_IF(!gPaymentService)) {
    return NS_ERROR_FAILURE;
  }
  RefPtr<PaymentRequestService> service = gPaymentService;
  *aReturn = mIndex < service->NumPayments();
  return NS_OK;
}

NS_IMETHODIMP
PaymentRequestEnumerator::GetNext(nsISupports** aItem) {
  NS_ENSURE_ARG_POINTER(aItem);
  if (NS_WARN_IF(!gPaymentService)) {
    return NS_ERROR_FAILURE;
  }
  RefPtr<payments::PaymentRequest> rowRequest =
      gPaymentService->GetPaymentRequestByIndex(mIndex);
  if (!rowRequest) {
    return NS_ERROR_FAILURE;
  }
  mIndex++;
  rowRequest.forget(aItem);
  return NS_OK;
}

}  // end of anonymous namespace

/* PaymentRequestService */

NS_IMPL_ISUPPORTS(PaymentRequestService, nsIPaymentRequestService)

already_AddRefed<PaymentRequestService> PaymentRequestService::GetSingleton() {
  MOZ_ASSERT(NS_IsMainThread());
  if (!gPaymentService) {
    gPaymentService = new PaymentRequestService();
    ClearOnShutdown(&gPaymentService);
  }
  RefPtr<PaymentRequestService> service = gPaymentService;
  return service.forget();
}

uint32_t PaymentRequestService::NumPayments() const {
  return mRequestQueue.Length();
}

already_AddRefed<payments::PaymentRequest>
PaymentRequestService::GetPaymentRequestByIndex(const uint32_t aIndex) {
  if (aIndex >= mRequestQueue.Length()) {
    return nullptr;
  }
  RefPtr<payments::PaymentRequest> request = mRequestQueue[aIndex];
  MOZ_ASSERT(request);
  return request.forget();
}

NS_IMETHODIMP
PaymentRequestService::GetPaymentRequestById(const nsAString& aRequestId,
                                             nsIPaymentRequest** aRequest) {
  NS_ENSURE_ARG_POINTER(aRequest);
  *aRequest = nullptr;
  RefPtr<payments::PaymentRequest> rowRequest;
  nsresult rv = GetPaymentRequestById(aRequestId, getter_AddRefs(rowRequest));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  rowRequest.forget(aRequest);
  return NS_OK;
}

nsresult PaymentRequestService::GetPaymentRequestById(
    const nsAString& aRequestId, payments::PaymentRequest** aRequest) {
  NS_ENSURE_ARG_POINTER(aRequest);
  *aRequest = nullptr;
  uint32_t numRequests = mRequestQueue.Length();
  for (uint32_t index = 0; index < numRequests; ++index) {
    RefPtr<payments::PaymentRequest> request = mRequestQueue[index];
    MOZ_ASSERT(request);
    nsAutoString requestId;
    nsresult rv = request->GetRequestId(requestId);
    NS_ENSURE_SUCCESS(rv, rv);
    if (requestId == aRequestId) {
      request.forget(aRequest);
      break;
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
PaymentRequestService::Enumerate(nsISimpleEnumerator** aEnumerator) {
  NS_ENSURE_ARG_POINTER(aEnumerator);
  nsCOMPtr<nsISimpleEnumerator> enumerator = new PaymentRequestEnumerator();
  enumerator.forget(aEnumerator);
  return NS_OK;
}

NS_IMETHODIMP
PaymentRequestService::Cleanup() {
  mRequestQueue.Clear();
  return NS_OK;
}

NS_IMETHODIMP
PaymentRequestService::SetTestingUIService(nsIPaymentUIService* aUIService) {
  // aUIService can be nullptr
  mTestingUIService = aUIService;
  return NS_OK;
}

nsresult PaymentRequestService::LaunchUIAction(const nsAString& aRequestId,
                                               uint32_t aActionType) {
  nsCOMPtr<nsIPaymentUIService> uiService;
  nsresult rv;
  if (mTestingUIService) {
    uiService = mTestingUIService;
  } else {
    uiService = do_GetService(NS_PAYMENT_UI_SERVICE_CONTRACT_ID, &rv);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      return rv;
    }
  }
  switch (aActionType) {
    case IPCPaymentActionRequest::TIPCPaymentShowActionRequest: {
      rv = uiService->ShowPayment(aRequestId);
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentAbortActionRequest: {
      rv = uiService->AbortPayment(aRequestId);
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentCompleteActionRequest: {
      rv = uiService->CompletePayment(aRequestId);
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentUpdateActionRequest: {
      rv = uiService->UpdatePayment(aRequestId);
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentCloseActionRequest: {
      rv = uiService->ClosePayment(aRequestId);
      break;
    }
    default: {
      return NS_ERROR_FAILURE;
    }
  }
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  return NS_OK;
}

nsresult PaymentRequestService::RequestPayment(
    const nsAString& aRequestId, const IPCPaymentActionRequest& aAction,
    PaymentRequestParent* aIPC) {
  NS_ENSURE_ARG_POINTER(aIPC);

  nsresult rv = NS_OK;
  uint32_t type = aAction.type();

  RefPtr<payments::PaymentRequest> request;
  if (type != IPCPaymentActionRequest::TIPCPaymentCreateActionRequest) {
    rv = GetPaymentRequestById(aRequestId, getter_AddRefs(request));
    if (NS_WARN_IF(NS_FAILED(rv))) {
      return rv;
    }
    if (!request &&
        type != IPCPaymentActionRequest::TIPCPaymentCloseActionRequest) {
      return NS_ERROR_FAILURE;
    }
    if (request) {
      request->SetIPC(aIPC);
    }
  }

  switch (type) {
    case IPCPaymentActionRequest::TIPCPaymentCreateActionRequest: {
      MOZ_ASSERT(!request);
      const IPCPaymentCreateActionRequest& action = aAction;
      nsCOMPtr<nsIMutableArray> methodData =
          do_CreateInstance(NS_ARRAY_CONTRACTID);
      MOZ_ASSERT(methodData);
      for (IPCPaymentMethodData data : action.methodData()) {
        nsCOMPtr<nsIPaymentMethodData> method;
        rv = payments::PaymentMethodData::Create(data, getter_AddRefs(method));
        NS_ENSURE_SUCCESS(rv, rv);
        rv = methodData->AppendElement(method);
        NS_ENSURE_SUCCESS(rv, rv);
      }
      nsCOMPtr<nsIPaymentDetails> details;
      rv = payments::PaymentDetails::Create(action.details(),
                                            getter_AddRefs(details));
      NS_ENSURE_SUCCESS(rv, rv);
      nsCOMPtr<nsIPaymentOptions> options;
      rv = payments::PaymentOptions::Create(action.options(),
                                            getter_AddRefs(options));
      NS_ENSURE_SUCCESS(rv, rv);
      RefPtr<payments::PaymentRequest> request = new payments::PaymentRequest(
          action.topOuterWindowId(), aRequestId, action.topLevelPrincipal(),
          methodData, details, options, action.shippingOption());

      if (!mRequestQueue.AppendElement(request, mozilla::fallible)) {
        return NS_ERROR_OUT_OF_MEMORY;
      }
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentCanMakeActionRequest: {
      nsCOMPtr<nsIPaymentCanMakeActionResponse> canMakeResponse =
          do_CreateInstance(NS_PAYMENT_CANMAKE_ACTION_RESPONSE_CONTRACT_ID);
      MOZ_ASSERT(canMakeResponse);
      rv = canMakeResponse->Init(aRequestId, CanMakePayment(aRequestId));
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      rv = RespondPayment(canMakeResponse.get());
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentShowActionRequest: {
      const IPCPaymentShowActionRequest& action = aAction;
      rv = ShowPayment(aRequestId, action.isUpdating());
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentAbortActionRequest: {
      MOZ_ASSERT(request);
      request->SetState(payments::PaymentRequest::eInteractive);
      rv = LaunchUIAction(aRequestId, type);
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentCompleteActionRequest: {
      MOZ_ASSERT(request);
      const IPCPaymentCompleteActionRequest& action = aAction;
      request->SetCompleteStatus(action.completeStatus());
      rv = LaunchUIAction(aRequestId, type);
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentUpdateActionRequest: {
      const IPCPaymentUpdateActionRequest& action = aAction;
      nsCOMPtr<nsIPaymentDetails> details;
      rv = payments::PaymentDetails::Create(action.details(),
                                            getter_AddRefs(details));
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      MOZ_ASSERT(request);
      rv = request->UpdatePaymentDetails(details, action.shippingOption());
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      nsAutoString completeStatus;
      rv = request->GetCompleteStatus(completeStatus);
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      if (completeStatus.Equals(u"initial"_ns)) {
        request->SetCompleteStatus(u""_ns);
      }
      MOZ_ASSERT(mShowingRequest && mShowingRequest == request);
      rv = LaunchUIAction(aRequestId, type);
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentCloseActionRequest: {
      rv = LaunchUIAction(aRequestId, type);
      if (NS_WARN_IF(NS_FAILED(rv))) {
        return rv;
      }
      if (mShowingRequest == request) {
        mShowingRequest = nullptr;
      }
      mRequestQueue.RemoveElement(request);
      break;
    }
    case IPCPaymentActionRequest::TIPCPaymentRetryActionRequest: {
      const IPCPaymentRetryActionRequest& action = aAction;
      MOZ_ASSERT(request);
      request->UpdateErrors(action.error(), action.payerErrors(),
                            action.paymentMethodErrors(),
                            action.shippingAddressErrors());
      request->SetState(payments::PaymentRequest::eInteractive);
      MOZ_ASSERT(mShowingRequest == request);
      rv = LaunchUIAction(
          aRequestId, IPCPaymentActionRequest::TIPCPaymentUpdateActionRequest);
      break;
    }
    default: {
      return NS_ERROR_FAILURE;
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
PaymentRequestService::RespondPayment(nsIPaymentActionResponse* aResponse) {
  NS_ENSURE_ARG_POINTER(aResponse);
  nsAutoString requestId;
  nsresult rv = aResponse->GetRequestId(requestId);
  NS_ENSURE_SUCCESS(rv, rv);

  RefPtr<payments::PaymentRequest> request;
  rv = GetPaymentRequestById(requestId, getter_AddRefs(request));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  if (!request) {
    return NS_ERROR_FAILURE;
  }
  uint32_t type;
  rv = aResponse->GetType(&type);
  NS_ENSURE_SUCCESS(rv, rv);

  // PaymentRequest can only be responded when
  // 1. the state is eInteractive
  // 2. the state is eClosed and response type is COMPLETE_ACTION
  // 3. the state is eCreated and response type is CANMAKE_ACTION
  payments::PaymentRequest::eState state = request->GetState();
  bool canBeResponded = (state == payments::PaymentRequest::eInteractive) ||
                        (state == payments::PaymentRequest::eClosed &&
                         type == nsIPaymentActionResponse::COMPLETE_ACTION) ||
                        (state == payments::PaymentRequest::eCreated &&
                         type == nsIPaymentActionResponse::CANMAKE_ACTION);
  if (!canBeResponded) {
    return NS_ERROR_FAILURE;
  }

  if (!request->GetIPC()) {
    return NS_ERROR_FAILURE;
  }
  rv = request->GetIPC()->RespondPayment(aResponse);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }

  // Remove PaymentRequest from mRequestQueue while receive succeeded abort
  // response or complete response
  switch (type) {
    case nsIPaymentActionResponse::ABORT_ACTION: {
      nsCOMPtr<nsIPaymentAbortActionResponse> response =
          do_QueryInterface(aResponse);
      MOZ_ASSERT(response);
      bool isSucceeded;
      rv = response->IsSucceeded(&isSucceeded);
      NS_ENSURE_SUCCESS(rv, rv);
      mShowingRequest = nullptr;
      if (isSucceeded) {
        mRequestQueue.RemoveElement(request);
        request->SetState(payments::PaymentRequest::eClosed);
      }
      break;
    }
    case nsIPaymentActionResponse::SHOW_ACTION: {
      request->SetState(payments::PaymentRequest::eClosed);
      nsCOMPtr<nsIPaymentShowActionResponse> response =
          do_QueryInterface(aResponse);
      MOZ_ASSERT(response);
      uint32_t acceptStatus;
      rv = response->GetAcceptStatus(&acceptStatus);
      NS_ENSURE_SUCCESS(rv, rv);
      if (acceptStatus != nsIPaymentActionResponse::PAYMENT_ACCEPTED) {
        // Check if rejecting the showing PaymentRequest.
        // If yes, set mShowingRequest as nullptr.
        if (mShowingRequest == request) {
          mShowingRequest = nullptr;
        }
        mRequestQueue.RemoveElement(request);
      }
      break;
    }
    case nsIPaymentActionResponse::COMPLETE_ACTION: {
      mShowingRequest = nullptr;
      mRequestQueue.RemoveElement(request);
      break;
    }
    default: {
      break;
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
PaymentRequestService::ChangeShippingAddress(const nsAString& aRequestId,
                                             nsIPaymentAddress* aAddress) {
  RefPtr<payments::PaymentRequest> request;
  nsresult rv = GetPaymentRequestById(aRequestId, getter_AddRefs(request));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  if (!request) {
    return NS_ERROR_FAILURE;
  }
  if (request->GetState() != payments::PaymentRequest::eInteractive) {
    return NS_ERROR_FAILURE;
  }
  if (!request->GetIPC()) {
    return NS_ERROR_FAILURE;
  }
  rv = request->GetIPC()->ChangeShippingAddress(aRequestId, aAddress);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  return NS_OK;
}

NS_IMETHODIMP
PaymentRequestService::ChangeShippingOption(const nsAString& aRequestId,
                                            const nsAString& aOption) {
  RefPtr<payments::PaymentRequest> request;
  nsresult rv = GetPaymentRequestById(aRequestId, getter_AddRefs(request));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  if (!request) {
    return NS_ERROR_FAILURE;
  }
  if (request->GetState() != payments::PaymentRequest::eInteractive) {
    return NS_ERROR_FAILURE;
  }
  if (!request->GetIPC()) {
    return NS_ERROR_FAILURE;
  }
  rv = request->GetIPC()->ChangeShippingOption(aRequestId, aOption);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  return NS_OK;
}

NS_IMETHODIMP
PaymentRequestService::ChangePayerDetail(const nsAString& aRequestId,
                                         const nsAString& aPayerName,
                                         const nsAString& aPayerEmail,
                                         const nsAString& aPayerPhone) {
  RefPtr<payments::PaymentRequest> request;
  nsresult rv = GetPaymentRequestById(aRequestId, getter_AddRefs(request));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  MOZ_ASSERT(request);
  if (!request->GetIPC()) {
    return NS_ERROR_FAILURE;
  }
  rv = request->GetIPC()->ChangePayerDetail(aRequestId, aPayerName, aPayerEmail,
                                            aPayerPhone);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  return NS_OK;
}

NS_IMETHODIMP
PaymentRequestService::ChangePaymentMethod(
    const nsAString& aRequestId, const nsAString& aMethodName,
    nsIMethodChangeDetails* aMethodDetails) {
  RefPtr<payments::PaymentRequest> request;
  nsresult rv = GetPaymentRequestById(aRequestId, getter_AddRefs(request));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  if (!request) {
    return NS_ERROR_FAILURE;
  }
  if (request->GetState() != payments::PaymentRequest::eInteractive) {
    return NS_ERROR_FAILURE;
  }
  if (!request->GetIPC()) {
    return NS_ERROR_FAILURE;
  }
  rv = request->GetIPC()->ChangePaymentMethod(aRequestId, aMethodName,
                                              aMethodDetails);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  return NS_OK;
}

bool PaymentRequestService::CanMakePayment(const nsAString& aRequestId) {
  /*
   *  TODO: Check third party payment app support by traversing all
   *        registered third party payment apps.
   */
  return IsBasicCardPayment(aRequestId);
}

nsresult PaymentRequestService::ShowPayment(const nsAString& aRequestId,
                                            bool aIsUpdating) {
  nsresult rv;
  RefPtr<payments::PaymentRequest> request;
  rv = GetPaymentRequestById(aRequestId, getter_AddRefs(request));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }
  MOZ_ASSERT(request);
  request->SetState(payments::PaymentRequest::eInteractive);
  if (aIsUpdating) {
    request->SetCompleteStatus(u"initial"_ns);
  }

  if (mShowingRequest || !CanMakePayment(aRequestId)) {
    uint32_t responseStatus;
    if (mShowingRequest) {
      responseStatus = nsIPaymentActionResponse::PAYMENT_REJECTED;
    } else {
      responseStatus = nsIPaymentActionResponse::PAYMENT_NOTSUPPORTED;
    }
    nsCOMPtr<nsIPaymentShowActionResponse> showResponse =
        do_CreateInstance(NS_PAYMENT_SHOW_ACTION_RESPONSE_CONTRACT_ID);
    MOZ_ASSERT(showResponse);
    rv = showResponse->Init(aRequestId, responseStatus, u""_ns, nullptr, u""_ns,
                            u""_ns, u""_ns);
    rv = RespondPayment(showResponse.get());
    if (NS_WARN_IF(NS_FAILED(rv))) {
      return rv;
    }
  } else {
    mShowingRequest = request;
    rv = LaunchUIAction(aRequestId,
                        IPCPaymentActionRequest::TIPCPaymentShowActionRequest);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      return rv;
    }
  }
  return NS_OK;
}

bool PaymentRequestService::IsBasicCardPayment(const nsAString& aRequestId) {
  RefPtr<payments::PaymentRequest> request;
  nsresult rv = GetPaymentRequestById(aRequestId, getter_AddRefs(request));
  NS_ENSURE_SUCCESS(rv, false);
  nsCOMPtr<nsIArray> methods;
  rv = request->GetPaymentMethods(getter_AddRefs(methods));
  NS_ENSURE_SUCCESS(rv, false);
  uint32_t length;
  rv = methods->GetLength(&length);
  NS_ENSURE_SUCCESS(rv, false);
  RefPtr<BasicCardService> service = BasicCardService::GetService();
  MOZ_ASSERT(service);
  for (uint32_t index = 0; index < length; ++index) {
    nsCOMPtr<nsIPaymentMethodData> method = do_QueryElementAt(methods, index);
    MOZ_ASSERT(method);
    nsAutoString supportedMethods;
    rv = method->GetSupportedMethods(supportedMethods);
    NS_ENSURE_SUCCESS(rv, false);
    if (service->IsBasicCardPayment(supportedMethods)) {
      return true;
    }
  }
  return false;
}

}  // namespace mozilla::dom