diff options
Diffstat (limited to 'dom/worklet')
43 files changed, 3833 insertions, 0 deletions
diff --git a/dom/worklet/Worklet.cpp b/dom/worklet/Worklet.cpp new file mode 100644 index 0000000000..7c37bdbba9 --- /dev/null +++ b/dom/worklet/Worklet.cpp @@ -0,0 +1,122 @@ +/* -*- 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 "Worklet.h" +#include "WorkletThread.h" + +#include "mozilla/dom/WorkletFetchHandler.h" +#include "mozilla/dom/WorkletImpl.h" +#include "xpcprivate.h" + +using JS::loader::ResolveError; +using JS::loader::ResolveErrorInfo; + +namespace mozilla::dom { +// --------------------------------------------------------------------------- +// Worklet + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(Worklet) + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Worklet) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwnedObject) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mImportHandlers) + tmp->mImpl->NotifyWorkletFinished(); + NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Worklet) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwnedObject) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mImportHandlers) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(Worklet) +NS_IMPL_CYCLE_COLLECTING_RELEASE(Worklet) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Worklet) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +Worklet::Worklet(nsPIDOMWindowInner* aWindow, RefPtr<WorkletImpl> aImpl, + nsISupports* aOwnedObject) + : mWindow(aWindow), mOwnedObject(aOwnedObject), mImpl(std::move(aImpl)) { + MOZ_ASSERT(aWindow); + MOZ_ASSERT(mImpl); + MOZ_ASSERT(NS_IsMainThread()); +} + +Worklet::~Worklet() { mImpl->NotifyWorkletFinished(); } + +JSObject* Worklet::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return mImpl->WrapWorklet(aCx, this, aGivenProto); +} + +static bool LoadLocalizedStrings(nsTArray<nsString>& aStrings) { + // All enumes in ResolveError. + ResolveError errors[] = {ResolveError::Failure, + ResolveError::FailureMayBeBare, + ResolveError::BlockedByNullEntry, + ResolveError::BlockedByAfterPrefix, + ResolveError::BlockedByBacktrackingPrefix, + ResolveError::InvalidBareSpecifier}; + + static_assert( + ArrayLength(errors) == static_cast<size_t>(ResolveError::Length), + "The array 'errors' has missing entries in the enum class ResolveError."); + + for (auto i : errors) { + nsAutoString message; + nsresult rv = nsContentUtils::GetLocalizedString( + nsContentUtils::eDOM_PROPERTIES, ResolveErrorInfo::GetString(i), + message); + if (NS_WARN_IF(NS_FAILED(rv))) { + if (NS_WARN_IF(!aStrings.AppendElement(EmptyString(), fallible))) { + return false; + } + } else { + if (NS_WARN_IF(!aStrings.AppendElement(message, fallible))) { + return false; + } + } + } + + return true; +} + +already_AddRefed<Promise> Worklet::AddModule(JSContext* aCx, + const nsAString& aModuleURL, + const WorkletOptions& aOptions, + CallerType aCallerType, + ErrorResult& aRv) { + MOZ_ASSERT(NS_IsMainThread()); + if (mLocalizedStrings.IsEmpty()) { + bool result = LoadLocalizedStrings(mLocalizedStrings); + if (!result) { + return nullptr; + } + } + + return WorkletFetchHandler::AddModule(this, aCx, aModuleURL, aOptions, aRv); +} + +WorkletFetchHandler* Worklet::GetImportFetchHandler(const nsACString& aURI) { + MOZ_ASSERT(NS_IsMainThread()); + return mImportHandlers.GetWeak(aURI); +} + +void Worklet::AddImportFetchHandler(const nsACString& aURI, + WorkletFetchHandler* aHandler) { + MOZ_ASSERT(aHandler); + MOZ_ASSERT(!mImportHandlers.GetWeak(aURI)); + MOZ_ASSERT(NS_IsMainThread()); + + mImportHandlers.InsertOrUpdate(aURI, RefPtr{aHandler}); +} + +} // namespace mozilla::dom diff --git a/dom/worklet/Worklet.h b/dom/worklet/Worklet.h new file mode 100644 index 0000000000..1c404da18d --- /dev/null +++ b/dom/worklet/Worklet.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_Worklet_h +#define mozilla_dom_Worklet_h + +#include "mozilla/Attributes.h" +#include "nsRefPtrHashtable.h" +#include "nsWrapperCache.h" +#include "nsCOMPtr.h" + +class nsPIDOMWindowInner; + +namespace mozilla { + +class ErrorResult; +class WorkletImpl; + +namespace dom { + +class Promise; +class WorkletFetchHandler; +class WorkletScriptHandler; +struct WorkletOptions; +enum class CallerType : uint32_t; + +class Worklet final : public nsISupports, public nsWrapperCache { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(Worklet) + + // |aOwnedObject| may be provided by the WorkletImpl as a parent thread + // object to keep alive and traverse for CC as long as the Worklet has + // references remaining. + Worklet(nsPIDOMWindowInner* aWindow, RefPtr<WorkletImpl> aImpl, + nsISupports* aOwnedObject = nullptr); + + nsPIDOMWindowInner* GetParentObject() const { return mWindow; } + + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + already_AddRefed<Promise> AddModule(JSContext* aCx, + const nsAString& aModuleURL, + const WorkletOptions& aOptions, + CallerType aCallerType, ErrorResult& aRv); + + WorkletImpl* Impl() const { return mImpl; } + + const nsTArray<nsString>& GetLocalizedStrings() const { + return mLocalizedStrings; + } + + private: + ~Worklet(); + + WorkletFetchHandler* GetImportFetchHandler(const nsACString& aURI); + + void AddImportFetchHandler(const nsACString& aURI, + WorkletFetchHandler* aHandler); + + nsCOMPtr<nsPIDOMWindowInner> mWindow; + nsCOMPtr<nsISupports> mOwnedObject; + + nsRefPtrHashtable<nsCStringHashKey, WorkletFetchHandler> mImportHandlers; + + const RefPtr<WorkletImpl> mImpl; + + nsTArray<nsString> mLocalizedStrings; + + friend class WorkletFetchHandler; + friend class WorkletScriptHandler; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_Worklet_h diff --git a/dom/worklet/WorkletFetchHandler.cpp b/dom/worklet/WorkletFetchHandler.cpp new file mode 100644 index 0000000000..bc764c5316 --- /dev/null +++ b/dom/worklet/WorkletFetchHandler.cpp @@ -0,0 +1,642 @@ +/* -*- 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 "WorkletFetchHandler.h" + +#include "js/loader/ModuleLoadRequest.h" +#include "js/ContextOptions.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/Fetch.h" +#include "mozilla/dom/Request.h" +#include "mozilla/dom/Response.h" +#include "mozilla/dom/RootedDictionary.h" +#include "mozilla/dom/ScriptLoader.h" +#include "mozilla/dom/ScriptLoadHandler.h" // ScriptDecoder +#include "mozilla/dom/Worklet.h" +#include "mozilla/dom/WorkletBinding.h" +#include "mozilla/dom/WorkletGlobalScope.h" +#include "mozilla/dom/WorkletImpl.h" +#include "mozilla/dom/WorkletThread.h" +#include "mozilla/dom/worklet/WorkletModuleLoader.h" +#include "mozilla/CycleCollectedJSContext.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/TaskQueue.h" +#include "nsIInputStreamPump.h" +#include "nsIThreadRetargetableRequest.h" +#include "xpcpublic.h" + +using JS::loader::ModuleLoadRequest; +using JS::loader::ScriptFetchOptions; +using mozilla::dom::loader::WorkletModuleLoader; + +namespace mozilla::dom { + +// A Runnable to call ModuleLoadRequest::StartModuleLoad on a worklet thread. +class StartModuleLoadRunnable final : public Runnable { + public: + StartModuleLoadRunnable( + WorkletImpl* aWorkletImpl, + const nsMainThreadPtrHandle<WorkletFetchHandler>& aHandlerRef, + nsCOMPtr<nsIURI> aURI, nsIURI* aReferrer, + const nsTArray<nsString>& aLocalizedStrs) + : Runnable("Worklet::StartModuleLoadRunnable"), + mWorkletImpl(aWorkletImpl), + mHandlerRef(aHandlerRef), + mURI(std::move(aURI)), + mReferrer(aReferrer), + mLocalizedStrs(aLocalizedStrs), + mParentRuntime( + JS_GetParentRuntime(CycleCollectedJSContext::Get()->Context())) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mParentRuntime); + xpc::SetPrefableContextOptions(mContextOptions); + } + + ~StartModuleLoadRunnable() = default; + + NS_IMETHOD Run() override; + + private: + NS_IMETHOD RunOnWorkletThread(); + + RefPtr<WorkletImpl> mWorkletImpl; + nsMainThreadPtrHandle<WorkletFetchHandler> mHandlerRef; + nsCOMPtr<nsIURI> mURI; + nsCOMPtr<nsIURI> mReferrer; + const nsTArray<nsString>& mLocalizedStrs; + JSRuntime* mParentRuntime; + JS::ContextOptions mContextOptions; +}; + +NS_IMETHODIMP +StartModuleLoadRunnable::Run() { + // WorkletThread::IsOnWorkletThread() cannot be used here because it depends + // on a WorkletJSContext having been created for this thread. That does not + // happen until the global scope is created the first time + // RunOnWorkletThread() is called. + MOZ_ASSERT(!NS_IsMainThread()); + return RunOnWorkletThread(); +} + +NS_IMETHODIMP StartModuleLoadRunnable::RunOnWorkletThread() { + // This can be called on a GraphRunner thread or a DOM Worklet thread. + WorkletThread::EnsureCycleCollectedJSContext(mParentRuntime, mContextOptions); + + WorkletGlobalScope* globalScope = mWorkletImpl->GetGlobalScope(); + if (!globalScope) { + return NS_ERROR_DOM_UNKNOWN_ERR; + } + + // To fetch a worklet/module worker script graph: + // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-worklet/module-worker-script-graph + // Step 1. Let options be a script fetch options. And referrer policy is the + // empty string. + ReferrerPolicy referrerPolicy = ReferrerPolicy::_empty; + RefPtr<ScriptFetchOptions> fetchOptions = new ScriptFetchOptions( + CORSMode::CORS_NONE, referrerPolicy, /*triggeringPrincipal*/ nullptr); + + WorkletModuleLoader* moduleLoader = + static_cast<WorkletModuleLoader*>(globalScope->GetModuleLoader()); + MOZ_ASSERT(moduleLoader); + + if (!moduleLoader->HasSetLocalizedStrings()) { + moduleLoader->SetLocalizedStrings(&mLocalizedStrs); + } + + RefPtr<WorkletLoadContext> loadContext = new WorkletLoadContext(mHandlerRef); + + // Part of Step 2. This sets the Top-level flag to true + RefPtr<ModuleLoadRequest> request = new ModuleLoadRequest( + mURI, fetchOptions, SRIMetadata(), mReferrer, loadContext, + true, /* is top level */ + false, /* is dynamic import */ + moduleLoader, ModuleLoadRequest::NewVisitedSetForTopLevelImport(mURI), + nullptr); + + request->mURL = request->mURI->GetSpecOrDefault(); + + return request->StartModuleLoad(); +} + +StartFetchRunnable::StartFetchRunnable( + const nsMainThreadPtrHandle<WorkletFetchHandler>& aHandlerRef, nsIURI* aURI, + nsIURI* aReferrer) + : Runnable("Worklet::StartFetchRunnable"), + mHandlerRef(aHandlerRef), + mURI(aURI), + mReferrer(aReferrer) { + MOZ_ASSERT(!NS_IsMainThread()); +} + +NS_IMETHODIMP +StartFetchRunnable::Run() { + MOZ_ASSERT(NS_IsMainThread()); + + nsCOMPtr<nsIGlobalObject> global = + do_QueryInterface(mHandlerRef->mWorklet->GetParentObject()); + MOZ_ASSERT(global); + + AutoJSAPI jsapi; + if (NS_WARN_IF(!jsapi.Init(global))) { + return NS_ERROR_FAILURE; + } + + JSContext* cx = jsapi.cx(); + nsresult rv = mHandlerRef->StartFetch(cx, mURI, mReferrer); + if (NS_FAILED(rv)) { + mHandlerRef->HandleFetchFailed(mURI); + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +// A Runnable to call ModuleLoadRequest::OnFetchComplete on a worklet thread. +class FetchCompleteRunnable final : public Runnable { + public: + FetchCompleteRunnable(WorkletImpl* aWorkletImpl, nsIURI* aURI, + nsresult aResult, + UniquePtr<uint8_t[]> aScriptBuffer = nullptr, + size_t aScriptLength = 0) + : Runnable("Worklet::FetchCompleteRunnable"), + mWorkletImpl(aWorkletImpl), + mURI(aURI), + mResult(aResult), + mScriptBuffer(std::move(aScriptBuffer)), + mScriptLength(aScriptLength) { + MOZ_ASSERT(NS_IsMainThread()); + } + + ~FetchCompleteRunnable() = default; + + NS_IMETHOD Run() override; + + private: + NS_IMETHOD RunOnWorkletThread(); + + RefPtr<WorkletImpl> mWorkletImpl; + nsCOMPtr<nsIURI> mURI; + nsresult mResult; + UniquePtr<uint8_t[]> mScriptBuffer; + size_t mScriptLength; +}; + +NS_IMETHODIMP +FetchCompleteRunnable::Run() { + MOZ_ASSERT(WorkletThread::IsOnWorkletThread()); + return RunOnWorkletThread(); +} + +NS_IMETHODIMP FetchCompleteRunnable::RunOnWorkletThread() { + WorkletGlobalScope* globalScope = mWorkletImpl->GetGlobalScope(); + if (!globalScope) { + return NS_ERROR_DOM_UNKNOWN_ERR; + } + + WorkletModuleLoader* moduleLoader = + static_cast<WorkletModuleLoader*>(globalScope->GetModuleLoader()); + MOZ_ASSERT(moduleLoader); + MOZ_ASSERT(mURI); + ModuleLoadRequest* request = moduleLoader->GetRequest(mURI); + MOZ_ASSERT(request); + + // Set the Source type to "text" for decoding. + request->SetTextSource(); + + nsresult rv; + if (mScriptBuffer) { + UniquePtr<ScriptDecoder> decoder = MakeUnique<ScriptDecoder>( + UTF_8_ENCODING, ScriptDecoder::BOMHandling::Remove); + rv = decoder->DecodeRawData(request, mScriptBuffer.get(), mScriptLength, + true); + NS_ENSURE_SUCCESS(rv, rv); + } + + request->mBaseURL = mURI; + request->OnFetchComplete(mResult); + + if (NS_FAILED(mResult)) { + if (request->IsTopLevel()) { + request->LoadFailed(); + } else { + request->Cancel(); + } + } + + moduleLoader->RemoveRequest(mURI); + return NS_OK; +} + +////////////////////////////////////////////////////////////// +// WorkletFetchHandler +////////////////////////////////////////////////////////////// +NS_IMPL_CYCLE_COLLECTING_ADDREF(WorkletFetchHandler) +NS_IMPL_CYCLE_COLLECTING_RELEASE(WorkletFetchHandler) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WorkletFetchHandler) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTION_CLASS(WorkletFetchHandler) + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(WorkletFetchHandler) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mWorklet, mPromises) + tmp->mErrorToRethrow.setUndefined(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(WorkletFetchHandler) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWorklet, mPromises) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(WorkletFetchHandler) + NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mErrorToRethrow) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +// static +already_AddRefed<Promise> WorkletFetchHandler::AddModule( + Worklet* aWorklet, JSContext* aCx, const nsAString& aModuleURL, + const WorkletOptions& aOptions, ErrorResult& aRv) { + MOZ_ASSERT(aWorklet); + MOZ_ASSERT(NS_IsMainThread()); + + aWorklet->Impl()->OnAddModuleStarted(); + + auto promiseSettledGuard = + MakeScopeExit([&] { aWorklet->Impl()->OnAddModulePromiseSettled(); }); + + nsCOMPtr<nsIGlobalObject> global = + do_QueryInterface(aWorklet->GetParentObject()); + MOZ_ASSERT(global); + + RefPtr<Promise> promise = Promise::Create(global, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + + nsCOMPtr<nsPIDOMWindowInner> window = aWorklet->GetParentObject(); + MOZ_ASSERT(window); + + nsCOMPtr<Document> doc; + doc = window->GetExtantDoc(); + if (!doc) { + promise->MaybeReject(NS_ERROR_FAILURE); + return promise.forget(); + } + + nsCOMPtr<nsIURI> resolvedURI; + nsresult rv = NS_NewURI(getter_AddRefs(resolvedURI), aModuleURL, nullptr, + doc->GetBaseURI()); + if (NS_WARN_IF(NS_FAILED(rv))) { + // https://html.spec.whatwg.org/multipage/worklets.html#dom-worklet-addmodule + // Step 3. If this fails, then return a promise rejected with a + // "SyntaxError" DOMException. + rv = NS_ERROR_DOM_SYNTAX_ERR; + + promise->MaybeReject(rv); + return promise.forget(); + } + + nsAutoCString spec; + rv = resolvedURI->GetSpec(spec); + if (NS_WARN_IF(NS_FAILED(rv))) { + rv = NS_ERROR_DOM_SYNTAX_ERR; + + promise->MaybeReject(rv); + return promise.forget(); + } + + // Maybe we already have an handler for this URI + { + WorkletFetchHandler* handler = aWorklet->GetImportFetchHandler(spec); + if (handler) { + handler->AddPromise(aCx, promise); + return promise.forget(); + } + } + + RefPtr<WorkletFetchHandler> handler = + new WorkletFetchHandler(aWorklet, promise, aOptions.mCredentials); + + nsMainThreadPtrHandle<WorkletFetchHandler> handlerRef{ + new nsMainThreadPtrHolder<WorkletFetchHandler>("FetchHandler", handler)}; + + // Determine request's Referrer + // https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer + // Step 3. Switch on request’s referrer: + // "client" + // Step 1.4. Let referrerSource be document’s URL. + nsIURI* referrer = doc->GetDocumentURIAsReferrer(); + nsCOMPtr<nsIRunnable> runnable = new StartModuleLoadRunnable( + aWorklet->mImpl, handlerRef, std::move(resolvedURI), referrer, + aWorklet->GetLocalizedStrings()); + + if (NS_FAILED(aWorklet->mImpl->SendControlMessage(runnable.forget()))) { + return nullptr; + } + + promiseSettledGuard.release(); + + aWorklet->AddImportFetchHandler(spec, handler); + return promise.forget(); +} + +WorkletFetchHandler::WorkletFetchHandler(Worklet* aWorklet, Promise* aPromise, + RequestCredentials aCredentials) + : mWorklet(aWorklet), mStatus(ePending), mCredentials(aCredentials) { + MOZ_ASSERT(aWorklet); + MOZ_ASSERT(aPromise); + MOZ_ASSERT(NS_IsMainThread()); + + mPromises.AppendElement(aPromise); +} + +WorkletFetchHandler::~WorkletFetchHandler() { mozilla::DropJSObjects(this); } + +void WorkletFetchHandler::ExecutionFailed() { + MOZ_ASSERT(NS_IsMainThread()); + RejectPromises(NS_ERROR_DOM_ABORT_ERR); +} + +void WorkletFetchHandler::ExecutionFailed(JS::Handle<JS::Value> aError) { + MOZ_ASSERT(NS_IsMainThread()); + RejectPromises(aError); +} + +void WorkletFetchHandler::ExecutionSucceeded() { + MOZ_ASSERT(NS_IsMainThread()); + ResolvePromises(); +} + +void WorkletFetchHandler::AddPromise(JSContext* aCx, Promise* aPromise) { + MOZ_ASSERT(aPromise); + MOZ_ASSERT(NS_IsMainThread()); + + switch (mStatus) { + case ePending: + mPromises.AppendElement(aPromise); + return; + + case eRejected: + if (mHasError) { + JS::Rooted<JS::Value> error(aCx, mErrorToRethrow); + aPromise->MaybeReject(error); + } else { + aPromise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); + } + return; + + case eResolved: + aPromise->MaybeResolveWithUndefined(); + return; + } +} + +void WorkletFetchHandler::RejectPromises(nsresult aResult) { + MOZ_ASSERT(mStatus == ePending); + MOZ_ASSERT(NS_FAILED(aResult)); + MOZ_ASSERT(NS_IsMainThread()); + + mWorklet->Impl()->OnAddModulePromiseSettled(); + + for (uint32_t i = 0; i < mPromises.Length(); ++i) { + mPromises[i]->MaybeReject(aResult); + } + mPromises.Clear(); + + mStatus = eRejected; + mWorklet = nullptr; +} + +void WorkletFetchHandler::RejectPromises(JS::Handle<JS::Value> aValue) { + MOZ_ASSERT(mStatus == ePending); + MOZ_ASSERT(NS_IsMainThread()); + + mWorklet->Impl()->OnAddModulePromiseSettled(); + + for (uint32_t i = 0; i < mPromises.Length(); ++i) { + mPromises[i]->MaybeReject(aValue); + } + mPromises.Clear(); + + mHasError = true; + mErrorToRethrow = aValue; + + mozilla::HoldJSObjects(this); + + mStatus = eRejected; + mWorklet = nullptr; +} + +void WorkletFetchHandler::ResolvePromises() { + MOZ_ASSERT(mStatus == ePending); + MOZ_ASSERT(NS_IsMainThread()); + + mWorklet->Impl()->OnAddModulePromiseSettled(); + + for (uint32_t i = 0; i < mPromises.Length(); ++i) { + mPromises[i]->MaybeResolveWithUndefined(); + } + mPromises.Clear(); + + mStatus = eResolved; + mWorklet = nullptr; +} + +nsresult WorkletFetchHandler::StartFetch(JSContext* aCx, nsIURI* aURI, + nsIURI* aReferrer) { + nsAutoCString spec; + nsresult res = aURI->GetSpec(spec); + if (NS_WARN_IF(NS_FAILED(res))) { + return NS_ERROR_FAILURE; + } + + RequestOrUSVString requestInput; + + nsAutoString url; + CopyUTF8toUTF16(spec, url); + requestInput.SetAsUSVString().ShareOrDependUpon(url); + + RootedDictionary<RequestInit> requestInit(aCx); + requestInit.mCredentials.Construct(mCredentials); + + // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script + // Step 8. mode is "cors" + requestInit.mMode.Construct(RequestMode::Cors); + + if (aReferrer) { + nsAutoString referrer; + res = aReferrer->GetSpec(spec); + if (NS_WARN_IF(NS_FAILED(res))) { + return NS_ERROR_FAILURE; + } + + CopyUTF8toUTF16(spec, referrer); + requestInit.mReferrer.Construct(referrer); + } + + nsCOMPtr<nsIGlobalObject> global = + do_QueryInterface(mWorklet->GetParentObject()); + MOZ_ASSERT(global); + + IgnoredErrorResult rv; + SafeRefPtr<Request> request = + Request::Constructor(global, aCx, requestInput, requestInit, rv); + if (rv.Failed()) { + return NS_ERROR_FAILURE; + } + + request->OverrideContentPolicyType(mWorklet->Impl()->ContentPolicyType()); + + RequestOrUSVString finalRequestInput; + finalRequestInput.SetAsRequest() = request.unsafeGetRawPtr(); + + RefPtr<Promise> fetchPromise = FetchRequest( + global, finalRequestInput, requestInit, CallerType::System, rv); + if (NS_WARN_IF(rv.Failed())) { + return NS_ERROR_FAILURE; + } + + RefPtr<WorkletScriptHandler> scriptHandler = + new WorkletScriptHandler(mWorklet, aURI); + fetchPromise->AppendNativeHandler(scriptHandler); + return NS_OK; +} + +void WorkletFetchHandler::HandleFetchFailed(nsIURI* aURI) { + nsCOMPtr<nsIRunnable> runnable = new FetchCompleteRunnable( + mWorklet->mImpl, aURI, NS_ERROR_FAILURE, nullptr, 0); + + if (NS_WARN_IF( + NS_FAILED(mWorklet->mImpl->SendControlMessage(runnable.forget())))) { + NS_WARNING("Failed to dispatch FetchCompleteRunnable to a worklet thread."); + } +} + +////////////////////////////////////////////////////////////// +// WorkletScriptHandler +////////////////////////////////////////////////////////////// +NS_IMPL_ISUPPORTS(WorkletScriptHandler, nsIStreamLoaderObserver) + +WorkletScriptHandler::WorkletScriptHandler(Worklet* aWorklet, nsIURI* aURI) + : mWorklet(aWorklet), mURI(aURI) {} + +void WorkletScriptHandler::ResolvedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue, + ErrorResult& aRv) { + MOZ_ASSERT(NS_IsMainThread()); + + if (!aValue.isObject()) { + HandleFailure(NS_ERROR_FAILURE); + return; + } + + RefPtr<Response> response; + nsresult rv = UNWRAP_OBJECT(Response, &aValue.toObject(), response); + if (NS_WARN_IF(NS_FAILED(rv))) { + HandleFailure(NS_ERROR_FAILURE); + return; + } + + // https://html.spec.whatwg.org/multipage/worklets.html#dom-worklet-addmodule + // Step 6.4.1. If script is null, then: + // Step 1.1.2. Reject promise with an "AbortError" DOMException. + if (!response->Ok()) { + HandleFailure(NS_ERROR_DOM_ABORT_ERR); + return; + } + + nsCOMPtr<nsIInputStream> inputStream; + response->GetBody(getter_AddRefs(inputStream)); + if (!inputStream) { + HandleFailure(NS_ERROR_DOM_NETWORK_ERR); + return; + } + + nsCOMPtr<nsIInputStreamPump> pump; + rv = NS_NewInputStreamPump(getter_AddRefs(pump), inputStream.forget()); + if (NS_WARN_IF(NS_FAILED(rv))) { + HandleFailure(rv); + return; + } + + nsCOMPtr<nsIStreamLoader> loader; + rv = NS_NewStreamLoader(getter_AddRefs(loader), this); + if (NS_WARN_IF(NS_FAILED(rv))) { + HandleFailure(rv); + return; + } + + rv = pump->AsyncRead(loader); + if (NS_WARN_IF(NS_FAILED(rv))) { + HandleFailure(rv); + return; + } + + nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(pump); + if (rr) { + nsCOMPtr<nsIEventTarget> sts = + do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID); + RefPtr<TaskQueue> queue = TaskQueue::Create( + sts.forget(), "WorkletScriptHandler STS Delivery Queue"); + rv = rr->RetargetDeliveryTo(queue); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to dispatch the nsIInputStreamPump to a IO thread."); + } + } +} + +NS_IMETHODIMP WorkletScriptHandler::OnStreamComplete(nsIStreamLoader* aLoader, + nsISupports* aContext, + nsresult aStatus, + uint32_t aStringLen, + const uint8_t* aString) { + MOZ_ASSERT(NS_IsMainThread()); + + if (NS_FAILED(aStatus)) { + HandleFailure(aStatus); + return NS_OK; + } + + // Copy the buffer and decode it on worklet thread, as we can only access + // ModuleLoadRequest on worklet thread. + UniquePtr<uint8_t[]> scriptTextBuf = MakeUnique<uint8_t[]>(aStringLen); + memcpy(scriptTextBuf.get(), aString, aStringLen); + + nsCOMPtr<nsIRunnable> runnable = new FetchCompleteRunnable( + mWorklet->mImpl, mURI, NS_OK, std::move(scriptTextBuf), aStringLen); + + if (NS_FAILED(mWorklet->mImpl->SendControlMessage(runnable.forget()))) { + HandleFailure(NS_ERROR_FAILURE); + } + + return NS_OK; +} + +void WorkletScriptHandler::RejectedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue, + ErrorResult& aRv) { + MOZ_ASSERT(NS_IsMainThread()); + + // https://html.spec.whatwg.org/multipage/worklets.html#dom-worklet-addmodule + // Step 6.4.1. If script is null, then: + // Step 1.1.2. Reject promise with an "AbortError" DOMException. + HandleFailure(NS_ERROR_DOM_ABORT_ERR); +} + +void WorkletScriptHandler::HandleFailure(nsresult aResult) { + DispatchFetchCompleteToWorklet(aResult); +} + +void WorkletScriptHandler::DispatchFetchCompleteToWorklet(nsresult aRv) { + nsCOMPtr<nsIRunnable> runnable = + new FetchCompleteRunnable(mWorklet->mImpl, mURI, aRv, nullptr, 0); + + if (NS_WARN_IF( + NS_FAILED(mWorklet->mImpl->SendControlMessage(runnable.forget())))) { + NS_WARNING("Failed to dispatch FetchCompleteRunnable to a worklet thread."); + } +} + +} // namespace mozilla::dom diff --git a/dom/worklet/WorkletFetchHandler.h b/dom/worklet/WorkletFetchHandler.h new file mode 100644 index 0000000000..a380caf9eb --- /dev/null +++ b/dom/worklet/WorkletFetchHandler.h @@ -0,0 +1,120 @@ +/* -*- 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_WorkletFetchHandler_h +#define mozilla_dom_WorkletFetchHandler_h + +#include "mozilla/dom/PromiseNativeHandler.h" +#include "mozilla/dom/RequestBinding.h" // RequestCredentials +#include "nsIStreamLoader.h" + +namespace mozilla::dom { +class Worklet; +struct WorkletOptions; +class WorkletScriptHandler; + +namespace loader { +class AddModuleThrowErrorRunnable; +} // namespace loader + +// WorkletFetchHandler is used to fetch the module scripts on the main thread, +// and notifies the result of addModule back to |aWorklet|. +class WorkletFetchHandler final : public nsISupports { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(WorkletFetchHandler) + + static already_AddRefed<Promise> AddModule(Worklet* aWorklet, JSContext* aCx, + const nsAString& aModuleURL, + const WorkletOptions& aOptions, + ErrorResult& aRv); + + // Load a module script on main thread. + nsresult StartFetch(JSContext* aCx, nsIURI* aURI, nsIURI* aReferrer); + + void ExecutionFailed(); + void ExecutionFailed(JS::Handle<JS::Value> aError); + + void ExecutionSucceeded(); + + void HandleFetchFailed(nsIURI* aURI); + + private: + WorkletFetchHandler(Worklet* aWorklet, Promise* aPromise, + RequestCredentials aCredentials); + + ~WorkletFetchHandler(); + + void AddPromise(JSContext* aCx, Promise* aPromise); + + void RejectPromises(nsresult aResult); + void RejectPromises(JS::Handle<JS::Value> aValue); + + void ResolvePromises(); + + friend class StartFetchRunnable; + friend class loader::AddModuleThrowErrorRunnable; + RefPtr<Worklet> mWorklet; + nsTArray<RefPtr<Promise>> mPromises; + + enum { ePending, eRejected, eResolved } mStatus; + + RequestCredentials mCredentials; + + bool mHasError = false; + JS::Heap<JS::Value> mErrorToRethrow; +}; + +// A Runnable to call WorkletFetchHandler::StartFetch on the main thread. +class StartFetchRunnable final : public Runnable { + public: + StartFetchRunnable( + const nsMainThreadPtrHandle<WorkletFetchHandler>& aHandlerRef, + nsIURI* aURI, nsIURI* aReferrer); + ~StartFetchRunnable() = default; + + NS_IMETHOD + Run() override; + + private: + nsMainThreadPtrHandle<WorkletFetchHandler> mHandlerRef; + nsCOMPtr<nsIURI> mURI; + nsCOMPtr<nsIURI> mReferrer; +}; + +// WorkletScriptHandler is used to handle the result of fetching the module +// script. +class WorkletScriptHandler final : public PromiseNativeHandler, + public nsIStreamLoaderObserver { + public: + NS_DECL_THREADSAFE_ISUPPORTS + + WorkletScriptHandler(Worklet* aWorklet, nsIURI* aURI); + + void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override; + + NS_IMETHOD + OnStreamComplete(nsIStreamLoader* aLoader, nsISupports* aContext, + nsresult aStatus, uint32_t aStringLen, + const uint8_t* aString) override; + + void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override; + + void HandleFailure(nsresult aResult); + + private: + ~WorkletScriptHandler() = default; + + void DispatchFetchCompleteToWorklet(nsresult aRv); + + RefPtr<Worklet> mWorklet; + nsCOMPtr<nsIURI> mURI; +}; + +} // namespace mozilla::dom +#endif // mozilla_dom_WorkletFetchHandler_h diff --git a/dom/worklet/WorkletGlobalScope.cpp b/dom/worklet/WorkletGlobalScope.cpp new file mode 100644 index 0000000000..9231f6b095 --- /dev/null +++ b/dom/worklet/WorkletGlobalScope.cpp @@ -0,0 +1,116 @@ +/* -*- 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 "WorkletGlobalScope.h" +#include "mozilla/dom/WorkletGlobalScopeBinding.h" +#include "mozilla/dom/WorkletImpl.h" +#include "mozilla/dom/WorkletThread.h" +#include "mozilla/dom/worklet/WorkletModuleLoader.h" +#include "mozilla/dom/Console.h" +#include "nsContentUtils.h" +#include "nsJSUtils.h" + +using JS::loader::ModuleLoaderBase; +using mozilla::dom::loader::WorkletModuleLoader; + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(WorkletGlobalScope) + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(WorkletGlobalScope) + NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER + NS_IMPL_CYCLE_COLLECTION_UNLINK(mConsole) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mModuleLoader) + tmp->UnlinkObjectsInGlobal(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(WorkletGlobalScope) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mConsole) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mModuleLoader) + tmp->TraverseObjectsInGlobal(cb); +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(WorkletGlobalScope) +NS_IMPL_CYCLE_COLLECTING_RELEASE(WorkletGlobalScope) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WorkletGlobalScope) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsIGlobalObject) + NS_INTERFACE_MAP_ENTRY(WorkletGlobalScope) +NS_INTERFACE_MAP_END + +WorkletGlobalScope::WorkletGlobalScope(WorkletImpl* aImpl) + : mImpl(aImpl), mCreationTimeStamp(TimeStamp::Now()) {} + +WorkletGlobalScope::~WorkletGlobalScope() = default; + +JSObject* WorkletGlobalScope::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + MOZ_CRASH("We should never get here!"); + return nullptr; +} + +already_AddRefed<Console> WorkletGlobalScope::GetConsole(JSContext* aCx, + ErrorResult& aRv) { + if (!mConsole) { + MOZ_ASSERT(Impl()); + const WorkletLoadInfo& loadInfo = Impl()->LoadInfo(); + mConsole = Console::CreateForWorklet(aCx, this, loadInfo.OuterWindowID(), + loadInfo.InnerWindowID(), aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + } + + RefPtr<Console> console = mConsole; + return console.forget(); +} + +void WorkletGlobalScope::InitModuleLoader(WorkletModuleLoader* aModuleLoader) { + MOZ_ASSERT(!mModuleLoader); + mModuleLoader = aModuleLoader; +} + +ModuleLoaderBase* WorkletGlobalScope::GetModuleLoader(JSContext* aCx) { + return mModuleLoader; +}; + +OriginTrials WorkletGlobalScope::Trials() const { return mImpl->Trials(); } + +Maybe<nsID> WorkletGlobalScope::GetAgentClusterId() const { + return mImpl->GetAgentClusterId(); +} + +bool WorkletGlobalScope::IsSharedMemoryAllowed() const { + return mImpl->IsSharedMemoryAllowed(); +} + +bool WorkletGlobalScope::ShouldResistFingerprinting(RFPTarget aTarget) const { + return mImpl->ShouldResistFingerprinting(aTarget); +} + +void WorkletGlobalScope::Dump(const Optional<nsAString>& aString) const { + WorkletThread::AssertIsOnWorkletThread(); + + if (!nsJSUtils::DumpEnabled()) { + return; + } + + if (!aString.WasPassed()) { + return; + } + + NS_ConvertUTF16toUTF8 str(aString.Value()); + + MOZ_LOG(nsContentUtils::DOMDumpLog(), mozilla::LogLevel::Debug, + ("[Worklet.Dump] %s", str.get())); +#ifdef ANDROID + __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", str.get()); +#endif + fputs(str.get(), stdout); + fflush(stdout); +} + +} // namespace mozilla::dom diff --git a/dom/worklet/WorkletGlobalScope.h b/dom/worklet/WorkletGlobalScope.h new file mode 100644 index 0000000000..c053d57331 --- /dev/null +++ b/dom/worklet/WorkletGlobalScope.h @@ -0,0 +1,102 @@ +/* -*- 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_WorkletGlobalScope_h +#define mozilla_dom_WorkletGlobalScope_h + +#include "mozilla/Attributes.h" +#include "mozilla/Maybe.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "nsDOMNavigationTiming.h" +#include "nsIGlobalObject.h" +#include "nsWrapperCache.h" + +#define WORKLET_IID \ + { \ + 0x1b3f62e7, 0xe357, 0x44be, { \ + 0xbf, 0xe0, 0xdf, 0x85, 0xe6, 0x56, 0x85, 0xac \ + } \ + } + +namespace JS::loader { +class ModuleLoaderBase; +} + +namespace mozilla { + +class ErrorResult; +class WorkletImpl; + +namespace dom { + +namespace loader { +class WorkletModuleLoader; +} + +class Console; + +class WorkletGlobalScope : public nsIGlobalObject, public nsWrapperCache { + public: + NS_DECLARE_STATIC_IID_ACCESSOR(WORKLET_IID) + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(WorkletGlobalScope) + + WorkletGlobalScope(WorkletImpl*); + + nsIGlobalObject* GetParentObject() const { return nullptr; } + + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + virtual bool WrapGlobalObject(JSContext* aCx, + JS::MutableHandle<JSObject*> aReflector) = 0; + + JSObject* GetGlobalJSObject() override { return GetWrapper(); } + JSObject* GetGlobalJSObjectPreserveColor() const override { + return GetWrapperPreserveColor(); + } + + already_AddRefed<Console> GetConsole(JSContext* aCx, ErrorResult& aRv); + + WorkletImpl* Impl() const { return mImpl.get(); } + + void Dump(const Optional<nsAString>& aString) const; + + DOMHighResTimeStamp TimeStampToDOMHighRes(const TimeStamp& aTimeStamp) const { + MOZ_ASSERT(!aTimeStamp.IsNull()); + TimeDuration duration = aTimeStamp - mCreationTimeStamp; + return duration.ToMilliseconds(); + } + + void InitModuleLoader(loader::WorkletModuleLoader* aModuleLoader); + + JS::loader::ModuleLoaderBase* GetModuleLoader( + JSContext* aCx = nullptr) override; + + OriginTrials Trials() const override; + Maybe<nsID> GetAgentClusterId() const override; + bool IsSharedMemoryAllowed() const override; + bool ShouldResistFingerprinting(RFPTarget aTarget) const override; + + protected: + ~WorkletGlobalScope(); + + const RefPtr<WorkletImpl> mImpl; + + private: + TimeStamp mCreationTimeStamp; + RefPtr<Console> mConsole; + RefPtr<loader::WorkletModuleLoader> mModuleLoader; +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(WorkletGlobalScope, WORKLET_IID) + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_WorkletGlobalScope_h diff --git a/dom/worklet/WorkletImpl.cpp b/dom/worklet/WorkletImpl.cpp new file mode 100644 index 0000000000..8b54f4d570 --- /dev/null +++ b/dom/worklet/WorkletImpl.cpp @@ -0,0 +1,152 @@ +/* -*- 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 https://mozilla.org/MPL/2.0/. */ + +#include "WorkletImpl.h" + +#include "Worklet.h" +#include "WorkletThread.h" + +#include "mozilla/BasePrincipal.h" +#include "mozilla/NullPrincipal.h" +#include "mozilla/dom/DocGroup.h" +#include "mozilla/dom/RegisterWorkletBindings.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/WorkletBinding.h" +#include "mozilla/dom/WorkletGlobalScope.h" +#include "mozilla/dom/worklet/WorkletModuleLoader.h" +#include "nsGlobalWindowInner.h" + +using mozilla::dom::loader::WorkletModuleLoader; +using mozilla::dom::loader::WorkletScriptLoader; + +namespace mozilla { +// --------------------------------------------------------------------------- +// WorkletLoadInfo + +WorkletLoadInfo::WorkletLoadInfo(nsPIDOMWindowInner* aWindow) + : mInnerWindowID(aWindow->WindowID()) { + MOZ_ASSERT(NS_IsMainThread()); + nsPIDOMWindowOuter* outerWindow = aWindow->GetOuterWindow(); + if (outerWindow) { + mOuterWindowID = outerWindow->WindowID(); + } else { + mOuterWindowID = 0; + } +} + +// --------------------------------------------------------------------------- +// WorkletImpl + +WorkletImpl::WorkletImpl(nsPIDOMWindowInner* aWindow, nsIPrincipal* aPrincipal) + : mPrincipal(NullPrincipal::CreateWithInheritedAttributes(aPrincipal)), + mWorkletLoadInfo(aWindow), + mTerminated(false), + mFinishedOnExecutionThread(false), + mTrials(OriginTrials::FromWindow(nsGlobalWindowInner::Cast(aWindow))) { + Unused << NS_WARN_IF( + NS_FAILED(ipc::PrincipalToPrincipalInfo(mPrincipal, &mPrincipalInfo))); + + if (aWindow->GetDocGroup()) { + mAgentClusterId.emplace(aWindow->GetDocGroup()->AgentClusterId()); + } + + mSharedMemoryAllowed = + nsGlobalWindowInner::Cast(aWindow)->IsSharedMemoryAllowed(); + + mShouldResistFingerprinting = aWindow->AsGlobal()->ShouldResistFingerprinting( + RFPTarget::IsAlwaysEnabledForPrecompute); +} + +WorkletImpl::~WorkletImpl() { MOZ_ASSERT(!mGlobalScope); } + +JSObject* WorkletImpl::WrapWorklet(JSContext* aCx, dom::Worklet* aWorklet, + JS::Handle<JSObject*> aGivenProto) { + MOZ_ASSERT(NS_IsMainThread()); + return dom::Worklet_Binding::Wrap(aCx, aWorklet, aGivenProto); +} + +dom::WorkletGlobalScope* WorkletImpl::GetGlobalScope() { + dom::WorkletThread::AssertIsOnWorkletThread(); + + if (mGlobalScope) { + return mGlobalScope; + } + if (mFinishedOnExecutionThread) { + return nullptr; + } + + dom::AutoJSAPI jsapi; + jsapi.Init(); + JSContext* cx = jsapi.cx(); + + mGlobalScope = ConstructGlobalScope(); + + JS::Rooted<JSObject*> global(cx); + NS_ENSURE_TRUE(mGlobalScope->WrapGlobalObject(cx, &global), nullptr); + + JSAutoRealm ar(cx, global); + + // Init Web IDL bindings + if (!dom::RegisterWorkletBindings(cx, global)) { + return nullptr; + } + + JS_FireOnNewGlobalObject(cx, global); + + MOZ_ASSERT(!mGlobalScope->GetModuleLoader(cx)); + + RefPtr<WorkletScriptLoader> scriptLoader = new WorkletScriptLoader(); + RefPtr<WorkletModuleLoader> moduleLoader = + new WorkletModuleLoader(scriptLoader, mGlobalScope); + mGlobalScope->InitModuleLoader(moduleLoader); + + return mGlobalScope; +} + +void WorkletImpl::NotifyWorkletFinished() { + MOZ_ASSERT(NS_IsMainThread()); + + if (mTerminated) { + return; + } + + // Release global scope on its thread. + SendControlMessage( + NS_NewRunnableFunction("WorkletImpl::NotifyWorkletFinished", + [self = RefPtr<WorkletImpl>(this)]() { + self->mFinishedOnExecutionThread = true; + self->mGlobalScope = nullptr; + })); + + mTerminated = true; + if (mWorkletThread) { + mWorkletThread->Terminate(); + mWorkletThread = nullptr; + } +} + +nsresult WorkletImpl::SendControlMessage( + already_AddRefed<nsIRunnable> aRunnable) { + MOZ_ASSERT(NS_IsMainThread()); + RefPtr<nsIRunnable> runnable = std::move(aRunnable); + + // TODO: bug 1492011 re ConsoleWorkletRunnable. + if (mTerminated) { + return NS_ERROR_ILLEGAL_DURING_SHUTDOWN; + } + + if (!mWorkletThread) { + // Thread creation. FIXME: this will change. + mWorkletThread = dom::WorkletThread::Create(this); + if (!mWorkletThread) { + return NS_ERROR_ILLEGAL_DURING_SHUTDOWN; + } + } + + return mWorkletThread->DispatchRunnable(runnable.forget()); +} + +} // namespace mozilla diff --git a/dom/worklet/WorkletImpl.h b/dom/worklet/WorkletImpl.h new file mode 100644 index 0000000000..2bc8742ab5 --- /dev/null +++ b/dom/worklet/WorkletImpl.h @@ -0,0 +1,131 @@ +/* -*- 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 https://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_worklet_WorkletImpl_h +#define mozilla_dom_worklet_WorkletImpl_h + +#include "MainThreadUtils.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/Maybe.h" +#include "mozilla/OriginAttributes.h" +#include "mozilla/OriginTrials.h" +#include "mozilla/ipc/PBackgroundSharedTypes.h" +#include "nsRFPService.h" + +class nsPIDOMWindowInner; +class nsIPrincipal; +class nsIRunnable; + +namespace mozilla { + +namespace dom { + +class Worklet; +class WorkletGlobalScope; +class WorkletThread; + +} // namespace dom + +class WorkletLoadInfo { + public: + explicit WorkletLoadInfo(nsPIDOMWindowInner* aWindow); + + uint64_t OuterWindowID() const { return mOuterWindowID; } + uint64_t InnerWindowID() const { return mInnerWindowID; } + + private: + // Modified only in constructor. + uint64_t mOuterWindowID; + const uint64_t mInnerWindowID; +}; + +/** + * WorkletImpl is accessed from both the worklet's parent thread (on which the + * Worklet object lives) and the worklet's execution thread. It is owned by + * Worklet and WorkletGlobalScope. No parent thread cycle collected objects + * are owned indefinitely by WorkletImpl because WorkletImpl is not cycle + * collected. + */ +class WorkletImpl { + using RFPTarget = mozilla::RFPTarget; + + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WorkletImpl); + + // Methods for parent thread only: + + virtual JSObject* WrapWorklet(JSContext* aCx, dom::Worklet* aWorklet, + JS::Handle<JSObject*> aGivenProto); + + virtual nsresult SendControlMessage(already_AddRefed<nsIRunnable> aRunnable); + + void NotifyWorkletFinished(); + + virtual nsContentPolicyType ContentPolicyType() const = 0; + + // Execution thread only. + dom::WorkletGlobalScope* GetGlobalScope(); + + // Any thread. + + const OriginTrials& Trials() const { return mTrials; } + const WorkletLoadInfo& LoadInfo() const { return mWorkletLoadInfo; } + const OriginAttributes& OriginAttributesRef() const { + return mPrincipal->OriginAttributesRef(); + } + nsIPrincipal* Principal() const { return mPrincipal; } + const ipc::PrincipalInfo& PrincipalInfo() const { return mPrincipalInfo; } + + const Maybe<nsID>& GetAgentClusterId() const { return mAgentClusterId; } + + bool IsSharedMemoryAllowed() const { return mSharedMemoryAllowed; } + bool IsSystemPrincipal() const { return mPrincipal->IsSystemPrincipal(); } + bool ShouldResistFingerprinting(RFPTarget aTarget) const { + return mShouldResistFingerprinting && + nsRFPService::IsRFPEnabledFor(aTarget); + } + + virtual void OnAddModuleStarted() const { + MOZ_ASSERT(NS_IsMainThread()); + // empty base impl + } + + virtual void OnAddModulePromiseSettled() const { + MOZ_ASSERT(NS_IsMainThread()); + // empty base impl + } + + protected: + WorkletImpl(nsPIDOMWindowInner* aWindow, nsIPrincipal* aPrincipal); + virtual ~WorkletImpl(); + + virtual already_AddRefed<dom::WorkletGlobalScope> ConstructGlobalScope() = 0; + + // Modified only in constructor. + ipc::PrincipalInfo mPrincipalInfo; + nsCOMPtr<nsIPrincipal> mPrincipal; + + const WorkletLoadInfo mWorkletLoadInfo; + + // Parent thread only. + RefPtr<dom::WorkletThread> mWorkletThread; + bool mTerminated; + + // Execution thread only. + RefPtr<dom::WorkletGlobalScope> mGlobalScope; + bool mFinishedOnExecutionThread; + + Maybe<nsID> mAgentClusterId; + + bool mSharedMemoryAllowed; + bool mShouldResistFingerprinting; + + const OriginTrials mTrials; +}; + +} // namespace mozilla + +#endif // mozilla_dom_worklet_WorkletImpl_h diff --git a/dom/worklet/WorkletThread.cpp b/dom/worklet/WorkletThread.cpp new file mode 100644 index 0000000000..c5ad7070b0 --- /dev/null +++ b/dom/worklet/WorkletThread.cpp @@ -0,0 +1,474 @@ +/* -*- 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 "WorkletThread.h" +#include "prthread.h" +#include "nsContentUtils.h" +#include "nsCycleCollector.h" +#include "nsJSEnvironment.h" +#include "nsJSPrincipals.h" +#include "mozilla/dom/AtomList.h" +#include "mozilla/dom/WorkletGlobalScope.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/Attributes.h" +#include "mozilla/CycleCollectedJSRuntime.h" +#include "mozilla/EventQueue.h" +#include "mozilla/ThreadEventQueue.h" +#include "js/ContextOptions.h" +#include "js/Exception.h" +#include "js/Initialization.h" +#include "XPCSelfHostedShmem.h" + +namespace mozilla::dom { + +namespace { + +// The size of the worklet runtime heaps in bytes. +#define WORKLET_DEFAULT_RUNTIME_HEAPSIZE 32 * 1024 * 1024 + +// The C stack size. We use the same stack size on all platforms for +// consistency. +const uint32_t kWorkletStackSize = 256 * sizeof(size_t) * 1024; + +// Half the size of the actual C stack, to be safe. +#define WORKLET_CONTEXT_NATIVE_STACK_LIMIT 128 * sizeof(size_t) * 1024 + +// Helper functions + +bool PreserveWrapper(JSContext* aCx, JS::Handle<JSObject*> aObj) { + MOZ_ASSERT(aCx); + MOZ_ASSERT(aObj); + MOZ_ASSERT(mozilla::dom::IsDOMObject(aObj)); + return mozilla::dom::TryPreserveWrapper(aObj); +} + +JSObject* Wrap(JSContext* aCx, JS::Handle<JSObject*> aExisting, + JS::Handle<JSObject*> aObj) { + if (aExisting) { + js::Wrapper::Renew(aExisting, aObj, + &js::OpaqueCrossCompartmentWrapper::singleton); + } + + return js::Wrapper::New(aCx, aObj, + &js::OpaqueCrossCompartmentWrapper::singleton); +} + +const JSWrapObjectCallbacks WrapObjectCallbacks = { + Wrap, + nullptr, +}; + +} // namespace + +// This classes control CC in the worklet thread. + +class WorkletJSRuntime final : public mozilla::CycleCollectedJSRuntime { + public: + explicit WorkletJSRuntime(JSContext* aCx) : CycleCollectedJSRuntime(aCx) {} + + ~WorkletJSRuntime() override = default; + + virtual void PrepareForForgetSkippable() override {} + + virtual void BeginCycleCollectionCallback( + mozilla::CCReason aReason) override {} + + virtual void EndCycleCollectionCallback( + CycleCollectorResults& aResults) override {} + + virtual void DispatchDeferredDeletion(bool aContinuation, + bool aPurge) override { + MOZ_ASSERT(!aContinuation); + nsCycleCollector_doDeferredDeletion(); + } + + virtual void CustomGCCallback(JSGCStatus aStatus) override { + // nsCycleCollector_collect() requires a cycle collector but + // ~WorkletJSContext calls nsCycleCollector_shutdown() and the base class + // destructor will trigger a final GC. The nsCycleCollector_collect() + // call can be skipped in this GC as ~CycleCollectedJSContext removes the + // context from |this|. + if (aStatus == JSGC_END && GetContext()) { + nsCycleCollector_collect(CCReason::GC_FINISHED, nullptr); + } + } +}; + +class WorkletJSContext final : public CycleCollectedJSContext { + public: + WorkletJSContext() { + MOZ_ASSERT(!NS_IsMainThread()); + + nsCycleCollector_startup(); + } + + // MOZ_CAN_RUN_SCRIPT_BOUNDARY because otherwise we have to annotate the + // SpiderMonkey JS::JobQueue's destructor as MOZ_CAN_RUN_SCRIPT, which is a + // bit of a pain. + MOZ_CAN_RUN_SCRIPT_BOUNDARY ~WorkletJSContext() override { + MOZ_ASSERT(!NS_IsMainThread()); + + JSContext* cx = MaybeContext(); + if (!cx) { + return; // Initialize() must have failed + } + + nsCycleCollector_shutdown(); + } + + WorkletJSContext* GetAsWorkletJSContext() override { return this; } + + CycleCollectedJSRuntime* CreateRuntime(JSContext* aCx) override { + return new WorkletJSRuntime(aCx); + } + + nsresult Initialize(JSRuntime* aParentRuntime) { + MOZ_ASSERT(!NS_IsMainThread()); + + nsresult rv = CycleCollectedJSContext::Initialize( + aParentRuntime, WORKLET_DEFAULT_RUNTIME_HEAPSIZE); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + JSContext* cx = Context(); + + js::SetPreserveWrapperCallbacks(cx, PreserveWrapper, HasReleasedWrapper); + JS_InitDestroyPrincipalsCallback(cx, nsJSPrincipals::Destroy); + JS_InitReadPrincipalsCallback(cx, nsJSPrincipals::ReadPrincipals); + JS_SetWrapObjectCallbacks(cx, &WrapObjectCallbacks); + JS_SetFutexCanWait(cx); + + return NS_OK; + } + + void DispatchToMicroTask( + already_AddRefed<MicroTaskRunnable> aRunnable) override { + RefPtr<MicroTaskRunnable> runnable(aRunnable); + + MOZ_ASSERT(!NS_IsMainThread()); + MOZ_ASSERT(runnable); + + JSContext* cx = Context(); + MOZ_ASSERT(cx); + +#ifdef DEBUG + JS::Rooted<JSObject*> global(cx, JS::CurrentGlobalOrNull(cx)); + MOZ_ASSERT(global); +#endif + + JS::JobQueueMayNotBeEmpty(cx); + GetMicroTaskQueue().push_back(std::move(runnable)); + } + + bool IsSystemCaller() const override { + // Currently no support for special system worklet privileges. + return false; + } + + void ReportError(JSErrorReport* aReport, + JS::ConstUTF8CharsZ aToStringResult) override; + + uint64_t GetCurrentWorkletWindowID() { + JSObject* global = JS::CurrentGlobalOrNull(Context()); + if (NS_WARN_IF(!global)) { + return 0; + } + nsIGlobalObject* nativeGlobal = xpc::NativeGlobal(global); + nsCOMPtr<WorkletGlobalScope> workletGlobal = + do_QueryInterface(nativeGlobal); + if (NS_WARN_IF(!workletGlobal)) { + return 0; + } + return workletGlobal->Impl()->LoadInfo().InnerWindowID(); + } +}; + +void WorkletJSContext::ReportError(JSErrorReport* aReport, + JS::ConstUTF8CharsZ aToStringResult) { + RefPtr<xpc::ErrorReport> xpcReport = new xpc::ErrorReport(); + xpcReport->Init(aReport, aToStringResult.c_str(), IsSystemCaller(), + GetCurrentWorkletWindowID()); + RefPtr<AsyncErrorReporter> reporter = new AsyncErrorReporter(xpcReport); + + JSContext* cx = Context(); + if (JS_IsExceptionPending(cx)) { + JS::ExceptionStack exnStack(cx); + if (JS::StealPendingExceptionStack(cx, &exnStack)) { + JS::Rooted<JSObject*> stack(cx); + JS::Rooted<JSObject*> stackGlobal(cx); + xpc::FindExceptionStackForConsoleReport(nullptr, exnStack.exception(), + exnStack.stack(), &stack, + &stackGlobal); + if (stack) { + reporter->SerializeStack(cx, stack); + } + } + } + + NS_DispatchToMainThread(reporter); +} + +// This is the first runnable to be dispatched. It calls the RunEventLoop() so +// basically everything happens into this runnable. The reason behind this +// approach is that, when the Worklet is terminated, it must not have any JS in +// stack, but, because we have CC, nsIThread creates an AutoNoJSAPI object by +// default. Using this runnable, CC exists only into it. +class WorkletThread::PrimaryRunnable final : public Runnable { + public: + explicit PrimaryRunnable(WorkletThread* aWorkletThread) + : Runnable("WorkletThread::PrimaryRunnable"), + mWorkletThread(aWorkletThread) { + MOZ_ASSERT(aWorkletThread); + MOZ_ASSERT(NS_IsMainThread()); + } + + NS_IMETHOD + Run() override { + mWorkletThread->RunEventLoop(); + return NS_OK; + } + + private: + RefPtr<WorkletThread> mWorkletThread; +}; + +// This is the last runnable to be dispatched. It calls the TerminateInternal() +class WorkletThread::TerminateRunnable final : public Runnable { + public: + explicit TerminateRunnable(WorkletThread* aWorkletThread) + : Runnable("WorkletThread::TerminateRunnable"), + mWorkletThread(aWorkletThread) { + MOZ_ASSERT(aWorkletThread); + MOZ_ASSERT(NS_IsMainThread()); + } + + NS_IMETHOD + Run() override { + mWorkletThread->TerminateInternal(); + return NS_OK; + } + + private: + RefPtr<WorkletThread> mWorkletThread; +}; + +WorkletThread::WorkletThread(WorkletImpl* aWorkletImpl) + : nsThread( + MakeNotNull<ThreadEventQueue*>(MakeUnique<mozilla::EventQueue>()), + nsThread::NOT_MAIN_THREAD, {.stackSize = kWorkletStackSize}), + mWorkletImpl(aWorkletImpl), + mExitLoop(false), + mIsTerminating(false) { + MOZ_ASSERT(NS_IsMainThread()); + nsContentUtils::RegisterShutdownObserver(this); +} + +WorkletThread::~WorkletThread() = default; + +// static +already_AddRefed<WorkletThread> WorkletThread::Create( + WorkletImpl* aWorkletImpl) { + RefPtr<WorkletThread> thread = new WorkletThread(aWorkletImpl); + if (NS_WARN_IF(NS_FAILED(thread->Init("DOM Worklet"_ns)))) { + return nullptr; + } + + RefPtr<PrimaryRunnable> runnable = new PrimaryRunnable(thread); + if (NS_WARN_IF(NS_FAILED(thread->DispatchRunnable(runnable.forget())))) { + return nullptr; + } + + return thread.forget(); +} + +nsresult WorkletThread::DispatchRunnable( + already_AddRefed<nsIRunnable> aRunnable) { + nsCOMPtr<nsIRunnable> runnable(aRunnable); + return nsThread::Dispatch(runnable.forget(), NS_DISPATCH_NORMAL); +} + +NS_IMETHODIMP +WorkletThread::DispatchFromScript(nsIRunnable* aRunnable, uint32_t aFlags) { + nsCOMPtr<nsIRunnable> runnable(aRunnable); + return Dispatch(runnable.forget(), aFlags); +} + +NS_IMETHODIMP +WorkletThread::Dispatch(already_AddRefed<nsIRunnable> aRunnable, + uint32_t aFlags) { + nsCOMPtr<nsIRunnable> runnable(aRunnable); + + // Worklet only supports asynchronous dispatch. + if (NS_WARN_IF(aFlags != NS_DISPATCH_NORMAL)) { + return NS_ERROR_UNEXPECTED; + } + + return nsThread::Dispatch(runnable.forget(), NS_DISPATCH_NORMAL); +} + +NS_IMETHODIMP +WorkletThread::DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t aFlags) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +static bool DispatchToEventLoop(void* aClosure, + JS::Dispatchable* aDispatchable) { + // This callback may execute either on the worklet thread or a random + // JS-internal helper thread. + + // See comment at JS::InitDispatchToEventLoop() below for how we know the + // thread is alive. + nsIThread* thread = static_cast<nsIThread*>(aClosure); + + nsresult rv = thread->Dispatch( + NS_NewRunnableFunction( + "WorkletThread::DispatchToEventLoop", + [aDispatchable]() { + CycleCollectedJSContext* ccjscx = CycleCollectedJSContext::Get(); + if (!ccjscx) { + return; + } + + WorkletJSContext* wjc = ccjscx->GetAsWorkletJSContext(); + if (!wjc) { + return; + } + + aDispatchable->run(wjc->Context(), + JS::Dispatchable::NotShuttingDown); + }), + NS_DISPATCH_NORMAL); + + return NS_SUCCEEDED(rv); +} + +// static +void WorkletThread::EnsureCycleCollectedJSContext( + JSRuntime* aParentRuntime, const JS::ContextOptions& aOptions) { + CycleCollectedJSContext* ccjscx = CycleCollectedJSContext::Get(); + if (ccjscx) { + MOZ_ASSERT(ccjscx->GetAsWorkletJSContext()); + return; + } + + WorkletJSContext* context = new WorkletJSContext(); + nsresult rv = context->Initialize(aParentRuntime); + if (NS_WARN_IF(NS_FAILED(rv))) { + // TODO: error propagation + return; + } + + JS::ContextOptionsRef(context->Context()) = aOptions; + + JS_SetGCParameter(context->Context(), JSGC_MAX_BYTES, uint32_t(-1)); + + // FIXME: JS_SetDefaultLocale + // FIXME: JSSettings + // FIXME: JS_SetSecurityCallbacks + // FIXME: JS::SetAsyncTaskCallbacks + // FIXME: JS::SetCTypesActivityCallback + // FIXME: JS_SetGCZeal + + // A thread lives strictly longer than its JSRuntime so we can safely + // store a raw pointer as the callback's closure argument on the JSRuntime. + JS::InitDispatchToEventLoop(context->Context(), DispatchToEventLoop, + NS_GetCurrentThread()); + + JS_SetNativeStackQuota(context->Context(), + WORKLET_CONTEXT_NATIVE_STACK_LIMIT); + + // When available, set the self-hosted shared memory to be read, so that we + // can decode the self-hosted content instead of parsing it. + auto& shm = xpc::SelfHostedShmem::GetSingleton(); + JS::SelfHostedCache selfHostedContent = shm.Content(); + + if (!JS::InitSelfHostedCode(context->Context(), selfHostedContent)) { + // TODO: error propagation + return; + } +} + +void WorkletThread::RunEventLoop() { + MOZ_ASSERT(!NS_IsMainThread()); + + PR_SetCurrentThreadName("worklet"); + + while (!mExitLoop) { + MOZ_ALWAYS_TRUE(NS_ProcessNextEvent(this, /* wait: */ true)); + } + + DeleteCycleCollectedJSContext(); +} + +void WorkletThread::Terminate() { + MOZ_ASSERT(NS_IsMainThread()); + + if (mIsTerminating) { + // nsThread::Dispatch() would leak the runnable if the event queue is no + // longer accepting runnables. + return; + } + + mIsTerminating = true; + + nsContentUtils::UnregisterShutdownObserver(this); + + RefPtr<TerminateRunnable> runnable = new TerminateRunnable(this); + DispatchRunnable(runnable.forget()); +} + +void WorkletThread::TerminateInternal() { + MOZ_ASSERT(!CycleCollectedJSContext::Get() || IsOnWorkletThread()); + + mExitLoop = true; + + nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod( + "WorkletThread::Shutdown", this, &WorkletThread::Shutdown); + NS_DispatchToMainThread(runnable); +} + +/* static */ +void WorkletThread::DeleteCycleCollectedJSContext() { + CycleCollectedJSContext* ccjscx = CycleCollectedJSContext::Get(); + if (!ccjscx) { + return; + } + + // Release any MessagePort kept alive by its ipc actor. + mozilla::ipc::BackgroundChild::CloseForCurrentThread(); + + WorkletJSContext* workletjscx = ccjscx->GetAsWorkletJSContext(); + MOZ_ASSERT(workletjscx); + delete workletjscx; +} + +/* static */ +bool WorkletThread::IsOnWorkletThread() { + CycleCollectedJSContext* ccjscx = CycleCollectedJSContext::Get(); + return ccjscx && ccjscx->GetAsWorkletJSContext(); +} + +/* static */ +void WorkletThread::AssertIsOnWorkletThread() { + MOZ_ASSERT(IsOnWorkletThread()); +} + +// nsIObserver +NS_IMETHODIMP +WorkletThread::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t*) { + MOZ_ASSERT(strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0); + + // The WorkletImpl will terminate the worklet thread after sending a message + // to release worklet thread objects. + mWorkletImpl->NotifyWorkletFinished(); + return NS_OK; +} + +NS_IMPL_ISUPPORTS_INHERITED(WorkletThread, nsThread, nsIObserver) + +} // namespace mozilla::dom diff --git a/dom/worklet/WorkletThread.h b/dom/worklet/WorkletThread.h new file mode 100644 index 0000000000..e6d0e414dc --- /dev/null +++ b/dom/worklet/WorkletThread.h @@ -0,0 +1,78 @@ +/* -*- 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_worklet_WorkletThread_h +#define mozilla_dom_worklet_WorkletThread_h + +#include "mozilla/Attributes.h" +#include "mozilla/CondVar.h" +#include "mozilla/RefPtr.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/dom/WorkletImpl.h" +#include "nsIObserver.h" +#include "nsThread.h" + +class nsIRunnable; + +namespace JS { +class ContextOptions; +}; // namespace JS + +namespace mozilla::dom { + +class WorkletThread final : public nsThread, public nsIObserver { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIOBSERVER + + static already_AddRefed<WorkletThread> Create(WorkletImpl* aWorkletImpl); + + // Threads that call EnsureCycleCollectedJSContext must call + // DeleteCycleCollectedJSContext::Get() before terminating. Clients of + // Create() do not need to do this as Terminate() will ensure this happens. + static void EnsureCycleCollectedJSContext(JSRuntime* aParentRuntime, + const JS::ContextOptions& aOptions); + static void DeleteCycleCollectedJSContext(); + + static bool IsOnWorkletThread(); + + static void AssertIsOnWorkletThread(); + + nsresult DispatchRunnable(already_AddRefed<nsIRunnable> aRunnable); + + void Terminate(); + + private: + explicit WorkletThread(WorkletImpl* aWorkletImpl); + ~WorkletThread(); + + void RunEventLoop(); + class PrimaryRunnable; + + void TerminateInternal(); + class TerminateRunnable; + + // This should only be called by consumers that have an + // nsIEventTarget/nsIThread pointer. + NS_IMETHOD + Dispatch(already_AddRefed<nsIRunnable> aRunnable, uint32_t aFlags) override; + + NS_IMETHOD + DispatchFromScript(nsIRunnable* aRunnable, uint32_t aFlags) override; + + NS_IMETHOD + DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t) override; + + const RefPtr<WorkletImpl> mWorkletImpl; + + bool mExitLoop; // worklet execution thread + + bool mIsTerminating; // main thread +}; + +} // namespace mozilla::dom + +#endif // mozilla_dom_worklet_WorkletThread_h diff --git a/dom/worklet/loader/WorkletModuleLoader.cpp b/dom/worklet/loader/WorkletModuleLoader.cpp new file mode 100644 index 0000000000..34353107f8 --- /dev/null +++ b/dom/worklet/loader/WorkletModuleLoader.cpp @@ -0,0 +1,297 @@ +/* -*- 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 "WorkletModuleLoader.h" + +#include "js/CompileOptions.h" // JS::InstantiateOptions +#include "js/experimental/JSStencil.h" // JS::CompileModuleScriptToStencil, JS::InstantiateModuleStencil +#include "js/loader/ModuleLoadRequest.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/Unused.h" +#include "mozilla/dom/StructuredCloneHolder.h" +#include "mozilla/dom/Worklet.h" +#include "mozilla/dom/WorkletFetchHandler.h" +#include "nsStringBundle.h" + +using JS::loader::ModuleLoadRequest; +using JS::loader::ResolveError; + +namespace mozilla::dom::loader { + +////////////////////////////////////////////////////////////// +// WorkletScriptLoader +////////////////////////////////////////////////////////////// + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WorkletScriptLoader) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTION(WorkletScriptLoader) + +NS_IMPL_CYCLE_COLLECTING_ADDREF(WorkletScriptLoader) +NS_IMPL_CYCLE_COLLECTING_RELEASE(WorkletScriptLoader) + +////////////////////////////////////////////////////////////// +// WorkletModuleLoader +////////////////////////////////////////////////////////////// + +NS_IMPL_ADDREF_INHERITED(WorkletModuleLoader, ModuleLoaderBase) +NS_IMPL_RELEASE_INHERITED(WorkletModuleLoader, ModuleLoaderBase) + +NS_IMPL_CYCLE_COLLECTION_INHERITED(WorkletModuleLoader, ModuleLoaderBase, + mFetchingRequests) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WorkletModuleLoader) +NS_INTERFACE_MAP_END_INHERITING(ModuleLoaderBase) + +WorkletModuleLoader::WorkletModuleLoader(WorkletScriptLoader* aScriptLoader, + nsIGlobalObject* aGlobalObject) + : ModuleLoaderBase(aScriptLoader, aGlobalObject, + GetCurrentSerialEventTarget()) { + // This should be constructed on a worklet thread. + MOZ_ASSERT(!NS_IsMainThread()); +} + +already_AddRefed<ModuleLoadRequest> WorkletModuleLoader::CreateStaticImport( + nsIURI* aURI, ModuleLoadRequest* aParent) { + const nsMainThreadPtrHandle<WorkletFetchHandler>& handlerRef = + aParent->GetWorkletLoadContext()->GetHandlerRef(); + RefPtr<WorkletLoadContext> loadContext = new WorkletLoadContext(handlerRef); + + // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-the-descendants-of-a-module-script + // Step 11. Perform the internal module script graph fetching procedure + // + // https://html.spec.whatwg.org/multipage/webappapis.html#internal-module-script-graph-fetching-procedure + // Step 5. Fetch a single module script with referrer is referringScript's + // base URL, + nsIURI* referrer = aParent->mURI; + RefPtr<ModuleLoadRequest> request = new ModuleLoadRequest( + aURI, aParent->mFetchOptions, SRIMetadata(), referrer, loadContext, + false, /* is top level */ + false, /* is dynamic import */ + this, aParent->mVisitedSet, aParent->GetRootModule()); + + request->mURL = request->mURI->GetSpecOrDefault(); + return request.forget(); +} + +already_AddRefed<ModuleLoadRequest> WorkletModuleLoader::CreateDynamicImport( + JSContext* aCx, nsIURI* aURI, LoadedScript* aMaybeActiveScript, + JS::Handle<JS::Value> aReferencingPrivate, JS::Handle<JSString*> aSpecifier, + JS::Handle<JSObject*> aPromise) { + return nullptr; +} + +bool WorkletModuleLoader::CanStartLoad(ModuleLoadRequest* aRequest, + nsresult* aRvOut) { + return true; +} + +nsresult WorkletModuleLoader::StartFetch(ModuleLoadRequest* aRequest) { + InsertRequest(aRequest->mURI, aRequest); + + RefPtr<StartFetchRunnable> runnable = + new StartFetchRunnable(aRequest->GetWorkletLoadContext()->GetHandlerRef(), + aRequest->mURI, aRequest->mReferrer); + NS_DispatchToMainThread(runnable.forget()); + return NS_OK; +} + +nsresult WorkletModuleLoader::CompileFetchedModule( + JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::CompileOptions& aOptions, + ModuleLoadRequest* aRequest, JS::MutableHandle<JSObject*> aModuleScript) { + RefPtr<JS::Stencil> stencil; + MOZ_ASSERT(aRequest->IsTextSource()); + + MaybeSourceText maybeSource; + nsresult rv = aRequest->GetScriptSource(aCx, &maybeSource); + NS_ENSURE_SUCCESS(rv, rv); + + auto compile = [&](auto& source) { + return JS::CompileModuleScriptToStencil(aCx, aOptions, source); + }; + stencil = maybeSource.mapNonEmpty(compile); + + if (!stencil) { + return NS_ERROR_FAILURE; + } + + JS::InstantiateOptions instantiateOptions(aOptions); + aModuleScript.set( + JS::InstantiateModuleStencil(aCx, instantiateOptions, stencil)); + return aModuleScript ? NS_OK : NS_ERROR_FAILURE; +} + +// AddModuleResultRunnable is a Runnable which will notify the result of +// Worklet::AddModule on the main thread. +class AddModuleResultRunnable final : public Runnable { + public: + explicit AddModuleResultRunnable( + const nsMainThreadPtrHandle<WorkletFetchHandler>& aHandlerRef, + bool aSucceeded) + : Runnable("Worklet::AddModuleResultRunnable"), + mHandlerRef(aHandlerRef), + mSucceeded(aSucceeded) { + MOZ_ASSERT(!NS_IsMainThread()); + } + + ~AddModuleResultRunnable() = default; + + NS_IMETHOD + Run() override; + + private: + nsMainThreadPtrHandle<WorkletFetchHandler> mHandlerRef; + bool mSucceeded; +}; + +NS_IMETHODIMP +AddModuleResultRunnable::Run() { + MOZ_ASSERT(NS_IsMainThread()); + if (mSucceeded) { + mHandlerRef->ExecutionSucceeded(); + } else { + mHandlerRef->ExecutionFailed(); + } + + return NS_OK; +} + +class AddModuleThrowErrorRunnable final : public Runnable, + public StructuredCloneHolder { + public: + explicit AddModuleThrowErrorRunnable( + const nsMainThreadPtrHandle<WorkletFetchHandler>& aHandlerRef) + : Runnable("Worklet::AddModuleThrowErrorRunnable"), + StructuredCloneHolder(CloningSupported, TransferringNotSupported, + StructuredCloneScope::SameProcess), + mHandlerRef(aHandlerRef) { + MOZ_ASSERT(!NS_IsMainThread()); + } + + ~AddModuleThrowErrorRunnable() = default; + + NS_IMETHOD + Run() override; + + private: + nsMainThreadPtrHandle<WorkletFetchHandler> mHandlerRef; +}; + +NS_IMETHODIMP +AddModuleThrowErrorRunnable::Run() { + MOZ_ASSERT(NS_IsMainThread()); + + nsCOMPtr<nsIGlobalObject> global = + do_QueryInterface(mHandlerRef->mWorklet->GetParentObject()); + MOZ_ASSERT(global); + + AutoJSAPI jsapi; + if (NS_WARN_IF(!jsapi.Init(global))) { + mHandlerRef->ExecutionFailed(); + return NS_ERROR_FAILURE; + } + + JSContext* cx = jsapi.cx(); + JS::Rooted<JS::Value> error(cx); + ErrorResult result; + Read(global, cx, &error, result); + Unused << NS_WARN_IF(result.Failed()); + mHandlerRef->ExecutionFailed(error); + + return NS_OK; +} + +void WorkletModuleLoader::OnModuleLoadComplete(ModuleLoadRequest* aRequest) { + if (!aRequest->IsTopLevel()) { + return; + } + + const nsMainThreadPtrHandle<WorkletFetchHandler>& handlerRef = + aRequest->GetWorkletLoadContext()->GetHandlerRef(); + + auto addModuleFailed = MakeScopeExit([&] { + RefPtr<AddModuleResultRunnable> runnable = + new AddModuleResultRunnable(handlerRef, false); + NS_DispatchToMainThread(runnable.forget()); + }); + + if (!aRequest->mModuleScript) { + return; + } + + if (!aRequest->InstantiateModuleGraph()) { + return; + } + + nsresult rv = aRequest->EvaluateModule(); + if (NS_FAILED(rv)) { + return; + } + + bool hasError = aRequest->mModuleScript->HasErrorToRethrow(); + if (hasError) { + AutoJSAPI jsapi; + if (NS_WARN_IF(!jsapi.Init(GetGlobalObject()))) { + return; + } + + JSContext* cx = jsapi.cx(); + JS::Rooted<JS::Value> error(cx, aRequest->mModuleScript->ErrorToRethrow()); + RefPtr<AddModuleThrowErrorRunnable> runnable = + new AddModuleThrowErrorRunnable(handlerRef); + ErrorResult result; + runnable->Write(cx, error, result); + if (NS_WARN_IF(result.Failed())) { + return; + } + + addModuleFailed.release(); + NS_DispatchToMainThread(runnable.forget()); + return; + } + + addModuleFailed.release(); + RefPtr<AddModuleResultRunnable> runnable = + new AddModuleResultRunnable(handlerRef, true); + NS_DispatchToMainThread(runnable.forget()); +} + +// TODO: Bug 1808301: Call FormatLocalizedString from a worklet thread. +nsresult WorkletModuleLoader::GetResolveFailureMessage( + ResolveError aError, const nsAString& aSpecifier, nsAString& aResult) { + uint8_t index = static_cast<uint8_t>(aError); + MOZ_ASSERT(index < static_cast<uint8_t>(ResolveError::Length)); + MOZ_ASSERT(mLocalizedStrs); + MOZ_ASSERT(!mLocalizedStrs->IsEmpty()); + if (!mLocalizedStrs || NS_WARN_IF(mLocalizedStrs->IsEmpty())) { + return NS_ERROR_FAILURE; + } + + const nsString& localizedStr = mLocalizedStrs->ElementAt(index); + + AutoTArray<nsString, 1> params; + params.AppendElement(aSpecifier); + + nsStringBundleBase::FormatString(localizedStr.get(), params, aResult); + return NS_OK; +} + +void WorkletModuleLoader::InsertRequest(nsIURI* aURI, + ModuleLoadRequest* aRequest) { + mFetchingRequests.InsertOrUpdate(aURI, aRequest); +} + +void WorkletModuleLoader::RemoveRequest(nsIURI* aURI) { + MOZ_ASSERT(mFetchingRequests.Remove(aURI)); +} + +ModuleLoadRequest* WorkletModuleLoader::GetRequest(nsIURI* aURI) const { + RefPtr<ModuleLoadRequest> req; + MOZ_ALWAYS_TRUE(mFetchingRequests.Get(aURI, getter_AddRefs(req))); + return req; +} + +} // namespace mozilla::dom::loader diff --git a/dom/worklet/loader/WorkletModuleLoader.h b/dom/worklet/loader/WorkletModuleLoader.h new file mode 100644 index 0000000000..818720ced8 --- /dev/null +++ b/dom/worklet/loader/WorkletModuleLoader.h @@ -0,0 +1,119 @@ +/* -*- 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_worklet_WorkletModuleLoader_h +#define mozilla_dom_worklet_WorkletModuleLoader_h + +#include "js/loader/LoadContextBase.h" +#include "js/loader/ModuleLoaderBase.h" +#include "js/loader/ResolveResult.h" // For ResolveError +#include "mozilla/dom/WorkletFetchHandler.h" + +namespace mozilla::dom { +namespace loader { +class WorkletScriptLoader : public JS::loader::ScriptLoaderInterface { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS(WorkletScriptLoader) + + nsIURI* GetBaseURI() const override { return nullptr; } + + void ReportErrorToConsole(ScriptLoadRequest* aRequest, + nsresult aResult) const override {} + + void ReportWarningToConsole( + ScriptLoadRequest* aRequest, const char* aMessageName, + const nsTArray<nsString>& aParams) const override {} + + nsresult FillCompileOptionsForRequest( + JSContext* cx, ScriptLoadRequest* aRequest, JS::CompileOptions* aOptions, + JS::MutableHandle<JSScript*> aIntroductionScript) override { + aOptions->setIntroductionType("Worklet"); + aOptions->setFileAndLine(aRequest->mURL.get(), 1); + aOptions->setIsRunOnce(true); + aOptions->setNoScriptRval(true); + return NS_OK; + } + + private: + ~WorkletScriptLoader() = default; +}; + +class WorkletModuleLoader : public JS::loader::ModuleLoaderBase { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(WorkletModuleLoader, + JS::loader::ModuleLoaderBase) + + WorkletModuleLoader(WorkletScriptLoader* aScriptLoader, + nsIGlobalObject* aGlobalObject); + + void InsertRequest(nsIURI* aURI, JS::loader::ModuleLoadRequest* aRequest); + void RemoveRequest(nsIURI* aURI); + JS::loader::ModuleLoadRequest* GetRequest(nsIURI* aURI) const; + + bool HasSetLocalizedStrings() const { return (bool)mLocalizedStrs; } + void SetLocalizedStrings(const nsTArray<nsString>* aStrings) { + mLocalizedStrs = aStrings; + } + + private: + ~WorkletModuleLoader() = default; + + already_AddRefed<JS::loader::ModuleLoadRequest> CreateStaticImport( + nsIURI* aURI, JS::loader::ModuleLoadRequest* aParent) override; + + already_AddRefed<JS::loader::ModuleLoadRequest> CreateDynamicImport( + JSContext* aCx, nsIURI* aURI, LoadedScript* aMaybeActiveScript, + JS::Handle<JS::Value> aReferencingPrivate, + JS::Handle<JSString*> aSpecifier, + JS::Handle<JSObject*> aPromise) override; + + bool CanStartLoad(JS::loader::ModuleLoadRequest* aRequest, + nsresult* aRvOut) override; + + nsresult StartFetch(JS::loader::ModuleLoadRequest* aRequest) override; + + nsresult CompileFetchedModule( + JSContext* aCx, JS::Handle<JSObject*> aGlobal, + JS::CompileOptions& aOptions, JS::loader::ModuleLoadRequest* aRequest, + JS::MutableHandle<JSObject*> aModuleScript) override; + + void OnModuleLoadComplete(JS::loader::ModuleLoadRequest* aRequest) override; + + nsresult GetResolveFailureMessage(JS::loader::ResolveError aError, + const nsAString& aSpecifier, + nsAString& aResult) override; + + // A hashtable to map a nsIURI(from main thread) to a ModuleLoadRequest(in + // worklet thread). + nsRefPtrHashtable<nsURIHashKey, JS::loader::ModuleLoadRequest> + mFetchingRequests; + + // We get the localized strings on the main thread, and pass it to + // WorkletModuleLoader. + const nsTArray<nsString>* mLocalizedStrs = nullptr; +}; +} // namespace loader + +class WorkletLoadContext : public JS::loader::LoadContextBase { + public: + explicit WorkletLoadContext( + const nsMainThreadPtrHandle<WorkletFetchHandler>& aHandlerRef) + : JS::loader::LoadContextBase(JS::loader::ContextKind::Worklet), + mHandlerRef(aHandlerRef) {} + + const nsMainThreadPtrHandle<WorkletFetchHandler>& GetHandlerRef() const { + return mHandlerRef; + } + + private: + ~WorkletLoadContext() = default; + + nsMainThreadPtrHandle<WorkletFetchHandler> mHandlerRef; +}; +} // namespace mozilla::dom +#endif // mozilla_dom_worklet_WorkletModuleLoader_h diff --git a/dom/worklet/loader/moz.build b/dom/worklet/loader/moz.build new file mode 100644 index 0000000000..38707a81cc --- /dev/null +++ b/dom/worklet/loader/moz.build @@ -0,0 +1,20 @@ +# -*- 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/. + +with Files("**"): + BUG_COMPONENT = ("Core", "DOM: Core & HTML") + +EXPORTS.mozilla.dom.worklet += [ + "WorkletModuleLoader.h", +] + +UNIFIED_SOURCES += [ + "WorkletModuleLoader.cpp", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" diff --git a/dom/worklet/moz.build b/dom/worklet/moz.build new file mode 100644 index 0000000000..f08e75bd19 --- /dev/null +++ b/dom/worklet/moz.build @@ -0,0 +1,36 @@ +# -*- 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/. + +with Files("**"): + BUG_COMPONENT = ("Core", "DOM: Core & HTML") + +DIRS += ["loader"] + +EXPORTS.mozilla.dom += [ + "Worklet.h", + "WorkletFetchHandler.h", + "WorkletGlobalScope.h", + "WorkletImpl.h", + "WorkletThread.h", +] + +UNIFIED_SOURCES += [ + "Worklet.cpp", + "WorkletFetchHandler.cpp", + "WorkletGlobalScope.cpp", + "WorkletImpl.cpp", + "WorkletThread.cpp", +] + +LOCAL_INCLUDES += [ + "/js/xpconnect/src", +] + +include("/ipc/chromium/chromium-config.mozbuild") + +MOCHITEST_MANIFESTS += ["tests/mochitest.ini"] + +FINAL_LIBRARY = "xul" diff --git a/dom/worklet/tests/common.js b/dom/worklet/tests/common.js new file mode 100644 index 0000000000..df6005cfe4 --- /dev/null +++ b/dom/worklet/tests/common.js @@ -0,0 +1,23 @@ +window.onload = function () { + // We are the parent. Let's load the test. + if (parent == this || !location.search.includes("worklet_iframe")) { + SimpleTest.waitForExplicitFinish(); + + configureTest().then(() => { + var iframe = document.createElement("iframe"); + iframe.src = location.href + "?worklet_iframe"; + document.body.appendChild(iframe); + }); + + return; + } + + // Here we are in the iframe. + window.SimpleTest = parent.SimpleTest; + window.is = parent.is; + window.isnot = parent.isnot; + window.ok = parent.ok; + window.info = parent.info; + + runTestInIframe(); +}; diff --git a/dom/worklet/tests/dynamic_import.js b/dom/worklet/tests/dynamic_import.js new file mode 100644 index 0000000000..a5196d212f --- /dev/null +++ b/dom/worklet/tests/dynamic_import.js @@ -0,0 +1,7 @@ +import("./empty-worklet-script.js") + .then(() => { + console.log("Fail"); + }) + .catch(e => { + console.log(e.name + ": Success"); + }); diff --git a/dom/worklet/tests/invalid_specifier.mjs b/dom/worklet/tests/invalid_specifier.mjs new file mode 100644 index 0000000000..128b60ffa6 --- /dev/null +++ b/dom/worklet/tests/invalid_specifier.mjs @@ -0,0 +1,3 @@ +/* eslint-disable import/no-unassigned-import */ +/* eslint-disable import/no-unresolved */ +import "foo"; diff --git a/dom/worklet/tests/mochitest.ini b/dom/worklet/tests/mochitest.ini new file mode 100644 index 0000000000..ebc85359cb --- /dev/null +++ b/dom/worklet/tests/mochitest.ini @@ -0,0 +1,40 @@ +[DEFAULT] +scheme = https +support-files = + common.js + +[test_audioWorklet.html] +support-files=worklet_audioWorklet.js +[test_audioWorkletGlobalScopeRegisterProcessor.html] +support-files=worklet_test_audioWorkletGlobalScopeRegisterProcessor.js +[test_audioWorklet_WASM.html] +skip-if = release_or_beta # requires dom.postMessage.sharedArrayBuffer.bypassCOOP_COEP.insecure.enabled +support-files=worklet_audioWorklet_WASM.js +[test_audioWorklet_insecureContext.html] +scheme = http +skip-if = + http3 +[test_audioWorklet_options.html] +skip-if = release_or_beta # requires dom.postMessage.sharedArrayBuffer.bypassCOOP_COEP.insecure.enabled +support-files=worklet_audioWorklet_options.js +[test_basic.html] +[test_console.html] +support-files=worklet_console.js +[test_dump.html] +support-files=worklet_dump.js +[test_dynamic_import.html] +support-files=dynamic_import.js +[test_exception.html] +support-files = + worklet_exception.js + invalid_specifier.mjs +[test_fetch_failed.html] +support-files=specifier_with_user.mjs +[test_import_with_cache.html] +skip-if = verify +support-files=server_import_with_cache.sjs +[test_paintWorklet.html] +skip-if = release_or_beta +support-files=worklet_paintWorklet.js +[test_promise.html] +support-files=worklet_promise.js diff --git a/dom/worklet/tests/server_import_with_cache.sjs b/dom/worklet/tests/server_import_with_cache.sjs new file mode 100644 index 0000000000..ed34a7a72f --- /dev/null +++ b/dom/worklet/tests/server_import_with_cache.sjs @@ -0,0 +1,12 @@ +function handleRequest(request, response) { + response.setHeader("Content-Type", "text/javascript", false); + + var state = getState("alreadySent"); + if (!state) { + setState("alreadySent", "1"); + } else { + response.setStatusLine("1.1", 404, "Not Found"); + } + + response.write("42"); +} diff --git a/dom/worklet/tests/specifier_with_user.mjs b/dom/worklet/tests/specifier_with_user.mjs new file mode 100644 index 0000000000..3d9bdb45cf --- /dev/null +++ b/dom/worklet/tests/specifier_with_user.mjs @@ -0,0 +1,3 @@ +/* eslint-disable import/no-unassigned-import */ +/* eslint-disable import/no-unresolved */ +import "http://user@example1.com/a.js"; diff --git a/dom/worklet/tests/test_audioWorklet.html b/dom/worklet/tests/test_audioWorklet.html new file mode 100644 index 0000000000..f7f3665e2f --- /dev/null +++ b/dom/worklet/tests/test_audioWorklet.html @@ -0,0 +1,53 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for AudioWorklet</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + const ConsoleAPIStorage = SpecialPowers.Cc[ + "@mozilla.org/consoleAPI-storage;1" + ].getService(SpecialPowers.Ci.nsIConsoleAPIStorage); + + function consoleListener() { + this.observe = this.observe.bind(this); + ConsoleAPIStorage.addLogEventListener(this.observe, SpecialPowers.wrap(document).nodePrincipal); + } + + consoleListener.prototype = { + observe(aSubject) { + var obj = aSubject.wrappedJSObject; + if (obj.arguments[0] == "So far so good") { + ok(true, "Message received \\o/"); + + ConsoleAPIStorage.removeLogEventListener(this.observe); + SimpleTest.finish(); + return; + } + } + } + + var cl = new consoleListener(); + + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + ok(window.isSecureContext, "Test should run in secure context"); + var audioContext = new AudioContext(); + ok(audioContext.audioWorklet instanceof AudioWorklet, + "AudioContext.audioWorklet should be an instance of AudioWorklet"); + audioContext.audioWorklet.addModule("worklet_audioWorklet.js") +} +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_audioWorkletGlobalScopeRegisterProcessor.html b/dom/worklet/tests/test_audioWorkletGlobalScopeRegisterProcessor.html new file mode 100644 index 0000000000..c26df05ad0 --- /dev/null +++ b/dom/worklet/tests/test_audioWorkletGlobalScopeRegisterProcessor.html @@ -0,0 +1,78 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for AudioWorklet</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + + var expected_errors = [ + "TypeError: AudioWorkletGlobalScope.registerProcessor: Argument 2 is not a constructor.", + "NotSupportedError: AudioWorkletGlobalScope.registerProcessor: Argument 1 should not be an empty string.", + "TypeError: AudioWorkletGlobalScope.registerProcessor: Argument 2 is not an object.", + "TypeError: AudioWorkletGlobalScope.registerProcessor: Element 0 in parameterDescriptors can't be converted to a dictionary.", + "NotSupportedError: AudioWorkletGlobalScope.registerProcessor: Argument 1 is invalid: a class with the same name is already registered.", + "TypeError: AudioWorkletGlobalScope.registerProcessor: Missing required 'name' member of AudioParamDescriptor.", + "TypeError: AudioWorkletGlobalScope.registerProcessor: 'defaultValue' member of AudioParamDescriptor is not a finite floating-point value.", + "TypeError: AudioWorkletGlobalScope.registerProcessor: 'minValue' member of AudioParamDescriptor is not a finite floating-point value.", + "TypeError: AudioWorkletGlobalScope.registerProcessor: 'maxValue' member of AudioParamDescriptor is not a finite floating-point value.", + "NotSupportedError: AudioWorkletGlobalScope.registerProcessor: Duplicated name \"test\" in parameterDescriptors.", + "TypeError: AudioWorkletGlobalScope.registerProcessor: Element 0 in parameterDescriptors can't be converted to a dictionary.", + "InvalidStateError: AudioWorkletGlobalScope.registerProcessor: In parameterDescriptors, test defaultValue is out of the range defined by minValue and maxValue.", + "InvalidStateError: AudioWorkletGlobalScope.registerProcessor: In parameterDescriptors, test defaultValue is out of the range defined by minValue and maxValue.", + "InvalidStateError: AudioWorkletGlobalScope.registerProcessor: In parameterDescriptors, test minValue should be smaller than maxValue.", + ]; + + var expected_errors_i = 0; + + const ConsoleAPIStorage = SpecialPowers.Cc[ + "@mozilla.org/consoleAPI-storage;1" + ].getService(SpecialPowers.Ci.nsIConsoleAPIStorage); + + function consoleListener() { + this.observe = this.observe.bind(this); + ConsoleAPIStorage.addLogEventListener(this.observe, SpecialPowers.wrap(document).nodePrincipal); + } + + consoleListener.prototype = { + observe(aSubject) { + var obj = aSubject.wrappedJSObject; + if (obj.arguments[0] == expected_errors[expected_errors_i]) { + ok(true, "Expected error received: " + obj.arguments[0]); + expected_errors_i++; + } + + if (expected_errors_i == expected_errors.length) { + // All errors have been received, this test has been completed + // succesfully! + ConsoleAPIStorage.removeLogEventListener(this.observe); + SimpleTest.finish(); + return; + } + } + } + + var cl = new consoleListener(); + + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + ok(window.isSecureContext, "Test should run in secure context"); + var audioContext = new AudioContext(); + ok(audioContext.audioWorklet instanceof AudioWorklet, + "AudioContext.audioWorklet should be an instance of AudioWorklet"); + audioContext.audioWorklet.addModule("worklet_test_audioWorkletGlobalScopeRegisterProcessor.js") +} +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_audioWorklet_WASM.html b/dom/worklet/tests/test_audioWorklet_WASM.html new file mode 100644 index 0000000000..127cc8b924 --- /dev/null +++ b/dom/worklet/tests/test_audioWorklet_WASM.html @@ -0,0 +1,85 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for AudioWorklet + WASM</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true], + ["dom.postMessage.sharedArrayBuffer.bypassCOOP_COEP.insecure.enabled", true], + ["browser.tabs.remote.useCrossOriginOpenerPolicy", true], + ["browser.tabs.remote.useCrossOriginEmbedderPolicy", true], + ["javascript.options.shared_memory", true], + ]}); +} + +function create_wasmModule() { + return new Promise(resolve => { + info("Checking if we can play with WebAssembly..."); + + if (!SpecialPowers.Cu.getJSTestingFunctions().wasmIsSupported()) { + resolve(null); + return; + } + + ok(WebAssembly, "WebAssembly object should exist"); + ok(WebAssembly.compile, "WebAssembly.compile function should exist"); + + const wasmTextToBinary = SpecialPowers.unwrap(SpecialPowers.Cu.getJSTestingFunctions().wasmTextToBinary); + /* + js -e ' + t = wasmTextToBinary(` + (module + (func $foo (result i32) (i32.const 42)) + (export "foo" (func $foo)) + ) + `); + print(t) + ' + */ + // eslint-disable-next-line + const fooModuleCode = new Uint8Array([0,97,115,109,1,0,0,0,1,5,1,96,0,1,127,3,2,1,0,7,7,1,3,102,111,111,0,0,10,6,1,4,0,65,42,11,0,13,4,110,97,109,101,1,6,1,0,3,102,111,111]); + + WebAssembly.compile(fooModuleCode).then(m => { + ok(m instanceof WebAssembly.Module, "The WasmModule has been compiled."); + resolve(m); + }, () => { + ok(false, "The compilation of the wasmModule failed."); + resolve(null); + }); + }); +} + +function runTestInIframe() { + let audioContext = new AudioContext(); + audioContext.audioWorklet.addModule("worklet_audioWorklet_WASM.js") + .then(() => create_wasmModule()) + .then(wasmModule => { + const node = new AudioWorkletNode(audioContext, 'wasm'); + let msgId = 0; + node.port.onmessage = e => { + if (msgId++ == 0) { + ok(e.data.wasmModule instanceof WebAssembly.Module, "WasmModule received"); + } else { + ok(e.data.sab instanceof SharedArrayBuffer, "SAB received"); + SimpleTest.finish(); + } + } + + node.port.postMessage({wasmModule}); + node.port.postMessage({sab: new SharedArrayBuffer(1024)}); + node.connect(audioContext.destination); + }); +} +</script> + +</body> +</html> diff --git a/dom/worklet/tests/test_audioWorklet_insecureContext.html b/dom/worklet/tests/test_audioWorklet_insecureContext.html new file mode 100644 index 0000000000..3cbb419ac3 --- /dev/null +++ b/dom/worklet/tests/test_audioWorklet_insecureContext.html @@ -0,0 +1,29 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for No AudioWorklet in insecure context</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + ok(!window.isSecureContext, "Test should run in an insecure context"); + var audioContext = new AudioContext(); + ok(!("audioWorklet" in audioContext), + "AudioWorklet shouldn't be defined in AudioContext in a insecure context"); + SimpleTest.finish(); +} +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_audioWorklet_options.html b/dom/worklet/tests/test_audioWorklet_options.html new file mode 100644 index 0000000000..df7a8b5649 --- /dev/null +++ b/dom/worklet/tests/test_audioWorklet_options.html @@ -0,0 +1,81 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for AudioWorklet + Options + WASM</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> +<script type="application/javascript"> + +function configureTest() { + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true], + ["dom.postMessage.sharedArrayBuffer.bypassCOOP_COEP.insecure.enabled", true], + ["browser.tabs.remote.useCrossOriginOpenerPolicy", true], + ["browser.tabs.remote.useCrossOriginEmbedderPolicy", true], + ["javascript.options.shared_memory", true], + ]}); +} + +function create_wasmModule() { + return new Promise(resolve => { + info("Checking if we can play with WebAssembly..."); + + if (!SpecialPowers.Cu.getJSTestingFunctions().wasmIsSupported()) { + resolve(null); + return; + } + + ok(WebAssembly, "WebAssembly object should exist"); + ok(WebAssembly.compile, "WebAssembly.compile function should exist"); + + const wasmTextToBinary = SpecialPowers.unwrap(SpecialPowers.Cu.getJSTestingFunctions().wasmTextToBinary); + + /* + js -e ' + t = wasmTextToBinary(` + (module + (func $foo (result i32) (i32.const 42)) + (export "foo" (func $foo)) + ) + `); + print(t) + ' + */ + // eslint-disable-next-line + const fooModuleCode = new Uint8Array([0,97,115,109,1,0,0,0,1,5,1,96,0,1,127,3,2,1,0,7,7,1,3,102,111,111,0,0,10,6,1,4,0,65,42,11,0,13,4,110,97,109,101,1,6,1,0,3,102,111,111]); + + WebAssembly.compile(fooModuleCode).then(m => { + ok(m instanceof WebAssembly.Module, "The WasmModule has been compiled."); + resolve(m); + }, () => { + ok(false, "The compilation of the wasmModule failed."); + resolve(null); + }); + }); +} + +function runTestInIframe() { + let audioContext = new AudioContext(); + audioContext.audioWorklet.addModule("worklet_audioWorklet_options.js") + .then(() => create_wasmModule()) + .then(wasmModule => { + const node = new AudioWorkletNode(audioContext, 'options', { processorOptions: { + wasmModule, sab: new SharedArrayBuffer(1024), + }}); + node.port.onmessage = e => { + ok(e.data.wasmModule instanceof WebAssembly.Module, "WasmModule received"); + ok(e.data.sab instanceof SharedArrayBuffer, "SAB received"); + SimpleTest.finish(); + } + + node.connect(audioContext.destination); + }); +} + +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_basic.html b/dom/worklet/tests/test_basic.html new file mode 100644 index 0000000000..b13cadd6d1 --- /dev/null +++ b/dom/worklet/tests/test_basic.html @@ -0,0 +1,66 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Worklet</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + var audioContext = new AudioContext(); + ok(!!audioContext.audioWorklet, "audioContext.audioWorklet exists"); + + // First loading + audioContext.audioWorklet.addModule("common.js") + .then(() => { + ok(true, "Import should load a resource."); + }) + + // Second loading - same file + .then(() => { + return audioContext.audioWorklet.addModule("common.js") + }) + .then(() => { + ok(true, "Import should load a resource."); + }) + + // 3rd loading - a network error + .then(() => { + return audioContext.audioWorklet.addModule("404.js"); + }) + .then(() => { + ok(false, "The loading should fail."); + }, () => { + ok(true, "The loading should fail."); + }) + + // 4th loading - a network error + .then(() => { + return audioContext.audioWorklet.addModule("404.js"); + }) + .then(() => { + ok(false, "The loading should fail."); + }, () => { + ok(true, "The loading should fail."); + }) + + // done + .then(() => { + SimpleTest.finish(); + }); +} + +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_console.html b/dom/worklet/tests/test_console.html new file mode 100644 index 0000000000..c33b93001f --- /dev/null +++ b/dom/worklet/tests/test_console.html @@ -0,0 +1,54 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Worklet - Console</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> +const WORKLET_SCRIPT = "worklet_console.js"; + +function configureTest() { + const ConsoleAPIStorage = SpecialPowers.Cc[ + "@mozilla.org/consoleAPI-storage;1" + ].getService(SpecialPowers.Ci.nsIConsoleAPIStorage); + + function consoleListener() { + this.observe = this.observe.bind(this); + ConsoleAPIStorage.addLogEventListener(this.observe, SpecialPowers.wrap(document).nodePrincipal); + } + + consoleListener.prototype = { + observe(aSubject) { + var obj = aSubject.wrappedJSObject; + if (obj.arguments[0] == "Hello world from a worklet") { + ok(true, "Message received \\o/"); + is(obj.filename, + new URL(WORKLET_SCRIPT, document.baseURI).toString()); + + ConsoleAPIStorage.removeLogEventListener(this.observe); + SimpleTest.finish(); + return; + } + } + } + + var cl = new consoleListener(); + + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + var audioContext = new AudioContext(); + audioContext.audioWorklet.addModule(WORKLET_SCRIPT); +} + +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_dump.html b/dom/worklet/tests/test_dump.html new file mode 100644 index 0000000000..f7885a1e21 --- /dev/null +++ b/dom/worklet/tests/test_dump.html @@ -0,0 +1,30 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Worklet - Console</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + var audioContext = new AudioContext(); + audioContext.audioWorklet.addModule("worklet_dump.js") + .then(() => { + ok(true, "All good!"); + SimpleTest.finish(); + }); +} +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_dynamic_import.html b/dom/worklet/tests/test_dynamic_import.html new file mode 100644 index 0000000000..e0326b976c --- /dev/null +++ b/dom/worklet/tests/test_dynamic_import.html @@ -0,0 +1,54 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test import() should throw a TypeError for Worklets</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> +const WORKLET_SCRIPT = "dynamic_import.js"; + +function configureTest() { + const ConsoleAPIStorage = SpecialPowers.Cc[ + "@mozilla.org/consoleAPI-storage;1" + ].getService(SpecialPowers.Ci.nsIConsoleAPIStorage); + + // We use console API to check if a TypeError has been thrown, as worklets + // have limitations to post the result back to the main document: + // Worklets have a different global, and they don't have postMessage() APIs, + // and static import SimpleTest.js in worklets also don't work. + function consoleListener() { + this.observe = this.observe.bind(this); + ConsoleAPIStorage.addLogEventListener(this.observe, SpecialPowers.wrap(document).nodePrincipal); + } + + consoleListener.prototype = { + observe(aSubject) { + var obj = aSubject.wrappedJSObject; + info("Got console message:" + obj.arguments[0]); + is(TypeError.name + ": Success", obj.arguments[0], "import() should throw"); + + ConsoleAPIStorage.removeLogEventListener(this.observe); + SimpleTest.finish(); + } + } + + var cl = new consoleListener(); + + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + var audioContext = new AudioContext(); + audioContext.audioWorklet.addModule(WORKLET_SCRIPT); +} + +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_exception.html b/dom/worklet/tests/test_exception.html new file mode 100644 index 0000000000..598dc859f3 --- /dev/null +++ b/dom/worklet/tests/test_exception.html @@ -0,0 +1,73 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Exception in Worklet script</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + let error; + + // This loading should fail + var audioContext = new AudioContext(); + audioContext.audioWorklet.addModule("404.js") + .then(() => { + ok(false, "We should not be called!"); + }, () => { + ok(true, "The script thrown but we are still here."); + }) + + // This should throw from JS + .then(() => { + return audioContext.audioWorklet.addModule("worklet_exception.js") + }) + .then(() => { + ok(true, "The script threw but we are still here."); + }, () => { + ok(false, "We should not be called!"); + }) + + // invalid_specifier.mjs will throw a TypeError. + .then(() => { + return audioContext.audioWorklet.addModule("invalid_specifier.mjs") + }) + .then(() => { + ok(false, "We should not be called!"); + }, (e) => { + ok(true, "The script thrown but we are still here."); + ok(e instanceof TypeError, "The error should be a TypeError."); + error = e; + }) + + // import "invalid_specifier.mjs" again, this will reuse the response from the + // previous addModule("invalid_specifier.mjs") call. + .then(() => { + return audioContext.audioWorklet.addModule("invalid_specifier.mjs") + }) + .then(() => { + ok(false, "We should not be called!"); + }, (e) => { + ok(true, "The script thrown but we are still here."); + ok (e === error, "The TypeError object should be reused."); + }) + + .then(() => { + SimpleTest.finish(); + }); +} + +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_fetch_failed.html b/dom/worklet/tests/test_fetch_failed.html new file mode 100644 index 0000000000..b5d316805f --- /dev/null +++ b/dom/worklet/tests/test_fetch_failed.html @@ -0,0 +1,39 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test fetch an child module script with an invalid uri for Worklet</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + var audioContext = new AudioContext(); + ok(!!audioContext.audioWorklet, "audioContext.audioWorklet exists"); + + audioContext.audioWorklet.addModule("specifier_with_user.mjs") + .then(() => { + ok(false, "Error: load shouldn't succeed."); + }, () => { + ok(true, "OK: load should fail."); + }) + + // done + .then(() => { + SimpleTest.finish(); + }); +} + +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_import_with_cache.html b/dom/worklet/tests/test_import_with_cache.html new file mode 100644 index 0000000000..de1744f9cc --- /dev/null +++ b/dom/worklet/tests/test_import_with_cache.html @@ -0,0 +1,49 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for Worklet</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + var audioContext = new AudioContext(); + function loading() { + audioContext.audioWorklet.addModule("server_import_with_cache.sjs") + .then(() => { + ok(true, "Import should load a resource."); + }, () => { + ok(false, "Import should load a resource."); + }) + .then(() => { + done(); + }); + } + + var count = 0; + const MAX = 10; + + function done() { + if (++count == MAX) { + SimpleTest.finish(); + } + } + + for (var i = 0; i < MAX; ++i) { + loading(); + } +} +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_paintWorklet.html b/dom/worklet/tests/test_paintWorklet.html new file mode 100644 index 0000000000..a02a2757fb --- /dev/null +++ b/dom/worklet/tests/test_paintWorklet.html @@ -0,0 +1,49 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for PaintWorklet</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + const ConsoleAPIStorage = SpecialPowers.Cc[ + "@mozilla.org/consoleAPI-storage;1" + ].getService(SpecialPowers.Ci.nsIConsoleAPIStorage); + + function consoleListener() { + this.observe = this.observe.bind(this); + ConsoleAPIStorage.addLogEventListener(this.observe, SpecialPowers.wrap(document).nodePrincipal); + } + + consoleListener.prototype = { + observe(aSubject) { + var obj = aSubject.wrappedJSObject; + if (obj.arguments[0] == "So far so good") { + ok(true, "Message received \\o/"); + + ConsoleAPIStorage.removeLogEventListener(this.observe); + SimpleTest.finish(); + return; + } + } + } + + var cl = new consoleListener(); + + return SpecialPowers.pushPrefEnv( + {"set": [["dom.paintWorklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +// This function is called into an iframe. +function runTestInIframe() { + paintWorklet.addModule("worklet_paintWorklet.js") +} +</script> +</body> +</html> diff --git a/dom/worklet/tests/test_promise.html b/dom/worklet/tests/test_promise.html new file mode 100644 index 0000000000..8ea71af9a6 --- /dev/null +++ b/dom/worklet/tests/test_promise.html @@ -0,0 +1,57 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Test for promise in worklet</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> + <script type="application/javascript" src="common.js"></script> +</head> +<body> + +<script type="application/javascript"> + +function configureTest() { + return SpecialPowers.pushPrefEnv( + {"set": [["dom.audioworklet.enabled", true], + ["dom.worklet.enabled", true]]}); +} + +function runTestInIframe() { + if (!SpecialPowers.Cu.getJSTestingFunctions().wasmIsSupported()) { + SimpleTest.finish(); + return; + } + + ok(window.isSecureContext, "Test should run in secure context"); + var audioContext = new AudioContext(); + ok(audioContext.audioWorklet instanceof AudioWorklet, + "AudioContext.audioWorklet should be an instance of AudioWorklet"); + audioContext.audioWorklet.addModule("worklet_promise.js") + .then(() => { + const node = new AudioWorkletNode(audioContext, 'promise'); + node.port.onmessage = e => { + ok(e.data instanceof WebAssembly.Module, "The WasmModule has been compiled into the worklet."); + SimpleTest.finish(); + } + + const wasmTextToBinary = SpecialPowers.unwrap(SpecialPowers.Cu.getJSTestingFunctions().wasmTextToBinary); + /* + js -e ' + t = wasmTextToBinary(` + (module + (func $foo (result i32) (i32.const 42)) + (export "foo" (func $foo)) + ) + `); + print(t) + ' + */ + // eslint-disable-next-line + const fooModuleCode = new Uint8Array([0,97,115,109,1,0,0,0,1,5,1,96,0,1,127,3,2,1,0,7,7,1,3,102,111,111,0,0,10,6,1,4,0,65,42,11,0,13,4,110,97,109,101,1,6,1,0,3,102,111,111]); + + node.port.postMessage(fooModuleCode); + }); +} +</script> +</body> +</html> diff --git a/dom/worklet/tests/worklet_audioWorklet.js b/dom/worklet/tests/worklet_audioWorklet.js new file mode 100644 index 0000000000..fa916d4359 --- /dev/null +++ b/dom/worklet/tests/worklet_audioWorklet.js @@ -0,0 +1,16 @@ +class DummyProcessWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } +} + +// We need to pass a valid AudioWorkletProcessor here, otherwise, it will fail, +// and the console.log won't be executed +registerProcessor("sure!", DummyProcessWorkletProcessor); +console.log( + globalThis instanceof AudioWorkletGlobalScope ? "So far so good" : "error" +); diff --git a/dom/worklet/tests/worklet_audioWorklet_WASM.js b/dom/worklet/tests/worklet_audioWorklet_WASM.js new file mode 100644 index 0000000000..1215b4c8d0 --- /dev/null +++ b/dom/worklet/tests/worklet_audioWorklet_WASM.js @@ -0,0 +1,16 @@ +class WasmProcessWorkletProcessor extends AudioWorkletProcessor { + constructor(...args) { + super(...args); + this.port.onmessage = e => { + // Let's send it back. + this.port.postMessage(e.data); + }; + } + + process(inputs, outputs, parameters) { + // Do nothing, output silence + return true; + } +} + +registerProcessor("wasm", WasmProcessWorkletProcessor); diff --git a/dom/worklet/tests/worklet_audioWorklet_options.js b/dom/worklet/tests/worklet_audioWorklet_options.js new file mode 100644 index 0000000000..eb7a704234 --- /dev/null +++ b/dom/worklet/tests/worklet_audioWorklet_options.js @@ -0,0 +1,12 @@ +class OptionsProcessWorkletProcessor extends AudioWorkletProcessor { + constructor(...args) { + super(...args); + this.port.postMessage(args[0].processorOptions); + } + + process(inputs, outputs, parameters) { + return true; + } +} + +registerProcessor("options", OptionsProcessWorkletProcessor); diff --git a/dom/worklet/tests/worklet_console.js b/dom/worklet/tests/worklet_console.js new file mode 100644 index 0000000000..557beb1af2 --- /dev/null +++ b/dom/worklet/tests/worklet_console.js @@ -0,0 +1 @@ +console.log("Hello world from a worklet"); diff --git a/dom/worklet/tests/worklet_dump.js b/dom/worklet/tests/worklet_dump.js new file mode 100644 index 0000000000..439d13f700 --- /dev/null +++ b/dom/worklet/tests/worklet_dump.js @@ -0,0 +1 @@ +dump("Hello world from a worklet"); diff --git a/dom/worklet/tests/worklet_exception.js b/dom/worklet/tests/worklet_exception.js new file mode 100644 index 0000000000..f3b473756e --- /dev/null +++ b/dom/worklet/tests/worklet_exception.js @@ -0,0 +1 @@ +foobar(); diff --git a/dom/worklet/tests/worklet_paintWorklet.js b/dom/worklet/tests/worklet_paintWorklet.js new file mode 100644 index 0000000000..7cf5256e51 --- /dev/null +++ b/dom/worklet/tests/worklet_paintWorklet.js @@ -0,0 +1,5 @@ +// This should work for real... at some point. +registerPaint("sure!", () => {}); +console.log( + globalThis instanceof PaintWorkletGlobalScope ? "So far so good" : "error" +); diff --git a/dom/worklet/tests/worklet_promise.js b/dom/worklet/tests/worklet_promise.js new file mode 100644 index 0000000000..8c593fd001 --- /dev/null +++ b/dom/worklet/tests/worklet_promise.js @@ -0,0 +1,22 @@ +class WasmProcessWorkletProcessor extends AudioWorkletProcessor { + constructor(...args) { + super(...args); + this.port.onmessage = e => { + WebAssembly.compile(e.data).then( + m => { + this.port.postMessage(m); + }, + () => { + this.port.postMessage("error"); + } + ); + }; + } + + process(inputs, outputs, parameters) { + // Do nothing, output silence + return true; + } +} + +registerProcessor("promise", WasmProcessWorkletProcessor); diff --git a/dom/worklet/tests/worklet_test_audioWorkletGlobalScopeRegisterProcessor.js b/dom/worklet/tests/worklet_test_audioWorkletGlobalScopeRegisterProcessor.js new file mode 100644 index 0000000000..cddb9524ec --- /dev/null +++ b/dom/worklet/tests/worklet_test_audioWorkletGlobalScopeRegisterProcessor.js @@ -0,0 +1,384 @@ +// Define several classes. +class EmptyWorkletProcessor extends AudioWorkletProcessor {} + +class NoProcessWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } +} + +class BadDescriptorsWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return "A string"; + } +} + +class GoodDescriptorsWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [ + { + name: "myParam", + defaultValue: 0.707, + }, + ]; + } +} + +class DummyProcessWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } +} + +class DescriptorsNoNameWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [ + { + defaultValue: 0.707, + }, + ]; + } +} + +class DescriptorsDefaultValueNotNumberWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [ + { + name: "test", + defaultValue: "test", + }, + ]; + } +} + +class DescriptorsMinValueNotNumberWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [ + { + name: "test", + minValue: "test", + }, + ]; + } +} + +class DescriptorsMaxValueNotNumberWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [ + { + name: "test", + maxValue: "test", + }, + ]; + } +} + +class DescriptorsDuplicatedNameWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [ + { + name: "test", + }, + { + name: "test", + }, + ]; + } +} + +class DescriptorsNotDictWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [42]; + } +} + +class DescriptorsOutOfRangeMinWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [ + { + name: "test", + defaultValue: 0, + minValue: 1, + maxValue: 2, + }, + ]; + } +} + +class DescriptorsOutOfRangeMaxWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [ + { + name: "test", + defaultValue: 3, + minValue: 1, + maxValue: 2, + }, + ]; + } +} + +class DescriptorsBadRangeMaxWorkletProcessor extends AudioWorkletProcessor { + constructor() { + super(); + } + + process() { + // Do nothing, output silence + } + + static get parameterDescriptors() { + return [ + { + name: "test", + defaultValue: 1.5, + minValue: 2, + maxValue: 1, + }, + ]; + } +} + +// Test not a constructor +// "TypeError: Argument 2 of AudioWorkletGlobalScope.registerProcessor is not a constructor." +try { + registerProcessor("sure!", () => {}); +} catch (e) { + console.log(e); +} + +// Test empty name +// "NotSupportedError: Argument 1 of AudioWorkletGlobalScope.registerProcessor should not be an empty string." +try { + registerProcessor("", EmptyWorkletProcessor); +} catch (e) { + console.log(e); +} + +// Test not an object +// "TypeError: Argument 2 of AudioWorkletGlobalScope.registerProcessor is not an object." +try { + registerProcessor("my-worklet-processor", ""); +} catch (e) { + console.log(e); +} + +// Test Empty class definition +registerProcessor("empty-worklet-processor", EmptyWorkletProcessor); + +// Test class with constructor but not process function +registerProcessor("no-worklet-processor", NoProcessWorkletProcessor); + +// Test class with parameterDescriptors being iterable, but the elements are not +// dictionaries. +// "TypeError: AudioWorkletGlobalScope.registerProcessor: Element 0 in parameterDescriptors can't be converted to a dictionary.", +try { + registerProcessor( + "bad-descriptors-worklet-processor", + BadDescriptorsWorkletProcessor + ); +} catch (e) { + console.log(e); +} + +// Test class with good parameterDescriptors +// No error expected here +registerProcessor( + "good-descriptors-worklet-processor", + GoodDescriptorsWorkletProcessor +); + +// Test class with constructor and process function +// No error expected here +registerProcessor("dummy-worklet-processor", DummyProcessWorkletProcessor); + +// Test class adding class with the same name twice +// "NotSupportedError: Operation is not supported: Argument 1 of AudioWorkletGlobalScope.registerProcessor is invalid: a class with the same name is already registered." +try { + registerProcessor("dummy-worklet-processor", DummyProcessWorkletProcessor); +} catch (e) { + console.log(e); +} + +// "name" is a mandatory field in descriptors +// "TypeError: Missing required 'name' member of AudioParamDescriptor." +try { + registerProcessor( + "descriptors-no-name-worklet-processor", + DescriptorsNoNameWorkletProcessor + ); +} catch (e) { + console.log(e); +} + +// "defaultValue" should be a number +// "TypeError: 'defaultValue' member of AudioParamDescriptor is not a finite floating-point value." +try { + registerProcessor( + "descriptors-default-value-not-number-worklet-processor", + DescriptorsDefaultValueNotNumberWorkletProcessor + ); +} catch (e) { + console.log(e); +} + +// "min" should be a number +// "TypeError: 'minValue' member of AudioParamDescriptor is not a finite floating-point value." +try { + registerProcessor( + "descriptors-min-value-not-number-worklet-processor", + DescriptorsMinValueNotNumberWorkletProcessor + ); +} catch (e) { + console.log(e); +} + +// "max" should be a number +// "TypeError: 'maxValue' member of AudioParamDescriptor is not a finite floating-point value." +try { + registerProcessor( + "descriptors-max-value-not-number-worklet-processor", + DescriptorsMaxValueNotNumberWorkletProcessor + ); +} catch (e) { + console.log(e); +} + +// Duplicated values are not allowed for "name" +// "NotSupportedError: Duplicated name \"test\" in parameterDescriptors" +try { + registerProcessor( + "descriptors-duplicated-name-worklet-processor", + DescriptorsDuplicatedNameWorkletProcessor + ); +} catch (e) { + console.log(e); +} + +// Descriptors' elements should be dictionnary +// "TypeError: Element 0 in parameterDescriptors can't be converted to a dictionary.", +try { + registerProcessor( + "descriptors-not-dict-worklet-processor", + DescriptorsNotDictWorkletProcessor + ); +} catch (e) { + console.log(e); +} + +// defaultValue value should be in range [minValue, maxValue]. defaultValue < minValue is not allowed +// "NotSupportedError: In parameterDescriptors, test defaultValue is out of the range defined by minValue and maxValue.", +try { + registerProcessor( + "descriptors-out-of-range-min-worklet-processor", + DescriptorsOutOfRangeMinWorkletProcessor + ); +} catch (e) { + console.log(e); +} + +// defaultValue value should be in range [minValue, maxValue]. defaultValue > maxValue is not allowed +// "NotSupportedError: In parameterDescriptors, test defaultValue is out of the range defined by minValue and maxValue.", +try { + registerProcessor( + "descriptors-out-of-range-max-worklet-processor", + DescriptorsOutOfRangeMaxWorkletProcessor + ); +} catch (e) { + console.log(e); +} + +// We should have minValue < maxValue to define a valid range +// "NotSupportedError: In parameterDescriptors, test minValue should be smaller than maxValue.", +try { + registerProcessor( + "descriptors-bad-range-max-worklet-processor", + DescriptorsBadRangeMaxWorkletProcessor + ); +} catch (e) { + console.log(e); +} |