Add m-esr52 at 52.6.0

1 files changed, 563 insertions, 0 deletions

diff --git a/dom/presentation/PresentationRequest.cpp b/dom/presentation/PresentationRequest.cpp
new file mode 100644
index 000000000..221684e53
--- /dev/null
+++ b/dom/presentation/PresentationRequest.cpp
@@ -0,0 +1,563 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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_INHERITED(PresentationRequest)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+static nsresult
+GetAbsoluteURL(const nsAString& aUrl,
+               nsIURI* aBaseUri,
+               nsIDocument* aDocument,
+               nsAString& aAbsoluteUrl)
+{
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = NS_NewURI(getter_AddRefs(uri),
+                          aUrl,
+                          aDocument ? aDocument->GetDocumentCharacterSet().get()
+                                    : 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, Move(urls));
+  return NS_WARN_IF(!request->Init()) ? nullptr : request.forget();
+}
+
+PresentationRequest::PresentationRequest(nsPIDOMWindowInner* aWindow,
+                                         nsTArray<nsString>&& aUrls)
+  : DOMEventTargetHelper(aWindow)
+  , mUrls(Move(aUrls))
+{
+}
+
+PresentationRequest::~PresentationRequest()
+{
+}
+
+bool
+PresentationRequest::Init()
+{
+  return true;
+}
+
+/* virtual */ JSObject*
+PresentationRequest::WrapObject(JSContext* aCx,
+                                JS::Handle<JSObject*> aGivenProto)
+{
+  return PresentationRequestBinding::Wrap(aCx, this, aGivenProto);
+}
+
+already_AddRefed<Promise>
+PresentationRequest::Start(ErrorResult& aRv)
+{
+  return StartWithDevice(NullString(), 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 (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 =
+    nsGlobalWindow::Cast(GetOwner())->GetNavigator(aRv);
+  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(buffer, 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<nsIDOMEventTarget> handler =
+    do_QueryInterface(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 (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>>(
+      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 (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)
+{
+  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;
+  }
+
+  ErrorResult rv;
+  RefPtr<Navigator> navigator =
+    nsGlobalWindow::Cast(GetOwner())->GetNavigator(rv);
+  if (!navigator) {
+    return;
+  }
+
+  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;
+  }
+
+  PrincipalOriginAttributes 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;
+}