gecko-dev/dom/presentation/PresentationRequest.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 "PresentationRequest.h"

#include "AvailabilityCollection.h"
#include "ControllerConnectionCollection.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/dom/Navigator.h"
#include "mozilla/dom/PresentationRequestBinding.h"
#include "mozilla/dom/PresentationConnectionAvailableEvent.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/Move.h"
#include "mozIThirdPartyUtil.h"
#include "nsContentSecurityManager.h"
#include "nsCycleCollectionParticipant.h"
#include "nsGlobalWindow.h"
#include "nsIDocument.h"
#include "nsIPresentationService.h"
#include "nsIURI.h"
#include "nsIUUIDGenerator.h"
#include "nsNetUtil.h"
#include "nsSandboxFlags.h"
#include "nsServiceManagerUtils.h"
#include "Presentation.h"
#include "PresentationAvailability.h"
#include "PresentationCallbacks.h"
#include "PresentationLog.h"
#include "PresentationTransportBuilderConstructor.h"

using namespace mozilla;
using namespace mozilla::dom;

NS_IMPL_ADDREF_INHERITED(PresentationRequest, DOMEventTargetHelper)
NS_IMPL_RELEASE_INHERITED(PresentationRequest, DOMEventTargetHelper)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PresentationRequest)
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)

static nsresult
GetAbsoluteURL(const nsAString& aUrl,
               nsIURI* aBaseUri,
               nsIDocument* aDocument,
               nsAString& aAbsoluteUrl)
{
  nsCOMPtr<nsIURI> uri;
  nsresult rv;
  if (aDocument) {
    rv = NS_NewURI(getter_AddRefs(uri), aUrl,
                   aDocument->GetDocumentCharacterSet(), aBaseUri);
  } else {
    rv = NS_NewURI(getter_AddRefs(uri), aUrl, nullptr, aBaseUri);
  }

  if (NS_FAILED(rv)) {
    return rv;
  }

  nsAutoCString spec;
  uri->GetSpec(spec);

  aAbsoluteUrl = NS_ConvertUTF8toUTF16(spec);

  return NS_OK;
}

/* static */ already_AddRefed<PresentationRequest>
PresentationRequest::Constructor(const GlobalObject& aGlobal,
                                 const nsAString& aUrl,
                                 ErrorResult& aRv)
{
  Sequence<nsString> urls;
  urls.AppendElement(aUrl, fallible);
  return Constructor(aGlobal, urls, aRv);
}

/* static */ already_AddRefed<PresentationRequest>
PresentationRequest::Constructor(const GlobalObject& aGlobal,
                                 const Sequence<nsString>& aUrls,
                                 ErrorResult& aRv)
{
  nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aGlobal.GetAsSupports());
  if (!window) {
    aRv.Throw(NS_ERROR_UNEXPECTED);
    return nullptr;
  }

  if (aUrls.IsEmpty()) {
    aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
    return nullptr;
  }

  // Resolve relative URL to absolute URL
  nsCOMPtr<nsIURI> baseUri = window->GetDocBaseURI();
  nsTArray<nsString> urls;
  for (const auto& url : aUrls) {
    nsAutoString absoluteUrl;
    nsresult rv =
      GetAbsoluteURL(url, baseUri, window->GetExtantDoc(), absoluteUrl);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
      return nullptr;
    }

    urls.AppendElement(absoluteUrl);
  }

  RefPtr<PresentationRequest> request =
    new PresentationRequest(window, std::move(urls));
  return NS_WARN_IF(!request->Init()) ? nullptr : request.forget();
}

PresentationRequest::PresentationRequest(nsPIDOMWindowInner* aWindow,
                                         nsTArray<nsString>&& aUrls)
  : DOMEventTargetHelper(aWindow)
  , mUrls(std::move(aUrls))
{
}

PresentationRequest::~PresentationRequest()
{
}

bool
PresentationRequest::Init()
{
  return true;
}

/* virtual */ JSObject*
PresentationRequest::WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto)
{
  return PresentationRequest_Binding::Wrap(aCx, this, aGivenProto);
}

already_AddRefed<Promise>
PresentationRequest::Start(ErrorResult& aRv)
{
  return StartWithDevice(VoidString(), aRv);
}

