Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 420 insertions, 0 deletions

diff --git a/dom/base/nsIGlobalObject.cpp b/dom/base/nsIGlobalObject.cpp
new file mode 100644
index 0000000000..c346db4f71
--- /dev/null
+++ b/dom/base/nsIGlobalObject.cpp
@@ -0,0 +1,420 @@
+/* -*- 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 "nsIGlobalObject.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/CycleCollectedJSContext.h"
+#include "mozilla/GlobalTeardownObserver.h"
+#include "mozilla/Result.h"
+#include "mozilla/StorageAccess.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/BlobURLProtocolHandler.h"
+#include "mozilla/dom/FunctionBinding.h"
+#include "mozilla/dom/Report.h"
+#include "mozilla/dom/ReportingObserver.h"
+#include "mozilla/dom/ServiceWorker.h"
+#include "mozilla/dom/ServiceWorkerRegistration.h"
+#include "mozilla/ipc/PBackgroundSharedTypes.h"
+#include "nsContentUtils.h"
+#include "nsThreadUtils.h"
+#include "nsGlobalWindowInner.h"
+
+// Max number of Report objects
+constexpr auto MAX_REPORT_RECORDS = 100;
+
+using mozilla::AutoSlowOperation;
+using mozilla::CycleCollectedJSContext;
+using mozilla::DOMEventTargetHelper;
+using mozilla::ErrorResult;
+using mozilla::GlobalTeardownObserver;
+using mozilla::IgnoredErrorResult;
+using mozilla::MallocSizeOf;
+using mozilla::Maybe;
+using mozilla::MicroTaskRunnable;
+using mozilla::dom::BlobURLProtocolHandler;
+using mozilla::dom::CallerType;
+using mozilla::dom::ClientInfo;
+using mozilla::dom::Report;
+using mozilla::dom::ReportingObserver;
+using mozilla::dom::ServiceWorker;
+using mozilla::dom::ServiceWorkerDescriptor;
+using mozilla::dom::ServiceWorkerRegistration;
+using mozilla::dom::ServiceWorkerRegistrationDescriptor;
+using mozilla::dom::VoidFunction;
+
+nsIGlobalObject::nsIGlobalObject()
+    : mIsDying(false), mIsScriptForbidden(false), mIsInnerWindow(false) {}
+
+bool nsIGlobalObject::IsScriptForbidden(JSObject* aCallback,
+                                        bool aIsJSImplementedWebIDL) const {
+  if (mIsScriptForbidden || mIsDying) {
+    return true;
+  }
+
+  if (NS_IsMainThread()) {
+    if (aIsJSImplementedWebIDL) {
+      return false;
+    }
+
+    if (!xpc::Scriptability::AllowedIfExists(aCallback)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+nsIGlobalObject::~nsIGlobalObject() {
+  UnlinkObjectsInGlobal();
+  DisconnectGlobalTeardownObservers();
+  MOZ_DIAGNOSTIC_ASSERT(mGlobalTeardownObservers.isEmpty());
+}
+
+nsIPrincipal* nsIGlobalObject::PrincipalOrNull() const {
+  JSObject* global = GetGlobalJSObjectPreserveColor();
+  if (NS_WARN_IF(!global)) return nullptr;
+
+  return nsContentUtils::ObjectPrincipal(global);
+}
+
+void nsIGlobalObject::RegisterHostObjectURI(const nsACString& aURI) {
+  MOZ_ASSERT(!mHostObjectURIs.Contains(aURI));
+  mHostObjectURIs.AppendElement(aURI);
+}
+
+void nsIGlobalObject::UnregisterHostObjectURI(const nsACString& aURI) {
+  mHostObjectURIs.RemoveElement(aURI);
+}
+
+namespace {
+
+class UnlinkHostObjectURIsRunnable final : public mozilla::Runnable {
+ public:
+  explicit UnlinkHostObjectURIsRunnable(nsTArray<nsCString>&& aURIs)
+      : mozilla::Runnable("UnlinkHostObjectURIsRunnable"),
+        mURIs(std::move(aURIs)) {}
+
+  NS_IMETHOD Run() override {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    for (uint32_t index = 0; index < mURIs.Length(); ++index) {
+      BlobURLProtocolHandler::RemoveDataEntry(mURIs[index]);
+    }
+
+    return NS_OK;
+  }
+
+ private:
+  ~UnlinkHostObjectURIsRunnable() = default;
+
+  const nsTArray<nsCString> mURIs;
+};
+
+}  // namespace
+
+void nsIGlobalObject::UnlinkObjectsInGlobal() {
+  if (!mHostObjectURIs.IsEmpty()) {
+    // BlobURLProtocolHandler is main-thread only.
+    if (NS_IsMainThread()) {
+      for (uint32_t index = 0; index < mHostObjectURIs.Length(); ++index) {
+        BlobURLProtocolHandler::RemoveDataEntry(mHostObjectURIs[index]);
+      }
+
+      mHostObjectURIs.Clear();
+    } else {
+      RefPtr<UnlinkHostObjectURIsRunnable> runnable =
+          new UnlinkHostObjectURIsRunnable(std::move(mHostObjectURIs));
+      MOZ_ASSERT(mHostObjectURIs.IsEmpty());
+
+      nsresult rv = NS_DispatchToMainThread(runnable);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("Failed to dispatch a runnable to the main-thread.");
+      }
+    }
+  }
+
+  mReportRecords.Clear();
+  mReportingObservers.Clear();
+  mCountQueuingStrategySizeFunction = nullptr;
+  mByteLengthQueuingStrategySizeFunction = nullptr;
+}
+
+void nsIGlobalObject::TraverseObjectsInGlobal(
+    nsCycleCollectionTraversalCallback& cb) {
+  // Currently we only store BlobImpl objects off the the main-thread and they
+  // are not CCed.
+  if (!mHostObjectURIs.IsEmpty() && NS_IsMainThread()) {
+    for (uint32_t index = 0; index < mHostObjectURIs.Length(); ++index) {
+      BlobURLProtocolHandler::Traverse(mHostObjectURIs[index], cb);
+    }
+  }
+
+  nsIGlobalObject* tmp = this;
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mReportRecords)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mReportingObservers)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCountQueuingStrategySizeFunction)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mByteLengthQueuingStrategySizeFunction)
+}
+
+void nsIGlobalObject::AddGlobalTeardownObserver(
+    GlobalTeardownObserver* aObject) {
+  MOZ_DIAGNOSTIC_ASSERT(aObject);
+  MOZ_ASSERT(!aObject->isInList());
+  mGlobalTeardownObservers.insertBack(aObject);
+}
+
+void nsIGlobalObject::RemoveGlobalTeardownObserver(
+    GlobalTeardownObserver* aObject) {
+  MOZ_DIAGNOSTIC_ASSERT(aObject);
+  MOZ_ASSERT(aObject->isInList());
+  MOZ_ASSERT(aObject->GetOwnerGlobal() == this);
+  aObject->remove();
+}
+
+void nsIGlobalObject::ForEachGlobalTeardownObserver(
+    const std::function<void(GlobalTeardownObserver*, bool* aDoneOut)>& aFunc)
+    const {
+  // Protect against the function call triggering a mutation of the list
+  // while we are iterating by copying the DETH references to a temporary
+  // list.
+  AutoTArray<RefPtr<GlobalTeardownObserver>, 64> targetList;
+  for (const GlobalTeardownObserver* deth = mGlobalTeardownObservers.getFirst();
+       deth; deth = deth->getNext()) {
+    targetList.AppendElement(const_cast<GlobalTeardownObserver*>(deth));
+  }
+
+  // Iterate the target list and call the function on each one.
+  bool done = false;
+  for (auto target : targetList) {
+    // Check to see if a previous iteration's callback triggered the removal
+    // of this target as a side-effect.  If it did, then just ignore it.
+    if (target->GetOwnerGlobal() != this) {
+      continue;
+    }
+    aFunc(target, &done);
+    if (done) {
+      break;
+    }
+  }
+}
+
+void nsIGlobalObject::DisconnectGlobalTeardownObservers() {
+  ForEachGlobalTeardownObserver(
+      [&](GlobalTeardownObserver* aTarget, bool* aDoneOut) {
+        aTarget->DisconnectFromOwner();
+
+        // Calling DisconnectFromOwner() should result in
+        // RemoveGlobalTeardownObserver() being called.
+        MOZ_DIAGNOSTIC_ASSERT(aTarget->GetOwnerGlobal() != this);
+      });
+}
+
+Maybe<ClientInfo> nsIGlobalObject::GetClientInfo() const {
+  // By default globals do not expose themselves as a client.  Only real
+  // window and worker globals are currently considered clients.
+  return Maybe<ClientInfo>();
+}
+
+Maybe<nsID> nsIGlobalObject::GetAgentClusterId() const {
+  Maybe<ClientInfo> ci = GetClientInfo();
+  if (ci.isSome()) {
+    return ci.value().AgentClusterId();
+  }
+  return mozilla::Nothing();
+}
+
+Maybe<ServiceWorkerDescriptor> nsIGlobalObject::GetController() const {
+  // By default globals do not have a service worker controller.  Only real
+  // window and worker globals can currently be controlled as a client.
+  return Maybe<ServiceWorkerDescriptor>();
+}
+
+RefPtr<ServiceWorker> nsIGlobalObject::GetOrCreateServiceWorker(
+    const ServiceWorkerDescriptor& aDescriptor) {
+  MOZ_DIAGNOSTIC_ASSERT(false,
+                        "this global should not have any service workers");
+  return nullptr;
+}
+
+RefPtr<ServiceWorkerRegistration> nsIGlobalObject::GetServiceWorkerRegistration(
+    const mozilla::dom::ServiceWorkerRegistrationDescriptor& aDescriptor)
+    const {
+  MOZ_DIAGNOSTIC_ASSERT(false,
+                        "this global should not have any service workers");
+  return nullptr;
+}
+
+RefPtr<ServiceWorkerRegistration>
+nsIGlobalObject::GetOrCreateServiceWorkerRegistration(
+    const ServiceWorkerRegistrationDescriptor& aDescriptor) {
+  MOZ_DIAGNOSTIC_ASSERT(
+      false, "this global should not have any service worker registrations");
+  return nullptr;
+}
+
+mozilla::StorageAccess nsIGlobalObject::GetStorageAccess() {
+  return mozilla::StorageAccess::eDeny;
+}
+
+nsPIDOMWindowInner* nsIGlobalObject::AsInnerWindow() {
+  if (MOZ_LIKELY(mIsInnerWindow)) {
+    return static_cast<nsPIDOMWindowInner*>(
+        static_cast<nsGlobalWindowInner*>(this));
+  }
+  return nullptr;
+}
+
+size_t nsIGlobalObject::ShallowSizeOfExcludingThis(MallocSizeOf aSizeOf) const {
+  size_t rtn = mHostObjectURIs.ShallowSizeOfExcludingThis(aSizeOf);
+  return rtn;
+}
+
+class QueuedMicrotask : public MicroTaskRunnable {
+ public:
+  QueuedMicrotask(nsIGlobalObject* aGlobal, VoidFunction& aCallback)
+      : mGlobal(aGlobal), mCallback(&aCallback) {}
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void Run(AutoSlowOperation& aAso) final {
+    IgnoredErrorResult rv;
+    MOZ_KnownLive(mCallback)->Call(static_cast<ErrorResult&>(rv));
+  }
+
+  bool Suppressed() final { return mGlobal->IsInSyncOperation(); }
+
+ private:
+  nsCOMPtr<nsIGlobalObject> mGlobal;
+  RefPtr<VoidFunction> mCallback;
+};
+
+void nsIGlobalObject::QueueMicrotask(VoidFunction& aCallback) {
+  CycleCollectedJSContext* context = CycleCollectedJSContext::Get();
+  if (context) {
+    RefPtr<MicroTaskRunnable> mt = new QueuedMicrotask(this, aCallback);
+    context->DispatchToMicroTask(mt.forget());
+  }
+}
+
+void nsIGlobalObject::RegisterReportingObserver(ReportingObserver* aObserver,
+                                                bool aBuffered) {
+  MOZ_ASSERT(aObserver);
+
+  if (mReportingObservers.Contains(aObserver)) {
+    return;
+  }
+
+  if (NS_WARN_IF(
+          !mReportingObservers.AppendElement(aObserver, mozilla::fallible))) {
+    return;
+  }
+
+  if (!aBuffered) {
+    return;
+  }
+
+  for (Report* report : mReportRecords) {
+    aObserver->MaybeReport(report);
+  }
+}
+
+void nsIGlobalObject::UnregisterReportingObserver(
+    ReportingObserver* aObserver) {
+  MOZ_ASSERT(aObserver);
+  mReportingObservers.RemoveElement(aObserver);
+}
+
+void nsIGlobalObject::BroadcastReport(Report* aReport) {
+  MOZ_ASSERT(aReport);
+
+  for (ReportingObserver* observer : mReportingObservers) {
+    observer->MaybeReport(aReport);
+  }
+
+  if (NS_WARN_IF(!mReportRecords.AppendElement(aReport, mozilla::fallible))) {
+    return;
+  }
+
+  while (mReportRecords.Length() > MAX_REPORT_RECORDS) {
+    mReportRecords.RemoveElementAt(0);
+  }
+}
+
+void nsIGlobalObject::NotifyReportingObservers() {
+  for (auto& observer : mReportingObservers.Clone()) {
+    // MOZ_KnownLive because the clone of 'mReportingObservers' is guaranteed to
+    // keep it alive.
+    //
+    // This can go away once
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1620312 is fixed.
+    MOZ_KnownLive(observer)->MaybeNotify();
+  }
+}
+
+void nsIGlobalObject::RemoveReportRecords() {
+  mReportRecords.Clear();
+
+  for (auto& observer : mReportingObservers) {
+    observer->ForgetReports();
+  }
+}
+
+already_AddRefed<mozilla::dom::Function>
+nsIGlobalObject::GetCountQueuingStrategySizeFunction() {
+  return do_AddRef(mCountQueuingStrategySizeFunction);
+}
+
+void nsIGlobalObject::SetCountQueuingStrategySizeFunction(
+    mozilla::dom::Function* aFunction) {
+  mCountQueuingStrategySizeFunction = aFunction;
+}
+
+already_AddRefed<mozilla::dom::Function>
+nsIGlobalObject::GetByteLengthQueuingStrategySizeFunction() {
+  return do_AddRef(mByteLengthQueuingStrategySizeFunction);
+}
+
+void nsIGlobalObject::SetByteLengthQueuingStrategySizeFunction(
+    mozilla::dom::Function* aFunction) {
+  mByteLengthQueuingStrategySizeFunction = aFunction;
+}
+
+mozilla::Result<mozilla::ipc::PrincipalInfo, nsresult>
+nsIGlobalObject::GetStorageKey() {
+  return mozilla::Err(NS_ERROR_NOT_AVAILABLE);
+}
+
+mozilla::Result<bool, nsresult> nsIGlobalObject::HasEqualStorageKey(
+    const mozilla::ipc::PrincipalInfo& aStorageKey) {
+  auto result = GetStorageKey();
+  if (result.isErr()) {
+    return result.propagateErr();
+  }
+
+  const auto& storageKey = result.inspect();
+
+  return mozilla::ipc::StorageKeysEqual(storageKey, aStorageKey);
+}
+
+mozilla::RTPCallerType nsIGlobalObject::GetRTPCallerType() const {
+  if (PrincipalOrNull() && PrincipalOrNull()->IsSystemPrincipal()) {
+    return RTPCallerType::SystemPrincipal;
+  }
+
+  if (ShouldResistFingerprinting(RFPTarget::Unknown)) {
+    return RTPCallerType::ResistFingerprinting;
+  }
+
+  if (CrossOriginIsolated()) {
+    return RTPCallerType::CrossOriginIsolated;
+  }
+
+  return RTPCallerType::Normal;
+}
+
+bool nsIGlobalObject::ShouldResistFingerprinting(CallerType aCallerType,
+                                                 RFPTarget aTarget) const {
+  return aCallerType != CallerType::System &&
+         ShouldResistFingerprinting(aTarget);
+}