summaryrefslogtreecommitdiffstats
path: root/js/loader/LoadedScript.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /js/loader/LoadedScript.h
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'js/loader/LoadedScript.h')
-rw-r--r--js/loader/LoadedScript.h384
1 files changed, 384 insertions, 0 deletions
diff --git a/js/loader/LoadedScript.h b/js/loader/LoadedScript.h
new file mode 100644
index 0000000000..ca6d1fc179
--- /dev/null
+++ b/js/loader/LoadedScript.h
@@ -0,0 +1,384 @@
+/* -*- 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 js_loader_LoadedScript_h
+#define js_loader_LoadedScript_h
+
+#include "js/AllocPolicy.h"
+#include "js/Transcoding.h"
+
+#include "mozilla/Maybe.h"
+#include "mozilla/MaybeOneOf.h"
+#include "mozilla/Utf8.h" // mozilla::Utf8Unit
+#include "mozilla/Variant.h"
+#include "mozilla/Vector.h"
+
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+
+#include "jsapi.h"
+#include "ScriptKind.h"
+#include "ScriptFetchOptions.h"
+
+class nsIURI;
+
+namespace JS::loader {
+
+class ScriptLoadRequest;
+
+using Utf8Unit = mozilla::Utf8Unit;
+
+void HostAddRefTopLevelScript(const JS::Value& aPrivate);
+void HostReleaseTopLevelScript(const JS::Value& aPrivate);
+
+class ClassicScript;
+class ModuleScript;
+class EventScript;
+class LoadContextBase;
+
+class LoadedScript : public nsISupports {
+ ScriptKind mKind;
+ const mozilla::dom::ReferrerPolicy mReferrerPolicy;
+ RefPtr<ScriptFetchOptions> mFetchOptions;
+ nsCOMPtr<nsIURI> mURI;
+ nsCOMPtr<nsIURI> mBaseURL;
+
+ protected:
+ LoadedScript(ScriptKind aKind, mozilla::dom::ReferrerPolicy aReferrerPolicy,
+ ScriptFetchOptions* aFetchOptions, nsIURI* aURI);
+
+ virtual ~LoadedScript();
+
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_CLASS(LoadedScript)
+
+ bool IsClassicScript() const { return mKind == ScriptKind::eClassic; }
+ bool IsModuleScript() const { return mKind == ScriptKind::eModule; }
+ bool IsEventScript() const { return mKind == ScriptKind::eEvent; }
+
+ inline ClassicScript* AsClassicScript();
+ inline ModuleScript* AsModuleScript();
+ inline EventScript* AsEventScript();
+
+ // Used to propagate Fetch Options to child modules
+ ScriptFetchOptions* GetFetchOptions() const { return mFetchOptions; }
+
+ mozilla::dom::ReferrerPolicy ReferrerPolicy() const {
+ return mReferrerPolicy;
+ }
+
+ nsIURI* GetURI() const { return mURI; }
+ void SetBaseURL(nsIURI* aBaseURL) {
+ MOZ_ASSERT(!mBaseURL);
+ mBaseURL = aBaseURL;
+ }
+ nsIURI* BaseURL() const { return mBaseURL; }
+
+ void AssociateWithScript(JSScript* aScript);
+
+ public:
+ // ===========================================================================
+ // Encoding of the content provided by the network, or refined by the JS
+ // engine.
+ template <typename... Ts>
+ using Variant = mozilla::Variant<Ts...>;
+
+ template <typename... Ts>
+ using VariantType = mozilla::VariantType<Ts...>;
+
+ // Type of data provided by the nsChannel.
+ enum class DataType : uint8_t { eUnknown, eTextSource, eBytecode };
+
+ // Use a vector backed by the JS allocator for script text so that contents
+ // can be transferred in constant time to the JS engine, not copied in linear
+ // time.
+ template <typename Unit>
+ using ScriptTextBuffer = mozilla::Vector<Unit, 0, js::MallocAllocPolicy>;
+
+ using MaybeSourceText =
+ mozilla::MaybeOneOf<JS::SourceText<char16_t>, JS::SourceText<Utf8Unit>>;
+
+ bool IsUnknownDataType() const { return mDataType == DataType::eUnknown; }
+ bool IsTextSource() const { return mDataType == DataType::eTextSource; }
+ bool IsSource() const { return IsTextSource(); }
+ bool IsBytecode() const { return mDataType == DataType::eBytecode; }
+
+ void SetUnknownDataType() {
+ mDataType = DataType::eUnknown;
+ mScriptData.reset();
+ }
+
+ void SetTextSource(LoadContextBase* maybeLoadContext) {
+ MOZ_ASSERT(IsUnknownDataType());
+ mDataType = DataType::eTextSource;
+ mScriptData.emplace(VariantType<ScriptTextBuffer<Utf8Unit>>());
+ }
+
+ void SetBytecode() {
+ MOZ_ASSERT(IsUnknownDataType());
+ mDataType = DataType::eBytecode;
+ }
+
+ bool IsUTF16Text() const {
+ return mScriptData->is<ScriptTextBuffer<char16_t>>();
+ }
+ bool IsUTF8Text() const {
+ return mScriptData->is<ScriptTextBuffer<Utf8Unit>>();
+ }
+
+ template <typename Unit>
+ const ScriptTextBuffer<Unit>& ScriptText() const {
+ MOZ_ASSERT(IsTextSource());
+ return mScriptData->as<ScriptTextBuffer<Unit>>();
+ }
+ template <typename Unit>
+ ScriptTextBuffer<Unit>& ScriptText() {
+ MOZ_ASSERT(IsTextSource());
+ return mScriptData->as<ScriptTextBuffer<Unit>>();
+ }
+
+ size_t ScriptTextLength() const {
+ MOZ_ASSERT(IsTextSource());
+ return IsUTF16Text() ? ScriptText<char16_t>().length()
+ : ScriptText<Utf8Unit>().length();
+ }
+
+ // Get source text. On success |aMaybeSource| will contain either UTF-8 or
+ // UTF-16 source; on failure it will remain in its initial state.
+ nsresult GetScriptSource(JSContext* aCx, MaybeSourceText* aMaybeSource,
+ LoadContextBase* aMaybeLoadContext);
+
+ void ClearScriptSource() {
+ if (IsTextSource()) {
+ ClearScriptText();
+ }
+ }
+
+ void ClearScriptText() {
+ MOZ_ASSERT(IsTextSource());
+ return IsUTF16Text() ? ScriptText<char16_t>().clearAndFree()
+ : ScriptText<Utf8Unit>().clearAndFree();
+ }
+
+ size_t ReceivedScriptTextLength() const { return mReceivedScriptTextLength; }
+
+ void SetReceivedScriptTextLength(size_t aLength) {
+ mReceivedScriptTextLength = aLength;
+ }
+
+ JS::TranscodeBuffer& SRIAndBytecode() {
+ // Note: SRIAndBytecode might be called even if the IsSource() returns true,
+ // as we want to be able to save the bytecode content when we are loading
+ // from source.
+ MOZ_ASSERT(IsBytecode() || IsSource());
+ return mScriptBytecode;
+ }
+ JS::TranscodeRange Bytecode() const {
+ MOZ_ASSERT(IsBytecode());
+ const auto& bytecode = mScriptBytecode;
+ auto offset = mBytecodeOffset;
+ return JS::TranscodeRange(bytecode.begin() + offset,
+ bytecode.length() - offset);
+ }
+
+ size_t GetSRILength() const {
+ MOZ_ASSERT(IsBytecode() || IsSource());
+ return mBytecodeOffset;
+ }
+ void SetSRILength(size_t sriLength) {
+ MOZ_ASSERT(IsBytecode() || IsSource());
+ mBytecodeOffset = JS::AlignTranscodingBytecodeOffset(sriLength);
+ }
+
+ void DropBytecode() {
+ MOZ_ASSERT(IsBytecode() || IsSource());
+ mScriptBytecode.clearAndFree();
+ }
+
+ // Determine whether the mScriptData or mScriptBytecode is used.
+ DataType mDataType;
+
+ // Holds script source data for non-inline scripts.
+ mozilla::Maybe<
+ Variant<ScriptTextBuffer<char16_t>, ScriptTextBuffer<Utf8Unit>>>
+ mScriptData;
+
+ // The length of script source text, set when reading completes. This is used
+ // since mScriptData is cleared when the source is passed to the JS engine.
+ size_t mReceivedScriptTextLength;
+
+ // Holds the SRI serialized hash and the script bytecode for non-inline
+ // scripts. The data is laid out according to ScriptBytecodeDataLayout
+ // or, if compression is enabled, ScriptBytecodeCompressedDataLayout.
+ JS::TranscodeBuffer mScriptBytecode;
+ uint32_t mBytecodeOffset; // Offset of the bytecode in mScriptBytecode
+};
+
+// Provide accessors for any classes `Derived` which is providing the
+// `getLoadedScript` function as interface. The accessors are meant to be
+// inherited by the `Derived` class.
+template <typename Derived>
+class LoadedScriptDelegate {
+ private:
+ // Use a static_cast<Derived> instead of declaring virtual functions. This is
+ // meant to avoid relying on virtual table, and improve inlining for non-final
+ // classes.
+ const LoadedScript* GetLoadedScript() const {
+ return static_cast<const Derived*>(this)->getLoadedScript();
+ }
+ LoadedScript* GetLoadedScript() {
+ return static_cast<Derived*>(this)->getLoadedScript();
+ }
+
+ public:
+ template <typename Unit>
+ using ScriptTextBuffer = LoadedScript::ScriptTextBuffer<Unit>;
+ using MaybeSourceText = LoadedScript::MaybeSourceText;
+
+ bool IsModuleScript() const { return GetLoadedScript()->IsModuleScript(); }
+ bool IsEventScript() const { return GetLoadedScript()->IsEventScript(); }
+
+ bool IsUnknownDataType() const {
+ return GetLoadedScript()->IsUnknownDataType();
+ }
+ bool IsTextSource() const { return GetLoadedScript()->IsTextSource(); }
+ bool IsSource() const { return GetLoadedScript()->IsSource(); }
+ bool IsBytecode() const { return GetLoadedScript()->IsBytecode(); }
+
+ void SetUnknownDataType() { GetLoadedScript()->SetUnknownDataType(); }
+
+ void SetTextSource(LoadContextBase* maybeLoadContext) {
+ GetLoadedScript()->SetTextSource(maybeLoadContext);
+ }
+
+ void SetBytecode() { GetLoadedScript()->SetBytecode(); }
+
+ bool IsUTF16Text() const { return GetLoadedScript()->IsUTF16Text(); }
+ bool IsUTF8Text() const { return GetLoadedScript()->IsUTF8Text(); }
+
+ template <typename Unit>
+ const ScriptTextBuffer<Unit>& ScriptText() const {
+ const LoadedScript* loader = GetLoadedScript();
+ return loader->ScriptText<Unit>();
+ }
+ template <typename Unit>
+ ScriptTextBuffer<Unit>& ScriptText() {
+ LoadedScript* loader = GetLoadedScript();
+ return loader->ScriptText<Unit>();
+ }
+
+ size_t ScriptTextLength() const {
+ return GetLoadedScript()->ScriptTextLength();
+ }
+
+ size_t ReceivedScriptTextLength() const {
+ return GetLoadedScript()->ReceivedScriptTextLength();
+ }
+
+ void SetReceivedScriptTextLength(size_t aLength) {
+ GetLoadedScript()->SetReceivedScriptTextLength(aLength);
+ }
+
+ // Get source text. On success |aMaybeSource| will contain either UTF-8 or
+ // UTF-16 source; on failure it will remain in its initial state.
+ nsresult GetScriptSource(JSContext* aCx, MaybeSourceText* aMaybeSource,
+ LoadContextBase* aLoadContext) {
+ return GetLoadedScript()->GetScriptSource(aCx, aMaybeSource, aLoadContext);
+ }
+
+ void ClearScriptSource() { GetLoadedScript()->ClearScriptSource(); }
+
+ void ClearScriptText() { GetLoadedScript()->ClearScriptText(); }
+
+ JS::TranscodeBuffer& SRIAndBytecode() {
+ return GetLoadedScript()->SRIAndBytecode();
+ }
+ JS::TranscodeRange Bytecode() const { return GetLoadedScript()->Bytecode(); }
+
+ size_t GetSRILength() const { return GetLoadedScript()->GetSRILength(); }
+ void SetSRILength(size_t sriLength) {
+ GetLoadedScript()->SetSRILength(sriLength);
+ }
+
+ void DropBytecode() { GetLoadedScript()->DropBytecode(); }
+};
+
+class ClassicScript final : public LoadedScript {
+ ~ClassicScript() = default;
+
+ private:
+ // Scripts can be created only by ScriptLoadRequest::NoCacheEntryFound.
+ ClassicScript(mozilla::dom::ReferrerPolicy aReferrerPolicy,
+ ScriptFetchOptions* aFetchOptions, nsIURI* aURI);
+
+ friend class ScriptLoadRequest;
+};
+
+class EventScript final : public LoadedScript {
+ ~EventScript() = default;
+
+ public:
+ EventScript(mozilla::dom::ReferrerPolicy aReferrerPolicy,
+ ScriptFetchOptions* aFetchOptions, nsIURI* aURI);
+};
+
+// A single module script. May be used to satisfy multiple load requests.
+
+class ModuleScript final : public LoadedScript {
+ JS::Heap<JSObject*> mModuleRecord;
+ JS::Heap<JS::Value> mParseError;
+ JS::Heap<JS::Value> mErrorToRethrow;
+ bool mDebuggerDataInitialized;
+
+ ~ModuleScript();
+
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(ModuleScript,
+ LoadedScript)
+
+ private:
+ // Scripts can be created only by ScriptLoadRequest::NoCacheEntryFound.
+ ModuleScript(mozilla::dom::ReferrerPolicy aReferrerPolicy,
+ ScriptFetchOptions* aFetchOptions, nsIURI* aURI);
+
+ friend class ScriptLoadRequest;
+
+ public:
+ void SetModuleRecord(JS::Handle<JSObject*> aModuleRecord);
+ void SetParseError(const JS::Value& aError);
+ void SetErrorToRethrow(const JS::Value& aError);
+ void SetDebuggerDataInitialized();
+
+ JSObject* ModuleRecord() const { return mModuleRecord; }
+
+ JS::Value ParseError() const { return mParseError; }
+ JS::Value ErrorToRethrow() const { return mErrorToRethrow; }
+ bool HasParseError() const { return !mParseError.isUndefined(); }
+ bool HasErrorToRethrow() const { return !mErrorToRethrow.isUndefined(); }
+ bool DebuggerDataInitialized() const { return mDebuggerDataInitialized; }
+
+ void Shutdown();
+
+ void UnlinkModuleRecord();
+
+ friend void CheckModuleScriptPrivate(LoadedScript*, const JS::Value&);
+};
+
+ClassicScript* LoadedScript::AsClassicScript() {
+ MOZ_ASSERT(!IsModuleScript());
+ return static_cast<ClassicScript*>(this);
+}
+
+ModuleScript* LoadedScript::AsModuleScript() {
+ MOZ_ASSERT(IsModuleScript());
+ return static_cast<ModuleScript*>(this);
+}
+
+} // namespace JS::loader
+
+#endif // js_loader_LoadedScript_h