already_AddRefed<Promise>
PresentationRequest::StartWithDevice(const nsAString& aDeviceId,
                                     ErrorResult& aRv)
{
  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
  if (NS_WARN_IF(!global)) {
    aRv.Throw(NS_ERROR_UNEXPECTED);
    return nullptr;
  }

  // Get the origin.
  nsAutoString origin;
  nsresult rv = nsContentUtils::GetUTFOrigin(global->PrincipalOrNull(), origin);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    aRv.Throw(rv);
    return nullptr;
  }

  nsCOMPtr<nsIDocument> doc = GetOwner()->GetExtantDoc();
  if (NS_WARN_IF(!doc)) {
    aRv.Throw(NS_ERROR_FAILURE);
    return nullptr;
  }

  RefPtr<Promise> promise = Promise::Create(global, aRv);
  if (NS_WARN_IF(aRv.Failed())) {
    return nullptr;
  }

  if (nsContentUtils::ShouldResistFingerprinting()) {
    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
    return promise.forget();
  }

  if (IsProhibitMixedSecurityContexts(doc) &&
      !IsAllURLAuthenticated()) {
    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
    return promise.forget();
  }

  if (doc->GetSandboxFlags() & SANDBOXED_PRESENTATION) {
    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
    return promise.forget();
  }

  RefPtr<Navigator> navigator = nsGlobalWindowInner::Cast(GetOwner())->Navigator();
  if (NS_WARN_IF(aRv.Failed())) {
    return nullptr;
  }

  RefPtr<Presentation> presentation = navigator->GetPresentation(aRv);
  if (NS_WARN_IF(aRv.Failed())) {
    return nullptr;
  }

  if (presentation->IsStartSessionUnsettled()) {
    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
    return promise.forget();
  }

  // Generate a session ID.
  nsCOMPtr<nsIUUIDGenerator> uuidgen =
    do_GetService("@mozilla.org/uuid-generator;1");
  if(NS_WARN_IF(!uuidgen)) {
    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
    return promise.forget();
  }

  nsID uuid;
  uuidgen->GenerateUUIDInPlace(&uuid);
  char buffer[NSID_LENGTH];
  uuid.ToProvidedString(buffer);
  nsAutoString id;
  CopyASCIItoUTF16(MakeSpan(buffer, NSID_LENGTH - 1), id);

  nsCOMPtr<nsIPresentationService> service =
    do_GetService(PRESENTATION_SERVICE_CONTRACTID);
  if(NS_WARN_IF(!service)) {
    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
    return promise.forget();
  }

  presentation->SetStartSessionUnsettled(true);

  // Get xul:browser element in parent process or nsWindowRoot object in child
  // process. If it's in child process, the corresponding xul:browser element
  // will be obtained at PresentationRequestParent::DoRequest in its parent
  // process.
  nsCOMPtr<EventTarget> handler = GetOwner()->GetChromeEventHandler();
  nsCOMPtr<nsIPrincipal> principal = doc->NodePrincipal();
  nsCOMPtr<nsIPresentationServiceCallback> callback =
    new PresentationRequesterCallback(this, id, promise);
  nsCOMPtr<nsIPresentationTransportBuilderConstructor> constructor =
    PresentationTransportBuilderConstructor::Create();
  rv = service->StartSession(mUrls,
                             id,
                             origin,
                             aDeviceId,
                             GetOwner()->WindowID(),
                             handler,
                             principal,
                             callback,
                             constructor);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
    NotifyPromiseSettled();
  }

  return promise.forget();
}

