From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- dom/workers/sharedworkers/PSharedWorker.ipdl | 40 ++ dom/workers/sharedworkers/SharedWorker.cpp | 426 ++++++++++++++++++++++ dom/workers/sharedworkers/SharedWorker.h | 94 +++++ dom/workers/sharedworkers/SharedWorkerChild.cpp | 155 ++++++++ dom/workers/sharedworkers/SharedWorkerChild.h | 61 ++++ dom/workers/sharedworkers/SharedWorkerManager.cpp | 348 ++++++++++++++++++ dom/workers/sharedworkers/SharedWorkerManager.h | 164 +++++++++ dom/workers/sharedworkers/SharedWorkerParent.cpp | 165 +++++++++ dom/workers/sharedworkers/SharedWorkerParent.h | 81 ++++ dom/workers/sharedworkers/SharedWorkerService.cpp | 263 +++++++++++++ dom/workers/sharedworkers/SharedWorkerService.h | 74 ++++ dom/workers/sharedworkers/moz.build | 28 ++ 12 files changed, 1899 insertions(+) create mode 100644 dom/workers/sharedworkers/PSharedWorker.ipdl create mode 100644 dom/workers/sharedworkers/SharedWorker.cpp create mode 100644 dom/workers/sharedworkers/SharedWorker.h create mode 100644 dom/workers/sharedworkers/SharedWorkerChild.cpp create mode 100644 dom/workers/sharedworkers/SharedWorkerChild.h create mode 100644 dom/workers/sharedworkers/SharedWorkerManager.cpp create mode 100644 dom/workers/sharedworkers/SharedWorkerManager.h create mode 100644 dom/workers/sharedworkers/SharedWorkerParent.cpp create mode 100644 dom/workers/sharedworkers/SharedWorkerParent.h create mode 100644 dom/workers/sharedworkers/SharedWorkerService.cpp create mode 100644 dom/workers/sharedworkers/SharedWorkerService.h create mode 100644 dom/workers/sharedworkers/moz.build (limited to 'dom/workers/sharedworkers') diff --git a/dom/workers/sharedworkers/PSharedWorker.ipdl b/dom/workers/sharedworkers/PSharedWorker.ipdl new file mode 100644 index 0000000000..2406a731da --- /dev/null +++ b/dom/workers/sharedworkers/PSharedWorker.ipdl @@ -0,0 +1,40 @@ +/* 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 protocol PBackground; + +include RemoteWorkerTypes; + +namespace mozilla { +namespace dom { + +/** + * Protocol for SharedWorker bindings to communicate with per-worker + * SharedWorkerManager instances in the parent via SharedWorkerChild / + * SharedWorkerParent and SharedWorkerService getting/creating the + * SharedWorkerManager if it doesn't already exist. Main-thread to PBackground. + */ +[ManualDealloc] +protocol PSharedWorker +{ + manager PBackground; + +parent: + async Close(); + async Suspend(); + async Resume(); + async Freeze(); + async Thaw(); + +child: + async Error(ErrorValue value); + async NotifyLock(bool aCreated); + async NotifyWebTransport(bool aCreated); + async Terminate(); + + async __delete__(); +}; + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/sharedworkers/SharedWorker.cpp b/dom/workers/sharedworkers/SharedWorker.cpp new file mode 100644 index 0000000000..b5aa7d9e2e --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorker.cpp @@ -0,0 +1,426 @@ +/* -*- 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 "SharedWorker.h" + +#include "mozilla/AntiTrackingUtils.h" +#include "mozilla/AsyncEventDispatcher.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/EventDispatcher.h" +#include "mozilla/dom/ClientInfo.h" +#include "mozilla/dom/Event.h" +#include "mozilla/dom/MessageChannel.h" +#include "mozilla/dom/MessagePort.h" +#include "mozilla/dom/PMessagePort.h" +#include "mozilla/dom/RemoteWorkerManager.h" // RemoteWorkerManager::GetRemoteType +#include "mozilla/dom/RemoteWorkerTypes.h" +#include "mozilla/dom/SharedWorkerBinding.h" +#include "mozilla/dom/SharedWorkerChild.h" +#include "mozilla/dom/WorkerBinding.h" +#include "mozilla/dom/WorkerLoadInfo.h" +#include "mozilla/dom/WorkerPrivate.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "mozilla/ipc/PBackgroundChild.h" +#include "mozilla/ipc/URIUtils.h" +#include "mozilla/net/CookieJarSettings.h" +#include "mozilla/StorageAccess.h" +#include "nsGlobalWindowInner.h" +#include "nsPIDOMWindow.h" + +#ifdef XP_WIN +# undef PostMessage +#endif + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::ipc; + +SharedWorker::SharedWorker(nsPIDOMWindowInner* aWindow, + SharedWorkerChild* aActor, MessagePort* aMessagePort) + : DOMEventTargetHelper(aWindow), + mWindow(aWindow), + mActor(aActor), + mMessagePort(aMessagePort), + mFrozen(false) { + AssertIsOnMainThread(); + MOZ_ASSERT(aActor); + MOZ_ASSERT(aMessagePort); +} + +SharedWorker::~SharedWorker() { + AssertIsOnMainThread(); + Close(); +} + +// static +already_AddRefed SharedWorker::Constructor( + const GlobalObject& aGlobal, const nsAString& aScriptURL, + const StringOrWorkerOptions& aOptions, ErrorResult& aRv) { + AssertIsOnMainThread(); + + nsCOMPtr window = + do_QueryInterface(aGlobal.GetAsSupports()); + MOZ_ASSERT(window); + + // Our current idiom is that storage-related APIs specialize for the system + // principal themselves, which is consistent with StorageAllowedForwindow not + // specializing for the system principal. Without this specialization we + // would end up with ePrivateBrowsing for system principaled private browsing + // windows which is explicitly not what we want. System Principal code always + // should have access to storage. It may make sense to enhance + // StorageAllowedForWindow in the future to handle this after comprehensive + // auditing. + nsCOMPtr principal = aGlobal.GetSubjectPrincipal(); + StorageAccess storageAllowed; + if (principal && principal->IsSystemPrincipal()) { + storageAllowed = StorageAccess::eAllow; + } else { + storageAllowed = StorageAllowedForWindow(window); + } + + if (storageAllowed == StorageAccess::eDeny) { + aRv.Throw(NS_ERROR_DOM_SECURITY_ERR); + return nullptr; + } + + if (ShouldPartitionStorage(storageAllowed) && + !StoragePartitioningEnabled( + storageAllowed, window->GetExtantDoc()->CookieJarSettings())) { + aRv.Throw(NS_ERROR_DOM_SECURITY_ERR); + return nullptr; + } + + // Assert that the principal private browsing state matches the + // StorageAccess value. +#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED + if (storageAllowed == StorageAccess::ePrivateBrowsing) { + uint32_t privateBrowsingId = 0; + if (principal) { + MOZ_ALWAYS_SUCCEEDS(principal->GetPrivateBrowsingId(&privateBrowsingId)); + } + MOZ_DIAGNOSTIC_ASSERT(privateBrowsingId != 0); + } +#endif // MOZ_DIAGNOSTIC_ASSERT_ENABLED + + nsAutoString name; + WorkerType workerType = WorkerType::Classic; + RequestCredentials credentials = RequestCredentials::Omit; + if (aOptions.IsString()) { + name = aOptions.GetAsString(); + } else { + MOZ_ASSERT(aOptions.IsWorkerOptions()); + name = aOptions.GetAsWorkerOptions().mName; + workerType = aOptions.GetAsWorkerOptions().mType; + credentials = aOptions.GetAsWorkerOptions().mCredentials; + } + + JSContext* cx = aGlobal.Context(); + + WorkerLoadInfo loadInfo; + aRv = WorkerPrivate::GetLoadInfo( + cx, window, nullptr, aScriptURL, workerType, credentials, false, + WorkerPrivate::OverrideLoadGroup, WorkerKindShared, &loadInfo); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + PrincipalInfo principalInfo; + aRv = PrincipalToPrincipalInfo(loadInfo.mPrincipal, &principalInfo); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + PrincipalInfo loadingPrincipalInfo; + aRv = PrincipalToPrincipalInfo(loadInfo.mLoadingPrincipal, + &loadingPrincipalInfo); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + // Here, the PartitionedPrincipal is always equal to the SharedWorker's + // principal because the channel is not opened yet, and, because of this, it's + // not classified. We need to force the correct originAttributes. + // + // The sharedWorker's principal could be a null principal, e.g. loading a + // data url. In this case, we don't need to force the OAs for the partitioned + // principal because creating storage from a null principal will fail anyway. + // We should only do this for content principals. + // + // You can find more details in StoragePrincipalHelper.h + if (ShouldPartitionStorage(storageAllowed) && + BasePrincipal::Cast(loadInfo.mPrincipal)->IsContentPrincipal()) { + nsCOMPtr sop = do_QueryInterface(window); + if (!sop) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + nsIPrincipal* windowPrincipal = sop->GetPrincipal(); + if (!windowPrincipal) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + + nsIPrincipal* windowPartitionedPrincipal = sop->PartitionedPrincipal(); + if (!windowPartitionedPrincipal) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + + if (!windowPrincipal->Equals(windowPartitionedPrincipal)) { + loadInfo.mPartitionedPrincipal = + BasePrincipal::Cast(loadInfo.mPrincipal) + ->CloneForcingOriginAttributes( + BasePrincipal::Cast(windowPartitionedPrincipal) + ->OriginAttributesRef()); + } + } + + PrincipalInfo partitionedPrincipalInfo; + if (loadInfo.mPrincipal->Equals(loadInfo.mPartitionedPrincipal)) { + partitionedPrincipalInfo = principalInfo; + } else { + aRv = PrincipalToPrincipalInfo(loadInfo.mPartitionedPrincipal, + &partitionedPrincipalInfo); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + } + + // We don't actually care about this MessageChannel, but we use it to 'steal' + // its 2 connected ports. + nsCOMPtr global = do_QueryInterface(window); + RefPtr channel = MessageChannel::Constructor(global, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + UniqueMessagePortId portIdentifier; + channel->Port1()->CloneAndDisentangle(portIdentifier); + + URIParams resolvedScriptURL; + SerializeURI(loadInfo.mResolvedScriptURI, resolvedScriptURL); + + URIParams baseURL; + SerializeURI(loadInfo.mBaseURI, baseURL); + + // Register this component to PBackground. + PBackgroundChild* actorChild = BackgroundChild::GetOrCreateForCurrentThread(); + + bool isSecureContext = JS::GetIsSecureContext(js::GetContextRealm(cx)); + + Maybe ipcClientInfo; + Maybe clientInfo = window->GetClientInfo(); + if (clientInfo.isSome()) { + ipcClientInfo.emplace(clientInfo.value().ToIPC()); + } + + nsID agentClusterId = nsID::GenerateUUID(); + + net::CookieJarSettingsArgs cjsData; + MOZ_ASSERT(loadInfo.mCookieJarSettings); + net::CookieJarSettings::Cast(loadInfo.mCookieJarSettings)->Serialize(cjsData); + + auto remoteType = RemoteWorkerManager::GetRemoteType( + loadInfo.mPrincipal, WorkerKind::WorkerKindShared); + if (NS_WARN_IF(remoteType.isErr())) { + aRv.Throw(remoteType.unwrapErr()); + return nullptr; + } + + RemoteWorkerData remoteWorkerData( + nsString(aScriptURL), baseURL, resolvedScriptURL, name, workerType, + credentials, loadingPrincipalInfo, principalInfo, + partitionedPrincipalInfo, loadInfo.mUseRegularPrincipal, + loadInfo.mHasStorageAccessPermissionGranted, cjsData, loadInfo.mDomain, + isSecureContext, ipcClientInfo, loadInfo.mReferrerInfo, storageAllowed, + AntiTrackingUtils::IsThirdPartyWindow(window, nullptr), + loadInfo.mShouldResistFingerprinting, + OriginTrials::FromWindow(nsGlobalWindowInner::Cast(window)), + void_t() /* OptionalServiceWorkerData */, agentClusterId, + remoteType.unwrap()); + + PSharedWorkerChild* pActor = actorChild->SendPSharedWorkerConstructor( + remoteWorkerData, loadInfo.mWindowID, portIdentifier.release()); + + RefPtr actor = static_cast(pActor); + MOZ_ASSERT(actor); + + RefPtr sharedWorker = + new SharedWorker(window, actor, channel->Port2()); + + // Let's inform the window about this SharedWorker. + nsGlobalWindowInner::Cast(window)->StoreSharedWorker(sharedWorker); + actor->SetParent(sharedWorker); + + if (nsGlobalWindowInner::Cast(window)->IsSuspended()) { + sharedWorker->Suspend(); + } + + return sharedWorker.forget(); +} + +MessagePort* SharedWorker::Port() { + AssertIsOnMainThread(); + return mMessagePort; +} + +void SharedWorker::Freeze() { + AssertIsOnMainThread(); + MOZ_ASSERT(!IsFrozen()); + + if (mFrozen) { + return; + } + + mFrozen = true; + + if (mActor) { + mActor->SendFreeze(); + } +} + +void SharedWorker::Thaw() { + AssertIsOnMainThread(); + MOZ_ASSERT(IsFrozen()); + + if (!mFrozen) { + return; + } + + mFrozen = false; + + if (mActor) { + mActor->SendThaw(); + } + + if (!mFrozenEvents.IsEmpty()) { + nsTArray> events = std::move(mFrozenEvents); + + for (uint32_t index = 0; index < events.Length(); index++) { + RefPtr& event = events[index]; + MOZ_ASSERT(event); + + RefPtr target = event->GetTarget(); + ErrorResult rv; + target->DispatchEvent(*event, rv); + if (rv.Failed()) { + NS_WARNING("Failed to dispatch event!"); + } + } + } +} + +void SharedWorker::QueueEvent(Event* aEvent) { + AssertIsOnMainThread(); + MOZ_ASSERT(aEvent); + MOZ_ASSERT(IsFrozen()); + + mFrozenEvents.AppendElement(aEvent); +} + +void SharedWorker::Close() { + AssertIsOnMainThread(); + + if (mWindow) { + nsGlobalWindowInner::Cast(mWindow)->ForgetSharedWorker(this); + mWindow = nullptr; + } + + if (mActor) { + mActor->SendClose(); + mActor->SetParent(nullptr); + mActor = nullptr; + } + + if (mMessagePort) { + mMessagePort->Close(); + } +} + +void SharedWorker::Suspend() { + if (mActor) { + mActor->SendSuspend(); + } +} + +void SharedWorker::Resume() { + if (mActor) { + mActor->SendResume(); + } +} + +void SharedWorker::PostMessage(JSContext* aCx, JS::Handle aMessage, + const Sequence& aTransferable, + ErrorResult& aRv) { + AssertIsOnMainThread(); + MOZ_ASSERT(mMessagePort); + + mMessagePort->PostMessage(aCx, aMessage, aTransferable, aRv); +} + +NS_IMPL_ADDREF_INHERITED(SharedWorker, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(SharedWorker, DOMEventTargetHelper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SharedWorker) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +NS_IMPL_CYCLE_COLLECTION_CLASS(SharedWorker) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(SharedWorker, + DOMEventTargetHelper) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMessagePort) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFrozenEvents) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(SharedWorker, + DOMEventTargetHelper) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mMessagePort) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mFrozenEvents) +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +JSObject* SharedWorker::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) { + AssertIsOnMainThread(); + + return SharedWorker_Binding::Wrap(aCx, this, aGivenProto); +} + +void SharedWorker::GetEventTargetParent(EventChainPreVisitor& aVisitor) { + AssertIsOnMainThread(); + + if (IsFrozen()) { + RefPtr event = aVisitor.mDOMEvent; + if (!event) { + event = EventDispatcher::CreateEvent(aVisitor.mEvent->mOriginalTarget, + aVisitor.mPresContext, + aVisitor.mEvent, u""_ns); + } + + QueueEvent(event); + + aVisitor.mCanHandle = false; + aVisitor.SetParentTarget(nullptr, false); + return; + } + + DOMEventTargetHelper::GetEventTargetParent(aVisitor); +} + +void SharedWorker::ErrorPropagation(nsresult aError) { + AssertIsOnMainThread(); + MOZ_ASSERT(mActor); + MOZ_ASSERT(NS_FAILED(aError)); + + RefPtr errorEvent = + new AsyncEventDispatcher(this, u"error"_ns, CanBubble::eNo); + errorEvent->PostDOMEvent(); + + Close(); +} diff --git a/dom/workers/sharedworkers/SharedWorker.h b/dom/workers/sharedworkers/SharedWorker.h new file mode 100644 index 0000000000..8318021236 --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorker.h @@ -0,0 +1,94 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_workers_sharedworker_h__ +#define mozilla_dom_workers_sharedworker_h__ + +#include "mozilla/dom/WorkerCommon.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/DOMEventTargetHelper.h" + +#ifdef XP_WIN +# undef PostMessage +#endif + +class nsPIDOMWindowInner; + +namespace mozilla { +class EventChainPreVisitor; + +namespace dom { +class MessagePort; +class StringOrWorkerOptions; +class Event; + +class SharedWorkerChild; + +/** + * DOM binding. Holds a SharedWorkerChild. Must exist on the main thread because + * we only allow top-level windows to create SharedWorkers. + */ +class SharedWorker final : public DOMEventTargetHelper { + using ErrorResult = mozilla::ErrorResult; + using GlobalObject = mozilla::dom::GlobalObject; + + RefPtr mWindow; + RefPtr mActor; + RefPtr mMessagePort; + nsTArray> mFrozenEvents; + bool mFrozen; + + public: + static already_AddRefed Constructor( + const GlobalObject& aGlobal, const nsAString& aScriptURL, + const StringOrWorkerOptions& aOptions, ErrorResult& aRv); + + MessagePort* Port(); + + bool IsFrozen() const { return mFrozen; } + + void QueueEvent(Event* aEvent); + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(SharedWorker, DOMEventTargetHelper) + + IMPL_EVENT_HANDLER(error) + + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + + void GetEventTargetParent(EventChainPreVisitor& aVisitor) override; + + void ErrorPropagation(nsresult aError); + + // Methods called from the window. + + void Close(); + + void Suspend(); + + void Resume(); + + void Freeze(); + + void Thaw(); + + private: + SharedWorker(nsPIDOMWindowInner* aWindow, SharedWorkerChild* aActor, + MessagePort* aMessagePort); + + // This class is reference-counted and will be destroyed from Release(). + ~SharedWorker(); + + // Only called by MessagePort. + void PostMessage(JSContext* aCx, JS::Handle aMessage, + const Sequence& aTransferable, ErrorResult& aRv); +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_workers_sharedworker_h__ diff --git a/dom/workers/sharedworkers/SharedWorkerChild.cpp b/dom/workers/sharedworkers/SharedWorkerChild.cpp new file mode 100644 index 0000000000..b11fffdcf4 --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorkerChild.cpp @@ -0,0 +1,155 @@ +/* -*- 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 "SharedWorkerChild.h" +#include "mozilla/dom/ErrorEvent.h" +#include "mozilla/dom/ErrorEventBinding.h" +#include "mozilla/dom/Exceptions.h" +#include "mozilla/dom/RootedDictionary.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/SharedWorker.h" +#include "mozilla/dom/WebTransport.h" +#include "mozilla/dom/WindowGlobalChild.h" +#include "mozilla/dom/WorkerError.h" +#include "mozilla/dom/locks/LockManagerChild.h" + +namespace mozilla { + +using namespace ipc; + +namespace dom { + +SharedWorkerChild::SharedWorkerChild() : mParent(nullptr), mActive(true) {} + +SharedWorkerChild::~SharedWorkerChild() = default; + +void SharedWorkerChild::ActorDestroy(ActorDestroyReason aWhy) { + mActive = false; +} + +void SharedWorkerChild::SendClose() { + if (mActive) { + // This is the last message. + mActive = false; + PSharedWorkerChild::SendClose(); + } +} + +void SharedWorkerChild::SendSuspend() { + if (mActive) { + PSharedWorkerChild::SendSuspend(); + } +} + +void SharedWorkerChild::SendResume() { + if (mActive) { + PSharedWorkerChild::SendResume(); + } +} + +void SharedWorkerChild::SendFreeze() { + if (mActive) { + PSharedWorkerChild::SendFreeze(); + } +} + +void SharedWorkerChild::SendThaw() { + if (mActive) { + PSharedWorkerChild::SendThaw(); + } +} + +IPCResult SharedWorkerChild::RecvError(const ErrorValue& aValue) { + if (!mParent) { + return IPC_OK(); + } + + if (aValue.type() == ErrorValue::Tnsresult) { + mParent->ErrorPropagation(aValue.get_nsresult()); + return IPC_OK(); + } + + nsPIDOMWindowInner* window = mParent->GetOwner(); + uint64_t innerWindowId = window ? window->WindowID() : 0; + + if (aValue.type() == ErrorValue::TErrorData && + aValue.get_ErrorData().isWarning()) { + // Don't fire any events for warnings. Just log to console. + WorkerErrorReport::LogErrorToConsole(aValue.get_ErrorData(), innerWindowId); + return IPC_OK(); + } + + AutoJSAPI jsapi; + jsapi.Init(); + + RefPtr event; + if (aValue.type() == ErrorValue::TErrorData) { + const ErrorData& errorData = aValue.get_ErrorData(); + RootedDictionary errorInit(jsapi.cx()); + errorInit.mBubbles = false; + errorInit.mCancelable = true; + errorInit.mMessage = errorData.message(); + errorInit.mFilename = errorData.filename(); + errorInit.mLineno = errorData.lineNumber(); + errorInit.mColno = errorData.columnNumber(); + + event = ErrorEvent::Constructor(mParent, u"error"_ns, errorInit); + } else { + event = Event::Constructor(mParent, u"error"_ns, EventInit()); + } + event->SetTrusted(true); + + ErrorResult res; + bool defaultActionEnabled = + mParent->DispatchEvent(*event, CallerType::System, res); + if (res.Failed()) { + ThrowAndReport(window, res.StealNSResult()); + return IPC_OK(); + } + + if (aValue.type() != ErrorValue::TErrorData) { + MOZ_ASSERT(aValue.type() == ErrorValue::Tvoid_t); + return IPC_OK(); + } + + if (defaultActionEnabled) { + WorkerErrorReport::LogErrorToConsole(aValue.get_ErrorData(), innerWindowId); + } + + return IPC_OK(); +} + +IPCResult SharedWorkerChild::RecvNotifyLock(bool aCreated) { + if (!mParent) { + return IPC_OK(); + } + + locks::LockManagerChild::NotifyBFCacheOnMainThread(mParent->GetOwner(), + aCreated); + + return IPC_OK(); +} + +IPCResult SharedWorkerChild::RecvNotifyWebTransport(bool aCreated) { + if (!mParent) { + return IPC_OK(); + } + + WebTransport::NotifyBFCacheOnMainThread(mParent->GetOwner(), aCreated); + + return IPC_OK(); +} + +IPCResult SharedWorkerChild::RecvTerminate() { + if (mParent) { + mParent->Close(); + } + + return IPC_OK(); +} + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/sharedworkers/SharedWorkerChild.h b/dom/workers/sharedworkers/SharedWorkerChild.h new file mode 100644 index 0000000000..c899589320 --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorkerChild.h @@ -0,0 +1,61 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_dom_SharedWorkerChild_h +#define mozilla_dom_dom_SharedWorkerChild_h + +#include "mozilla/dom/PSharedWorkerChild.h" +#include "nsISupportsImpl.h" + +namespace mozilla::dom { + +class SharedWorker; + +/** + * Held by SharedWorker bindings to remotely control sharedworker lifecycle and + * receive error and termination reports. + */ +class SharedWorkerChild final : public mozilla::dom::PSharedWorkerChild { + friend class PSharedWorkerChild; + + public: + NS_INLINE_DECL_REFCOUNTING(SharedWorkerChild) + + SharedWorkerChild(); + + void SetParent(SharedWorker* aSharedWorker) { mParent = aSharedWorker; } + + void SendClose(); + + void SendSuspend(); + + void SendResume(); + + void SendFreeze(); + + void SendThaw(); + + private: + ~SharedWorkerChild(); + + mozilla::ipc::IPCResult RecvError(const ErrorValue& aValue); + + mozilla::ipc::IPCResult RecvNotifyLock(bool aCreated); + + mozilla::ipc::IPCResult RecvNotifyWebTransport(bool aCreated); + + mozilla::ipc::IPCResult RecvTerminate(); + + void ActorDestroy(ActorDestroyReason aWhy) override; + + // Raw pointer because mParent is set to null when released. + SharedWorker* MOZ_NON_OWNING_REF mParent; + bool mActive; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_dom_SharedWorkerChild_h diff --git a/dom/workers/sharedworkers/SharedWorkerManager.cpp b/dom/workers/sharedworkers/SharedWorkerManager.cpp new file mode 100644 index 0000000000..37dbc700d9 --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorkerManager.cpp @@ -0,0 +1,348 @@ +/* -*- 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 "SharedWorkerManager.h" +#include "SharedWorkerParent.h" +#include "SharedWorkerService.h" +#include "mozilla/dom/MessagePort.h" +#include "mozilla/dom/PSharedWorker.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/ipc/URIUtils.h" +#include "mozilla/dom/RemoteWorkerController.h" +#include "nsIConsoleReportCollector.h" +#include "nsIPrincipal.h" +#include "nsProxyRelease.h" + +namespace mozilla::dom { + +// static +already_AddRefed SharedWorkerManager::Create( + SharedWorkerService* aService, nsIEventTarget* aPBackgroundEventTarget, + const RemoteWorkerData& aData, nsIPrincipal* aLoadingPrincipal, + const OriginAttributes& aEffectiveStoragePrincipalAttrs) { + MOZ_ASSERT(NS_IsMainThread()); + + RefPtr manager = + new SharedWorkerManager(aPBackgroundEventTarget, aData, aLoadingPrincipal, + aEffectiveStoragePrincipalAttrs); + + RefPtr holder = + new SharedWorkerManagerHolder(manager, aService); + return holder.forget(); +} + +SharedWorkerManager::SharedWorkerManager( + nsIEventTarget* aPBackgroundEventTarget, const RemoteWorkerData& aData, + nsIPrincipal* aLoadingPrincipal, + const OriginAttributes& aEffectiveStoragePrincipalAttrs) + : mPBackgroundEventTarget(aPBackgroundEventTarget), + mLoadingPrincipal(aLoadingPrincipal), + mDomain(aData.domain()), + mEffectiveStoragePrincipalAttrs(aEffectiveStoragePrincipalAttrs), + mResolvedScriptURL(DeserializeURI(aData.resolvedScriptURL())), + mName(aData.name()), + mIsSecureContext(aData.isSecureContext()), + mSuspended(false), + mFrozen(false) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aLoadingPrincipal); +} + +SharedWorkerManager::~SharedWorkerManager() { + NS_ReleaseOnMainThread("SharedWorkerManager::mLoadingPrincipal", + mLoadingPrincipal.forget()); + NS_ProxyRelease("SharedWorkerManager::mRemoteWorkerController", + mPBackgroundEventTarget, mRemoteWorkerController.forget()); +} + +bool SharedWorkerManager::MaybeCreateRemoteWorker( + const RemoteWorkerData& aData, uint64_t aWindowID, + UniqueMessagePortId& aPortIdentifier, base::ProcessId aProcessId) { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + + // Creating remote workers may result in creating new processes, but during + // parent shutdown that would add just noise, so better bail out. + if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) { + return false; + } + + if (!mRemoteWorkerController) { + mRemoteWorkerController = + RemoteWorkerController::Create(aData, this, aProcessId); + if (NS_WARN_IF(!mRemoteWorkerController)) { + return false; + } + } + + if (aWindowID) { + mRemoteWorkerController->AddWindowID(aWindowID); + } + + mRemoteWorkerController->AddPortIdentifier(aPortIdentifier.release()); + return true; +} + +already_AddRefed +SharedWorkerManager::MatchOnMainThread( + SharedWorkerService* aService, const nsACString& aDomain, + nsIURI* aScriptURL, const nsAString& aName, nsIPrincipal* aLoadingPrincipal, + const OriginAttributes& aEffectiveStoragePrincipalAttrs) { + MOZ_ASSERT(NS_IsMainThread()); + + bool urlEquals; + if (NS_FAILED(aScriptURL->Equals(mResolvedScriptURL, &urlEquals))) { + return nullptr; + } + + bool match = + aDomain == mDomain && urlEquals && aName == mName && + // We want to be sure that the window's principal subsumes the + // SharedWorker's loading principal and vice versa. + mLoadingPrincipal->Subsumes(aLoadingPrincipal) && + aLoadingPrincipal->Subsumes(mLoadingPrincipal) && + mEffectiveStoragePrincipalAttrs == aEffectiveStoragePrincipalAttrs; + if (!match) { + return nullptr; + } + + RefPtr holder = + new SharedWorkerManagerHolder(this, aService); + return holder.forget(); +} + +void SharedWorkerManager::AddActor(SharedWorkerParent* aParent) { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + MOZ_ASSERT(aParent); + MOZ_ASSERT(!mActors.Contains(aParent)); + + mActors.AppendElement(aParent); + + if (mLockCount) { + Unused << aParent->SendNotifyLock(true); + } + + if (mWebTransportCount) { + Unused << aParent->SendNotifyWebTransport(true); + } + + // NB: We don't update our Suspended/Frozen state here, yet. The aParent is + // responsible for doing so from SharedWorkerParent::ManagerCreated. + // XXX But we could avoid iterating all of our actors because if aParent is + // not frozen and we are, we would just need to thaw ourselves. +} + +void SharedWorkerManager::RemoveActor(SharedWorkerParent* aParent) { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + MOZ_ASSERT(aParent); + MOZ_ASSERT(mActors.Contains(aParent)); + + uint64_t windowID = aParent->WindowID(); + if (windowID) { + mRemoteWorkerController->RemoveWindowID(windowID); + } + + mActors.RemoveElement(aParent); + + if (!mActors.IsEmpty()) { + // Our remaining actors could be all suspended or frozen. + UpdateSuspend(); + UpdateFrozen(); + return; + } +} + +void SharedWorkerManager::Terminate() { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + MOZ_ASSERT(mActors.IsEmpty()); + MOZ_ASSERT(mHolders.IsEmpty()); + + // mRemoteWorkerController creation can fail. If the creation fails + // mRemoteWorkerController is nullptr and we should stop termination here. + if (!mRemoteWorkerController) { + return; + } + + mRemoteWorkerController->Terminate(); + mRemoteWorkerController = nullptr; +} + +void SharedWorkerManager::UpdateSuspend() { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + MOZ_ASSERT(mRemoteWorkerController); + + uint32_t suspended = 0; + + for (SharedWorkerParent* actor : mActors) { + if (actor->IsSuspended()) { + ++suspended; + } + } + + // Call Suspend only when all of our actors' windows are suspended and call + // Resume only when one of them resumes. + if ((mSuspended && suspended == mActors.Length()) || + (!mSuspended && suspended != mActors.Length())) { + return; + } + + if (!mSuspended) { + mSuspended = true; + mRemoteWorkerController->Suspend(); + } else { + mSuspended = false; + mRemoteWorkerController->Resume(); + } +} + +void SharedWorkerManager::UpdateFrozen() { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + MOZ_ASSERT(mRemoteWorkerController); + + uint32_t frozen = 0; + + for (SharedWorkerParent* actor : mActors) { + if (actor->IsFrozen()) { + ++frozen; + } + } + + // Similar to UpdateSuspend, above, we only want to be frozen when all of our + // actors are frozen. + if ((mFrozen && frozen == mActors.Length()) || + (!mFrozen && frozen != mActors.Length())) { + return; + } + + if (!mFrozen) { + mFrozen = true; + mRemoteWorkerController->Freeze(); + } else { + mFrozen = false; + mRemoteWorkerController->Thaw(); + } +} + +bool SharedWorkerManager::IsSecureContext() const { return mIsSecureContext; } + +void SharedWorkerManager::CreationFailed() { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + + for (SharedWorkerParent* actor : mActors) { + Unused << actor->SendError(NS_ERROR_FAILURE); + } +} + +void SharedWorkerManager::CreationSucceeded() { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + // Nothing to do here. +} + +void SharedWorkerManager::ErrorReceived(const ErrorValue& aValue) { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + + for (SharedWorkerParent* actor : mActors) { + Unused << actor->SendError(aValue); + } +} + +void SharedWorkerManager::LockNotified(bool aCreated) { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + MOZ_ASSERT_IF(!aCreated, mLockCount > 0); + + mLockCount += aCreated ? 1 : -1; + + // Notify only when we either: + // 1. Got a new lock when nothing were there + // 2. Lost all locks + if ((aCreated && mLockCount == 1) || !mLockCount) { + for (SharedWorkerParent* actor : mActors) { + Unused << actor->SendNotifyLock(aCreated); + } + } +}; + +void SharedWorkerManager::WebTransportNotified(bool aCreated) { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + MOZ_ASSERT_IF(!aCreated, mWebTransportCount > 0); + + mWebTransportCount += aCreated ? 1 : -1; + + // Notify only when we either: + // 1. Got a first WebTransport + // 2. The last WebTransport goes away + if ((aCreated && mWebTransportCount == 1) || mWebTransportCount == 0) { + for (SharedWorkerParent* actor : mActors) { + Unused << actor->SendNotifyWebTransport(aCreated); + } + } +}; + +void SharedWorkerManager::Terminated() { + ::mozilla::ipc::AssertIsOnBackgroundThread(); + + for (SharedWorkerParent* actor : mActors) { + Unused << actor->SendTerminate(); + } +} + +void SharedWorkerManager::RegisterHolder(SharedWorkerManagerHolder* aHolder) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aHolder); + MOZ_ASSERT(!mHolders.Contains(aHolder)); + + mHolders.AppendElement(aHolder); +} + +void SharedWorkerManager::UnregisterHolder(SharedWorkerManagerHolder* aHolder) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aHolder); + MOZ_ASSERT(mHolders.Contains(aHolder)); + + mHolders.RemoveElement(aHolder); + + if (!mHolders.IsEmpty()) { + return; + } + + // Time to go. + + aHolder->Service()->RemoveWorkerManagerOnMainThread(this); + + RefPtr self = this; + mPBackgroundEventTarget->Dispatch( + NS_NewRunnableFunction( + "SharedWorkerService::RemoveWorkerManagerOnMainThread", + [self]() { self->Terminate(); }), + NS_DISPATCH_NORMAL); +} + +SharedWorkerManagerHolder::SharedWorkerManagerHolder( + SharedWorkerManager* aManager, SharedWorkerService* aService) + : mManager(aManager), mService(aService) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aManager); + MOZ_ASSERT(aService); + + aManager->RegisterHolder(this); +} + +SharedWorkerManagerHolder::~SharedWorkerManagerHolder() { + MOZ_ASSERT(NS_IsMainThread()); + mManager->UnregisterHolder(this); +} + +SharedWorkerManagerWrapper::SharedWorkerManagerWrapper( + already_AddRefed aHolder) + : mHolder(aHolder) { + MOZ_ASSERT(NS_IsMainThread()); +} + +SharedWorkerManagerWrapper::~SharedWorkerManagerWrapper() { + NS_ReleaseOnMainThread("SharedWorkerManagerWrapper::mHolder", + mHolder.forget()); +} + +} // namespace mozilla::dom diff --git a/dom/workers/sharedworkers/SharedWorkerManager.h b/dom/workers/sharedworkers/SharedWorkerManager.h new file mode 100644 index 0000000000..fceabca4d4 --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorkerManager.h @@ -0,0 +1,164 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_SharedWorkerManager_h +#define mozilla_dom_SharedWorkerManager_h + +#include "SharedWorkerParent.h" +#include "mozilla/dom/RemoteWorkerController.h" +#include "mozilla/dom/quota/CheckedUnsafePtr.h" +#include "nsISupportsImpl.h" +#include "nsTArray.h" + +class nsIPrincipal; + +namespace mozilla::dom { + +class UniqueMessagePortId; +class RemoteWorkerData; +class SharedWorkerManager; +class SharedWorkerService; + +// Main-thread only object that keeps a manager and the service alive. +// When the last SharedWorkerManagerHolder is released, the corresponding +// manager unregisters itself from the service and terminates the worker. +class SharedWorkerManagerHolder final + : public SupportsCheckedUnsafePtr> { + public: + NS_INLINE_DECL_REFCOUNTING(SharedWorkerManagerHolder); + + SharedWorkerManagerHolder(SharedWorkerManager* aManager, + SharedWorkerService* aService); + + SharedWorkerManager* Manager() const { return mManager; } + + SharedWorkerService* Service() const { return mService; } + + private: + ~SharedWorkerManagerHolder(); + + const RefPtr mManager; + const RefPtr mService; +}; + +// Thread-safe wrapper for SharedWorkerManagerHolder. +class SharedWorkerManagerWrapper final { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedWorkerManagerWrapper); + + explicit SharedWorkerManagerWrapper( + already_AddRefed aHolder); + + SharedWorkerManager* Manager() const { return mHolder->Manager(); } + + private: + ~SharedWorkerManagerWrapper(); + + RefPtr mHolder; +}; + +/** + * PBackground instance that corresponds to a single logical Shared Worker that + * exists somewhere in the process tree. Referenced/owned by multiple + * SharedWorkerParent instances on the PBackground thread. Holds/owns a single + * RemoteWorkerController to interact with the actual shared worker thread, + * wherever it is located. Creates the RemoteWorkerController via + * RemoteWorkerController::Create which uses RemoteWorkerManager::Launch under + * the hood. + */ +class SharedWorkerManager final : public RemoteWorkerObserver { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedWorkerManager, override); + + // Called on main-thread thread methods + + static already_AddRefed Create( + SharedWorkerService* aService, nsIEventTarget* aPBackgroundEventTarget, + const RemoteWorkerData& aData, nsIPrincipal* aLoadingPrincipal, + const OriginAttributes& aEffectiveStoragePrincipalAttrs); + + // Returns a holder if this manager matches. The holder blocks the shutdown of + // the manager. + already_AddRefed MatchOnMainThread( + SharedWorkerService* aService, const nsACString& aDomain, + nsIURI* aScriptURL, const nsAString& aName, + nsIPrincipal* aLoadingPrincipal, + const OriginAttributes& aEffectiveStoragePrincipalAttrs); + + // RemoteWorkerObserver + + void CreationFailed() override; + + void CreationSucceeded() override; + + void ErrorReceived(const ErrorValue& aValue) override; + + void LockNotified(bool aCreated) final; + + void WebTransportNotified(bool aCreated) final; + + void Terminated() override; + + // Called on PBackground thread methods + + bool MaybeCreateRemoteWorker(const RemoteWorkerData& aData, + uint64_t aWindowID, + UniqueMessagePortId& aPortIdentifier, + base::ProcessId aProcessId); + + void AddActor(SharedWorkerParent* aParent); + + void RemoveActor(SharedWorkerParent* aParent); + + void UpdateSuspend(); + + void UpdateFrozen(); + + bool IsSecureContext() const; + + void Terminate(); + + // Called on main-thread only. + + void RegisterHolder(SharedWorkerManagerHolder* aHolder); + + void UnregisterHolder(SharedWorkerManagerHolder* aHolder); + + private: + SharedWorkerManager(nsIEventTarget* aPBackgroundEventTarget, + const RemoteWorkerData& aData, + nsIPrincipal* aLoadingPrincipal, + const OriginAttributes& aEffectiveStoragePrincipalAttrs); + + ~SharedWorkerManager(); + + nsCOMPtr mPBackgroundEventTarget; + + nsCOMPtr mLoadingPrincipal; + const nsCString mDomain; + const OriginAttributes mEffectiveStoragePrincipalAttrs; + const nsCOMPtr mResolvedScriptURL; + const nsString mName; + const bool mIsSecureContext; + bool mSuspended; + bool mFrozen; + uint32_t mLockCount = 0; + uint32_t mWebTransportCount = 0; + + // Raw pointers because SharedWorkerParent unregisters itself in + // ActorDestroy(). + nsTArray> mActors; + + RefPtr mRemoteWorkerController; + + // Main-thread only. Raw Pointers because holders keep the manager alive and + // they unregister themselves in their DTOR. + nsTArray> mHolders; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_SharedWorkerManager_h diff --git a/dom/workers/sharedworkers/SharedWorkerParent.cpp b/dom/workers/sharedworkers/SharedWorkerParent.cpp new file mode 100644 index 0000000000..38e56f5100 --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorkerParent.cpp @@ -0,0 +1,165 @@ +/* -*- 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 "SharedWorkerParent.h" +#include "SharedWorkerManager.h" +#include "SharedWorkerService.h" +#include "mozilla/dom/RemoteWorkerTypes.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "mozilla/Unused.h" + +namespace mozilla { + +using namespace ipc; + +namespace dom { + +SharedWorkerParent::SharedWorkerParent() + : mBackgroundEventTarget(GetCurrentSerialEventTarget()), + mStatus(eInit), + mSuspended(false), + mFrozen(false) { + AssertIsOnBackgroundThread(); +} + +SharedWorkerParent::~SharedWorkerParent() = default; + +void SharedWorkerParent::ActorDestroy(IProtocol::ActorDestroyReason aReason) { + AssertIsOnBackgroundThread(); + + if (mWorkerManagerWrapper) { + mWorkerManagerWrapper->Manager()->RemoveActor(this); + mWorkerManagerWrapper = nullptr; + } +} + +void SharedWorkerParent::Initialize( + const RemoteWorkerData& aData, uint64_t aWindowID, + const MessagePortIdentifier& aPortIdentifier) { + AssertIsOnBackgroundThread(); + MOZ_ASSERT(mStatus == eInit); + + mWindowID = aWindowID; + + mStatus = ePending; + + RefPtr service = SharedWorkerService::GetOrCreate(); + MOZ_ASSERT(service); + service->GetOrCreateWorkerManager(this, aData, aWindowID, aPortIdentifier); +} + +IPCResult SharedWorkerParent::RecvClose() { + AssertIsOnBackgroundThread(); + MOZ_ASSERT(mStatus == ePending || mStatus == eActive); + + mStatus = eClosed; + + if (mWorkerManagerWrapper) { + mWorkerManagerWrapper->Manager()->RemoveActor(this); + mWorkerManagerWrapper = nullptr; + } + + Unused << Send__delete__(this); + return IPC_OK(); +} + +IPCResult SharedWorkerParent::RecvSuspend() { + AssertIsOnBackgroundThread(); + MOZ_ASSERT(!mSuspended); + MOZ_ASSERT(mStatus == ePending || mStatus == eActive); + + mSuspended = true; + + if (mStatus == eActive) { + MOZ_ASSERT(mWorkerManagerWrapper); + mWorkerManagerWrapper->Manager()->UpdateSuspend(); + } + + return IPC_OK(); +} + +IPCResult SharedWorkerParent::RecvResume() { + AssertIsOnBackgroundThread(); + MOZ_ASSERT(mSuspended); + MOZ_ASSERT(mStatus == ePending || mStatus == eActive); + + mSuspended = false; + + if (mStatus == eActive) { + MOZ_ASSERT(mWorkerManagerWrapper); + mWorkerManagerWrapper->Manager()->UpdateSuspend(); + } + + return IPC_OK(); +} + +IPCResult SharedWorkerParent::RecvFreeze() { + AssertIsOnBackgroundThread(); + MOZ_ASSERT(!mFrozen); + MOZ_ASSERT(mStatus == ePending || mStatus == eActive); + + mFrozen = true; + + if (mStatus == eActive) { + MOZ_ASSERT(mWorkerManagerWrapper); + mWorkerManagerWrapper->Manager()->UpdateFrozen(); + } + + return IPC_OK(); +} + +IPCResult SharedWorkerParent::RecvThaw() { + AssertIsOnBackgroundThread(); + MOZ_ASSERT(mFrozen); + MOZ_ASSERT(mStatus == ePending || mStatus == eActive); + + mFrozen = false; + + if (mStatus == eActive) { + MOZ_ASSERT(mWorkerManagerWrapper); + mWorkerManagerWrapper->Manager()->UpdateFrozen(); + } + + return IPC_OK(); +} + +void SharedWorkerParent::ManagerCreated( + already_AddRefed aWorkerManagerWrapper) { + AssertIsOnBackgroundThread(); + MOZ_ASSERT(!mWorkerManagerWrapper); + MOZ_ASSERT(mStatus == ePending || mStatus == eClosed); + + RefPtr wrapper = aWorkerManagerWrapper; + + // Already gone. + if (mStatus == eClosed) { + wrapper->Manager()->RemoveActor(this); + return; + } + + mStatus = eActive; + mWorkerManagerWrapper = wrapper; + + mWorkerManagerWrapper->Manager()->UpdateFrozen(); + mWorkerManagerWrapper->Manager()->UpdateSuspend(); +} + +void SharedWorkerParent::ErrorPropagation(nsresult aError) { + AssertIsOnBackgroundThread(); + MOZ_ASSERT(NS_FAILED(aError)); + MOZ_ASSERT(mStatus == ePending || mStatus == eClosed); + + // Already gone. + if (mStatus == eClosed) { + return; + } + + Unused << SendError(aError); +} + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/sharedworkers/SharedWorkerParent.h b/dom/workers/sharedworkers/SharedWorkerParent.h new file mode 100644 index 0000000000..c91e66cc2e --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorkerParent.h @@ -0,0 +1,81 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_dom_SharedWorkerParent_h +#define mozilla_dom_dom_SharedWorkerParent_h + +#include "mozilla/dom/PSharedWorkerParent.h" +#include "mozilla/dom/quota/CheckedUnsafePtr.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "nsISupportsImpl.h" + +namespace mozilla::dom { + +class MessagePortIdentifier; +class RemoteWorkerData; +class SharedWorkerManagerWrapper; + +/** + * PBackground actor that relays life-cycle events (freeze/thaw, suspend/resume, + * close) to the PBackground SharedWorkerManager and relays error/termination + * back to the child. + */ +class SharedWorkerParent final + : public mozilla::dom::PSharedWorkerParent, + public SupportsCheckedUnsafePtr> { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedWorkerParent) + + SharedWorkerParent(); + + void Initialize(const RemoteWorkerData& aData, uint64_t aWindowID, + const MessagePortIdentifier& aPortIdentifier); + + void ManagerCreated( + already_AddRefed aWorkerManagerWrapper); + + void ErrorPropagation(nsresult aError); + + mozilla::ipc::IPCResult RecvClose(); + + mozilla::ipc::IPCResult RecvSuspend(); + + mozilla::ipc::IPCResult RecvResume(); + + mozilla::ipc::IPCResult RecvFreeze(); + + mozilla::ipc::IPCResult RecvThaw(); + + bool IsSuspended() const { return mSuspended; } + + bool IsFrozen() const { return mFrozen; } + + uint64_t WindowID() const { return mWindowID; } + + private: + ~SharedWorkerParent(); + + void ActorDestroy(IProtocol::ActorDestroyReason aReason) override; + + nsCOMPtr mBackgroundEventTarget; + RefPtr mWorkerManagerWrapper; + + enum { + eInit, + ePending, + eActive, + eClosed, + } mStatus; + + uint64_t mWindowID; + + bool mSuspended; + bool mFrozen; +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_dom_SharedWorkerParent_h diff --git a/dom/workers/sharedworkers/SharedWorkerService.cpp b/dom/workers/sharedworkers/SharedWorkerService.cpp new file mode 100644 index 0000000000..b543e8cb5e --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorkerService.cpp @@ -0,0 +1,263 @@ +/* -*- 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 "SharedWorkerService.h" +#include "mozilla/dom/MessagePort.h" +#include "mozilla/dom/RemoteWorkerTypes.h" +#include "mozilla/dom/SharedWorkerManager.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/ipc/URIUtils.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/SchedulerGroup.h" +#include "mozilla/StaticMutex.h" +#include "nsIPrincipal.h" +#include "nsProxyRelease.h" + +namespace mozilla { + +using namespace ipc; + +namespace dom { + +namespace { + +StaticMutex sSharedWorkerMutex; + +StaticRefPtr sSharedWorkerService; + +class GetOrCreateWorkerManagerRunnable final : public Runnable { + public: + GetOrCreateWorkerManagerRunnable(SharedWorkerService* aService, + SharedWorkerParent* aActor, + const RemoteWorkerData& aData, + uint64_t aWindowID, + const MessagePortIdentifier& aPortIdentifier) + : Runnable("GetOrCreateWorkerManagerRunnable"), + mBackgroundEventTarget(GetCurrentSerialEventTarget()), + mService(aService), + mActor(aActor), + mData(aData), + mWindowID(aWindowID), + mPortIdentifier(aPortIdentifier) {} + + NS_IMETHOD + Run() { + mService->GetOrCreateWorkerManagerOnMainThread( + mBackgroundEventTarget, mActor, mData, mWindowID, mPortIdentifier); + + return NS_OK; + } + + private: + nsCOMPtr mBackgroundEventTarget; + RefPtr mService; + RefPtr mActor; + RemoteWorkerData mData; + uint64_t mWindowID; + UniqueMessagePortId mPortIdentifier; +}; + +class WorkerManagerCreatedRunnable final : public Runnable { + public: + WorkerManagerCreatedRunnable( + already_AddRefed aManagerWrapper, + SharedWorkerParent* aActor, const RemoteWorkerData& aData, + uint64_t aWindowID, UniqueMessagePortId& aPortIdentifier) + : Runnable("WorkerManagerCreatedRunnable"), + mManagerWrapper(aManagerWrapper), + mActor(aActor), + mData(aData), + mWindowID(aWindowID), + mPortIdentifier(std::move(aPortIdentifier)) {} + + NS_IMETHOD + Run() { + AssertIsOnBackgroundThread(); + + if (NS_WARN_IF( + !mActor->CanSend() || + !mManagerWrapper->Manager()->MaybeCreateRemoteWorker( + mData, mWindowID, mPortIdentifier, mActor->OtherPid()))) { + // If we cannot send, the error won't arrive, but we may log something. + mActor->ErrorPropagation(NS_ERROR_FAILURE); + return NS_OK; + } + + mManagerWrapper->Manager()->AddActor(mActor); + mActor->ManagerCreated(mManagerWrapper.forget()); + return NS_OK; + } + + private: + RefPtr mManagerWrapper; + RefPtr mActor; + RemoteWorkerData mData; + uint64_t mWindowID; + UniqueMessagePortId mPortIdentifier; +}; + +class ErrorPropagationRunnable final : public Runnable { + public: + ErrorPropagationRunnable(SharedWorkerParent* aActor, nsresult aError) + : Runnable("ErrorPropagationRunnable"), mActor(aActor), mError(aError) {} + + NS_IMETHOD + Run() { + AssertIsOnBackgroundThread(); + mActor->ErrorPropagation(mError); + return NS_OK; + } + + private: + RefPtr mActor; + nsresult mError; +}; + +} // namespace + +/* static */ +already_AddRefed SharedWorkerService::GetOrCreate() { + AssertIsOnBackgroundThread(); + + StaticMutexAutoLock lock(sSharedWorkerMutex); + + if (!sSharedWorkerService) { + sSharedWorkerService = new SharedWorkerService(); + // ClearOnShutdown can only be called on main thread + nsresult rv = SchedulerGroup::Dispatch( + TaskCategory::Other, + NS_NewRunnableFunction("RegisterSharedWorkerServiceClearOnShutdown", + []() { + StaticMutexAutoLock lock(sSharedWorkerMutex); + MOZ_ASSERT(sSharedWorkerService); + ClearOnShutdown(&sSharedWorkerService); + })); + Unused << NS_WARN_IF(NS_FAILED(rv)); + } + + RefPtr instance = sSharedWorkerService; + return instance.forget(); +} + +/* static */ +SharedWorkerService* SharedWorkerService::Get() { + StaticMutexAutoLock lock(sSharedWorkerMutex); + + MOZ_ASSERT(sSharedWorkerService); + return sSharedWorkerService; +} + +void SharedWorkerService::GetOrCreateWorkerManager( + SharedWorkerParent* aActor, const RemoteWorkerData& aData, + uint64_t aWindowID, const MessagePortIdentifier& aPortIdentifier) { + AssertIsOnBackgroundThread(); + + // The real check happens on main-thread. + RefPtr r = + new GetOrCreateWorkerManagerRunnable(this, aActor, aData, aWindowID, + aPortIdentifier); + + nsresult rv = SchedulerGroup::Dispatch(TaskCategory::Other, r.forget()); + Unused << NS_WARN_IF(NS_FAILED(rv)); +} + +void SharedWorkerService::GetOrCreateWorkerManagerOnMainThread( + nsIEventTarget* aBackgroundEventTarget, SharedWorkerParent* aActor, + const RemoteWorkerData& aData, uint64_t aWindowID, + UniqueMessagePortId& aPortIdentifier) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aBackgroundEventTarget); + MOZ_ASSERT(aActor); + + auto partitionedPrincipalOrErr = + PrincipalInfoToPrincipal(aData.partitionedPrincipalInfo()); + if (NS_WARN_IF(partitionedPrincipalOrErr.isErr())) { + ErrorPropagationOnMainThread(aBackgroundEventTarget, aActor, + partitionedPrincipalOrErr.unwrapErr()); + return; + } + + auto loadingPrincipalOrErr = + PrincipalInfoToPrincipal(aData.loadingPrincipalInfo()); + if (NS_WARN_IF(loadingPrincipalOrErr.isErr())) { + ErrorPropagationOnMainThread(aBackgroundEventTarget, aActor, + loadingPrincipalOrErr.unwrapErr()); + return; + } + + RefPtr managerHolder; + + nsCOMPtr loadingPrincipal = loadingPrincipalOrErr.unwrap(); + nsCOMPtr partitionedPrincipal = + partitionedPrincipalOrErr.unwrap(); + + nsCOMPtr effectiveStoragePrincipal = partitionedPrincipal; + if (aData.useRegularPrincipal()) { + effectiveStoragePrincipal = loadingPrincipal; + } + + // Let's see if there is already a SharedWorker to share. + nsCOMPtr resolvedScriptURL = + DeserializeURI(aData.resolvedScriptURL()); + for (SharedWorkerManager* workerManager : mWorkerManagers) { + managerHolder = workerManager->MatchOnMainThread( + this, aData.domain(), resolvedScriptURL, aData.name(), loadingPrincipal, + BasePrincipal::Cast(effectiveStoragePrincipal)->OriginAttributesRef()); + if (managerHolder) { + break; + } + } + + // Let's create a new one. + if (!managerHolder) { + managerHolder = SharedWorkerManager::Create( + this, aBackgroundEventTarget, aData, loadingPrincipal, + BasePrincipal::Cast(effectiveStoragePrincipal)->OriginAttributesRef()); + + mWorkerManagers.AppendElement(managerHolder->Manager()); + } else { + // We are attaching the actor to an existing one. + if (managerHolder->Manager()->IsSecureContext() != + aData.isSecureContext()) { + ErrorPropagationOnMainThread(aBackgroundEventTarget, aActor, + NS_ERROR_DOM_SECURITY_ERR); + return; + } + } + + RefPtr wrapper = + new SharedWorkerManagerWrapper(managerHolder.forget()); + + RefPtr r = new WorkerManagerCreatedRunnable( + wrapper.forget(), aActor, aData, aWindowID, aPortIdentifier); + aBackgroundEventTarget->Dispatch(r.forget(), NS_DISPATCH_NORMAL); +} + +void SharedWorkerService::ErrorPropagationOnMainThread( + nsIEventTarget* aBackgroundEventTarget, SharedWorkerParent* aActor, + nsresult aError) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aBackgroundEventTarget); + MOZ_ASSERT(aActor); + MOZ_ASSERT(NS_FAILED(aError)); + + RefPtr r = + new ErrorPropagationRunnable(aActor, aError); + aBackgroundEventTarget->Dispatch(r.forget(), NS_DISPATCH_NORMAL); +} + +void SharedWorkerService::RemoveWorkerManagerOnMainThread( + SharedWorkerManager* aManager) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aManager); + MOZ_ASSERT(mWorkerManagers.Contains(aManager)); + + mWorkerManagers.RemoveElement(aManager); +} + +} // namespace dom +} // namespace mozilla diff --git a/dom/workers/sharedworkers/SharedWorkerService.h b/dom/workers/sharedworkers/SharedWorkerService.h new file mode 100644 index 0000000000..c4671163bd --- /dev/null +++ b/dom/workers/sharedworkers/SharedWorkerService.h @@ -0,0 +1,74 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_SharedWorkerService_h +#define mozilla_dom_SharedWorkerService_h + +#include "mozilla/dom/quota/CheckedUnsafePtr.h" +#include "nsISupportsImpl.h" +#include "nsTArray.h" + +class nsIEventTarget; + +namespace mozilla { + +namespace ipc { +class PrincipalInfo; +} + +namespace dom { + +class MessagePortIdentifier; +class RemoteWorkerData; +class SharedWorkerManager; +class SharedWorkerParent; +class UniqueMessagePortId; + +/** + * PBackground service that creates and tracks the per-worker + * SharedWorkerManager instances, allowing rendezvous between SharedWorkerParent + * instances and the SharedWorkerManagers they want to talk to (1:1). + */ +class SharedWorkerService final { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedWorkerService); + + // This can be called on PBackground thread only. + static already_AddRefed GetOrCreate(); + + // The service, if already created, is available on any thread using this + // method. + static SharedWorkerService* Get(); + + // PBackground method only. + void GetOrCreateWorkerManager(SharedWorkerParent* aActor, + const RemoteWorkerData& aData, + uint64_t aWindowID, + const MessagePortIdentifier& aPortIdentifier); + + void GetOrCreateWorkerManagerOnMainThread( + nsIEventTarget* aBackgroundEventTarget, SharedWorkerParent* aActor, + const RemoteWorkerData& aData, uint64_t aWindowID, + UniqueMessagePortId& aPortIdentifier); + + void RemoveWorkerManagerOnMainThread(SharedWorkerManager* aManager); + + private: + SharedWorkerService() = default; + ~SharedWorkerService() = default; + + void ErrorPropagationOnMainThread(nsIEventTarget* aBackgroundEventTarget, + SharedWorkerParent* aActor, + nsresult aError); + + // Touched on main-thread only. + nsTArray> mWorkerManagers; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_SharedWorkerService_h diff --git a/dom/workers/sharedworkers/moz.build b/dom/workers/sharedworkers/moz.build new file mode 100644 index 0000000000..2b83bc9525 --- /dev/null +++ b/dom/workers/sharedworkers/moz.build @@ -0,0 +1,28 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +EXPORTS.mozilla.dom += [ + "SharedWorker.h", + "SharedWorkerChild.h", + "SharedWorkerManager.h", + "SharedWorkerParent.h", +] + +UNIFIED_SOURCES += [ + "SharedWorker.cpp", + "SharedWorkerChild.cpp", + "SharedWorkerManager.cpp", + "SharedWorkerParent.cpp", + "SharedWorkerService.cpp", +] + +IPDL_SOURCES += [ + "PSharedWorker.ipdl", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" -- cgit v1.2.3