summaryrefslogtreecommitdiffstats
path: root/dom/base/JSExecutionContext.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base/JSExecutionContext.cpp')
-rw-r--r--dom/base/JSExecutionContext.cpp304
1 files changed, 304 insertions, 0 deletions
diff --git a/dom/base/JSExecutionContext.cpp b/dom/base/JSExecutionContext.cpp
new file mode 100644
index 0000000000..af8eafb332
--- /dev/null
+++ b/dom/base/JSExecutionContext.cpp
@@ -0,0 +1,304 @@
+/* -*- 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/. */
+
+/**
+ * This is not a generated file. It contains common utility functions
+ * invoked from the JavaScript code generated from IDL interfaces.
+ * The goal of the utility functions is to cut down on the size of
+ * the generated code itself.
+ */
+
+#include "mozilla/dom/JSExecutionContext.h"
+
+#include <utility>
+#include "ErrorList.h"
+#include "MainThreadUtils.h"
+#include "js/CompilationAndEvaluation.h"
+#include "js/CompileOptions.h"
+#include "js/Conversions.h"
+#include "js/experimental/JSStencil.h"
+#include "js/HeapAPI.h"
+#include "js/OffThreadScriptCompilation.h"
+#include "js/ProfilingCategory.h"
+#include "js/Promise.h"
+#include "js/SourceText.h"
+#include "js/Transcoding.h"
+#include "js/Value.h"
+#include "js/Wrapper.h"
+#include "jsapi.h"
+#include "mozilla/CycleCollectedJSContext.h"
+#include "mozilla/Likely.h"
+#include "nsContentUtils.h"
+#include "nsTPromiseFlatString.h"
+#include "xpcpublic.h"
+
+#if !defined(DEBUG) && !defined(MOZ_ENABLE_JS_DUMP)
+# include "mozilla/StaticPrefs_browser.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+static nsresult EvaluationExceptionToNSResult(JSContext* aCx) {
+ if (JS_IsExceptionPending(aCx)) {
+ return NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW;
+ }
+ return NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE;
+}
+
+JSExecutionContext::JSExecutionContext(
+ JSContext* aCx, JS::Handle<JSObject*> aGlobal,
+ JS::CompileOptions& aCompileOptions,
+ JS::Handle<JS::Value> aDebuggerPrivateValue,
+ JS::Handle<JSScript*> aDebuggerIntroductionScript)
+ : mAutoProfilerLabel("JSExecutionContext",
+ /* dynamicStr */ nullptr,
+ JS::ProfilingCategoryPair::JS),
+ mCx(aCx),
+ mRealm(aCx, aGlobal),
+ mRetValue(aCx),
+ mScript(aCx),
+ mCompileOptions(aCompileOptions),
+ mDebuggerPrivateValue(aCx, aDebuggerPrivateValue),
+ mDebuggerIntroductionScript(aCx, aDebuggerIntroductionScript),
+ mRv(NS_OK),
+ mSkip(false),
+ mCoerceToString(false),
+ mEncodeBytecode(false)
+#ifdef DEBUG
+ ,
+ mWantsReturnValue(false),
+ mScriptUsed(false)
+#endif
+{
+ MOZ_ASSERT(aCx == nsContentUtils::GetCurrentJSContext());
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(CycleCollectedJSContext::Get() &&
+ CycleCollectedJSContext::Get()->MicroTaskLevel());
+ MOZ_ASSERT(mRetValue.isUndefined());
+
+ MOZ_ASSERT(JS_IsGlobalObject(aGlobal));
+ if (MOZ_UNLIKELY(!xpc::Scriptability::Get(aGlobal).Allowed())) {
+ mSkip = true;
+ mRv = NS_OK;
+ }
+}
+
+nsresult JSExecutionContext::JoinOffThread(
+ JS::OffThreadToken** aOffThreadToken) {
+ if (mSkip) {
+ return mRv;
+ }
+
+ MOZ_ASSERT(!mWantsReturnValue);
+
+ JS::Rooted<JS::InstantiationStorage> storage(mCx);
+ RefPtr<JS::Stencil> stencil =
+ JS::FinishOffThreadStencil(mCx, *aOffThreadToken, storage.address());
+ *aOffThreadToken = nullptr; // Mark the token as having been finished.
+ if (!stencil) {
+ mSkip = true;
+ mRv = EvaluationExceptionToNSResult(mCx);
+ return mRv;
+ }
+
+ return InstantiateStencil(std::move(stencil), storage.address());
+}
+
+template <typename Unit>
+nsresult JSExecutionContext::InternalCompile(JS::SourceText<Unit>& aSrcBuf) {
+ if (mSkip) {
+ return mRv;
+ }
+
+ MOZ_ASSERT(aSrcBuf.get());
+ MOZ_ASSERT(mRetValue.isUndefined());
+#ifdef DEBUG
+ mWantsReturnValue = !mCompileOptions.noScriptRval;
+#endif
+
+ RefPtr<JS::Stencil> stencil =
+ CompileGlobalScriptToStencil(mCx, mCompileOptions, aSrcBuf);
+ if (!stencil) {
+ mSkip = true;
+ mRv = EvaluationExceptionToNSResult(mCx);
+ return mRv;
+ }
+
+ return InstantiateStencil(std::move(stencil));
+}
+
+nsresult JSExecutionContext::Compile(JS::SourceText<char16_t>& aSrcBuf) {
+ return InternalCompile(aSrcBuf);
+}
+
+nsresult JSExecutionContext::Compile(JS::SourceText<Utf8Unit>& aSrcBuf) {
+ return InternalCompile(aSrcBuf);
+}
+
+nsresult JSExecutionContext::Compile(const nsAString& aScript) {
+ if (mSkip) {
+ return mRv;
+ }
+
+ const nsPromiseFlatString& flatScript = PromiseFlatString(aScript);
+ JS::SourceText<char16_t> srcBuf;
+ if (!srcBuf.init(mCx, flatScript.get(), flatScript.Length(),
+ JS::SourceOwnership::Borrowed)) {
+ mSkip = true;
+ mRv = EvaluationExceptionToNSResult(mCx);
+ return mRv;
+ }
+
+ return Compile(srcBuf);
+}
+
+nsresult JSExecutionContext::Decode(mozilla::Vector<uint8_t>& aBytecodeBuf,
+ size_t aBytecodeIndex) {
+ if (mSkip) {
+ return mRv;
+ }
+
+ JS::DecodeOptions decodeOptions(mCompileOptions);
+ decodeOptions.borrowBuffer = true;
+
+ JS::TranscodeRange range(aBytecodeBuf.begin() + aBytecodeIndex,
+ aBytecodeBuf.length() - aBytecodeIndex);
+
+ MOZ_ASSERT(!mWantsReturnValue);
+ RefPtr<JS::Stencil> stencil;
+ JS::TranscodeResult tr =
+ JS::DecodeStencil(mCx, decodeOptions, range, getter_AddRefs(stencil));
+ // These errors are external parameters which should be handled before the
+ // decoding phase, and which are the only reasons why you might want to
+ // fallback on decoding failures.
+ MOZ_ASSERT(tr != JS::TranscodeResult::Failure_BadBuildId);
+ if (tr != JS::TranscodeResult::Ok) {
+ mSkip = true;
+ mRv = NS_ERROR_DOM_JS_DECODING_ERROR;
+ return mRv;
+ }
+
+ return InstantiateStencil(std::move(stencil));
+}
+
+nsresult JSExecutionContext::InstantiateStencil(
+ RefPtr<JS::Stencil>&& aStencil, JS::InstantiationStorage* aStorage) {
+ JS::InstantiateOptions instantiateOptions(mCompileOptions);
+ JS::Rooted<JSScript*> script(
+ mCx, JS::InstantiateGlobalStencil(mCx, instantiateOptions, aStencil,
+ aStorage));
+ if (!script) {
+ mSkip = true;
+ mRv = EvaluationExceptionToNSResult(mCx);
+ return mRv;
+ }
+
+ if (mEncodeBytecode) {
+ if (!JS::StartIncrementalEncoding(mCx, std::move(aStencil))) {
+ mSkip = true;
+ mRv = EvaluationExceptionToNSResult(mCx);
+ return mRv;
+ }
+ }
+
+ MOZ_ASSERT(!mScript);
+ mScript.set(script);
+
+ if (instantiateOptions.deferDebugMetadata) {
+ if (!JS::UpdateDebugMetadata(mCx, mScript, instantiateOptions,
+ mDebuggerPrivateValue, nullptr,
+ mDebuggerIntroductionScript, nullptr)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ return NS_OK;
+}
+
+JSScript* JSExecutionContext::GetScript() {
+#ifdef DEBUG
+ MOZ_ASSERT(!mSkip);
+ MOZ_ASSERT(mScript);
+ mScriptUsed = true;
+#endif
+
+ return MaybeGetScript();
+}
+
+JSScript* JSExecutionContext::MaybeGetScript() { return mScript; }
+
+nsresult JSExecutionContext::ExecScript() {
+ if (mSkip) {
+ return mRv;
+ }
+
+ MOZ_ASSERT(mScript);
+
+ if (!JS_ExecuteScript(mCx, mScript)) {
+ mSkip = true;
+ mRv = EvaluationExceptionToNSResult(mCx);
+ return mRv;
+ }
+
+ return NS_OK;
+}
+
+static bool IsPromiseValue(JSContext* aCx, JS::Handle<JS::Value> aValue) {
+ if (!aValue.isObject()) {
+ return false;
+ }
+
+ // We only care about Promise here, so CheckedUnwrapStatic is fine.
+ JS::Rooted<JSObject*> obj(aCx, js::CheckedUnwrapStatic(&aValue.toObject()));
+ if (!obj) {
+ return false;
+ }
+
+ return JS::IsPromiseObject(obj);
+}
+
+nsresult JSExecutionContext::ExecScript(
+ JS::MutableHandle<JS::Value> aRetValue) {
+ if (mSkip) {
+ aRetValue.setUndefined();
+ return mRv;
+ }
+
+ MOZ_ASSERT(mScript);
+ MOZ_ASSERT(mWantsReturnValue);
+
+ if (!JS_ExecuteScript(mCx, mScript, aRetValue)) {
+ mSkip = true;
+ mRv = EvaluationExceptionToNSResult(mCx);
+ return mRv;
+ }
+
+#ifdef DEBUG
+ mWantsReturnValue = false;
+#endif
+ if (mCoerceToString && IsPromiseValue(mCx, aRetValue)) {
+ // We're a javascript: url and we should treat Promise return values as
+ // undefined.
+ //
+ // Once bug 1477821 is fixed this code might be able to go away, or will
+ // become enshrined in the spec, depending.
+ aRetValue.setUndefined();
+ }
+
+ if (mCoerceToString && !aRetValue.isUndefined()) {
+ JSString* str = JS::ToString(mCx, aRetValue);
+ if (!str) {
+ // ToString can be a function call, so an exception can be raised while
+ // executing the function.
+ mSkip = true;
+ return EvaluationExceptionToNSResult(mCx);
+ }
+ aRetValue.set(JS::StringValue(str));
+ }
+
+ return NS_OK;
+}