already_AddRefed<Promise>
PresentationRequest::Reconnect(const nsAString& aPresentationId,
                               ErrorResult& aRv)
{
  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
  if (NS_WARN_IF(!global)) {
    aRv.Throw(NS_ERROR_UNEXPECTED);
    return nullptr;
  }

  nsCOMPtr<nsIDocument> doc = GetOwner()->GetExtantDoc();
  if (NS_WARN_IF(!doc)) {
    aRv.Throw(NS_ERROR_FAILURE);
    return nullptr;
  }

  RefPtr<Promise> promise = Promise::Create(global, aRv);
  if (NS_WARN_IF(aRv.Failed())) {
    return nullptr;
  }

  if (nsContentUtils::ShouldResistFingerprinting()) {
    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
    return promise.forget();
  }

  if (IsProhibitMixedSecurityContexts(doc) &&
      !IsAllURLAuthenticated()) {
    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
    return promise.forget();
  }

  if (doc->GetSandboxFlags() & SANDBOXED_PRESENTATION) {
    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
    return promise.forget();
  }

  nsString presentationId = nsString(aPresentationId);
  nsCOMPtr<nsIRunnable> r = NewRunnableMethod<nsString, RefPtr<Promise>>(
    "dom::PresentationRequest::FindOrCreatePresentationConnection",
    this,
    &PresentationRequest::FindOrCreatePresentationConnection,
    presentationId,
    promise);

  if (NS_WARN_IF(NS_FAILED(NS_DispatchToMainThread(r)))) {
    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
  }

  return promise.forget();
}

void
PresentationRequest::FindOrCreatePresentationConnection(
  const nsAString& aPresentationId,
  Promise* aPromise)
{
  MOZ_ASSERT(aPromise);

  if (NS_WARN_IF(!GetOwner())) {
    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
    return;
  }

  RefPtr<PresentationConnection> connection =
    ControllerConnectionCollection::GetSingleton()->FindConnection(
      GetOwner()->WindowID(),
      aPresentationId,
      nsIPresentationService::ROLE_CONTROLLER);

  if (connection) {
    nsAutoString url;
    connection->GetUrl(url);
    if (mUrls.Contains(url)) {
      switch (connection->State()) {
        case PresentationConnectionState::Closed:
          // We found the matched connection.
          break;
        case PresentationConnectionState::Connecting:
        case PresentationConnectionState::Connected:
          aPromise->MaybeResolve(connection);
          return;
        case PresentationConnectionState::Terminated:
          // A terminated connection cannot be reused.
          connection = nullptr;
          break;
        default:
          MOZ_CRASH("Unknown presentation session state.");
          return;
      }
    } else {
      connection = nullptr;
    }
  }

  nsCOMPtr<nsIPresentationService> service =
    do_GetService(PRESENTATION_SERVICE_CONTRACTID);
  if(NS_WARN_IF(!service)) {
    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
    return;
  }

  nsCOMPtr<nsIPresentationServiceCallback> callback =
    new PresentationReconnectCallback(this,
                                      aPresentationId,
                                      aPromise,
                                      connection);

  nsresult rv =
    service->ReconnectSession(mUrls,
                              aPresentationId,
                              nsIPresentationService::ROLE_CONTROLLER,
                              callback);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
  }
}

already_AddRefed<Promise>
PresentationRequest::GetAvailability(ErrorResult& aRv)
{
  PRES_DEBUG("%s\n", __func__);
  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
  if (NS_WARN_IF(!global)) {
    aRv.Throw(NS_ERROR_UNEXPECTED);
    return nullptr;
  }

  nsCOMPtr<nsIDocument> doc = GetOwner()->GetExtantDoc();
  if (NS_WARN_IF(!doc)) {
    aRv.Throw(NS_ERROR_FAILURE);
    return nullptr;
  }

  RefPtr<Promise> promise = Promise::Create(global, aRv);
  if (NS_WARN_IF(aRv.Failed())) {
    return nullptr;
  }

  if (nsContentUtils::ShouldResistFingerprinting()) {
    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
    return promise.forget();
  }

  if (IsProhibitMixedSecurityContexts(doc) &&
      !IsAllURLAuthenticated()) {
    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
    return promise.forget();
  }

  if (doc->GetSandboxFlags() & SANDBOXED_PRESENTATION) {
    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
    return promise.forget();
  }

  FindOrCreatePresentationAvailability(promise);

  return promise.forget();
}

void
PresentationRequest::FindOrCreatePresentationAvailability(RefPtr<Promise>& aPromise)
{
  MOZ_ASSERT(aPromise);

  if (NS_WARN_IF(!GetOwner())) {
    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
    return;
  }

  AvailabilityCollection* collection = AvailabilityCollection::GetSingleton();
  if (NS_WARN_IF(!collection)) {
    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
    return;
  }

  RefPtr<PresentationAvailability> availability =
    collection->Find(GetOwner()->WindowID(), mUrls);

  if (!availability) {
    availability = PresentationAvailability::Create(GetOwner(), mUrls, aPromise);
  } else {
    PRES_DEBUG(">resolve with same object\n");

    // Fetching cached available devices is asynchronous in our implementation,
    // we need to ensure the promise is resolved in order.
    if (availability->IsCachedValueReady()) {
      aPromise->MaybeResolve(availability);
      return;
    }

    availability->EnqueuePromise(aPromise);
  }

  if (!availability) {
    aPromise->MaybeReject(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
    return;
  }
}

nsresult
PresentationRequest::DispatchConnectionAvailableEvent(PresentationConnection* aConnection)
{
  if (nsContentUtils::ShouldResistFingerprinting()) {
    return NS_OK;
  }

  PresentationConnectionAvailableEventInit init;
  init.mConnection = aConnection;

  RefPtr<PresentationConnectionAvailableEvent> event =
    PresentationConnectionAvailableEvent::Constructor(this,
                                                      NS_LITERAL_STRING("connectionavailable"),
                                                      init);
  if (NS_WARN_IF(!event)) {
    return NS_ERROR_FAILURE;
  }
  event->SetTrusted(true);

  RefPtr<AsyncEventDispatcher> asyncDispatcher =
    new AsyncEventDispatcher(this, event);
  return asyncDispatcher->PostDOMEvent();
}

void
PresentationRequest::NotifyPromiseSettled()
{
  PRES_DEBUG("%s\n", __func__);

  if (!GetOwner()) {
    return;
  }

  RefPtr<Navigator> navigator = nsGlobalWindowInner::Cast(GetOwner())->Navigator();
  if (!navigator) {
    return;
  }

  ErrorResult rv;
  RefPtr<Presentation> presentation = navigator->GetPresentation(rv);

  if (presentation) {
    presentation->SetStartSessionUnsettled(false);
  }
}

bool
PresentationRequest::IsProhibitMixedSecurityContexts(nsIDocument* aDocument)
{
  MOZ_ASSERT(aDocument);

  if (nsContentUtils::IsChromeDoc(aDocument)) {
    return true;
  }

  nsCOMPtr<nsIDocument> doc = aDocument;
  while (doc && !nsContentUtils::IsChromeDoc(doc)) {
    if (nsContentUtils::HttpsStateIsModern(doc)) {
      return true;
    }

    doc = doc->GetParentDocument();
  }

  return false;
}

bool
PresentationRequest::IsPrioriAuthenticatedURL(const nsAString& aUrl)
{
  nsCOMPtr<nsIURI> uri;
  if (NS_FAILED(NS_NewURI(getter_AddRefs(uri), aUrl))) {
    return false;
  }

  nsAutoCString scheme;
  nsresult rv = uri->GetScheme(scheme);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return false;
  }

  if (scheme.EqualsLiteral("data")) {
    return true;
  }

  nsAutoCString uriSpec;
  rv = uri->GetSpec(uriSpec);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return false;
  }

  if (uriSpec.EqualsLiteral("about:blank") ||
      uriSpec.EqualsLiteral("about:srcdoc")) {
    return true;
  }

  OriginAttributes attrs;
  nsCOMPtr<nsIPrincipal> principal =
    BasePrincipal::CreateCodebasePrincipal(uri, attrs);
  if (NS_WARN_IF(!principal)) {
    return false;
  }

  nsCOMPtr<nsIContentSecurityManager> csm =
    do_GetService(NS_CONTENTSECURITYMANAGER_CONTRACTID);
  if (NS_WARN_IF(!csm)) {
    return false;
  }

  bool isTrustworthyOrigin = false;
  csm->IsOriginPotentiallyTrustworthy(principal, &isTrustworthyOrigin);
  return isTrustworthyOrigin;
}

bool
PresentationRequest::IsAllURLAuthenticated()
{
  for (const auto& url : mUrls) {
    if (!IsPrioriAuthenticatedURL(url)) {
      return false;
    }
  }

  return true;
}