Bug 1362119 - part 1 - Moving dom/base/Script{Loader,Element}.* in dom/script, r=ehsan
This patch does these things: 1. it moves nsScriptElement, nsScriptLoader, ScriptSettings, nsIScriptElement and nsIScriptLoaderObserver in dom/script 2. it renames nsScriptElement to mozilla::dom::ScriptElement 3. it renames nsScriptLaoder to mozilla::dom::ScriptLoader
This commit is contained in:
Andrea Marchesini
845
dom/script/ScriptSettings.cpp
Normal file
845
dom/script/ScriptSettings.cpp
Normal file
@@ -0,0 +1,845 @@
|
||||
/* -*- 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 "mozilla/dom/ScriptSettings.h"
|
||||
#include "mozilla/ThreadLocal.h"
|
||||
#include "mozilla/Assertions.h"
|
||||
#include "mozilla/CycleCollectedJSContext.h"
|
||||
|
||||
#include "jsapi.h"
|
||||
#include "xpcpublic.h"
|
||||
#include "nsIGlobalObject.h"
|
||||
#include "nsIDocShell.h"
|
||||
#include "nsIScriptGlobalObject.h"
|
||||
#include "nsIScriptContext.h"
|
||||
#include "nsContentUtils.h"
|
||||
#include "nsGlobalWindow.h"
|
||||
#include "nsPIDOMWindow.h"
|
||||
#include "nsTArray.h"
|
||||
#include "nsJSUtils.h"
|
||||
#include "nsDOMJSUtils.h"
|
||||
#include "WorkerPrivate.h"
|
||||
|
||||
namespace mozilla {
|
||||
namespace dom {
|
||||
|
||||
static MOZ_THREAD_LOCAL(ScriptSettingsStackEntry*) sScriptSettingsTLS;
|
||||
static bool sScriptSettingsTLSInitialized;
|
||||
|
||||
class ScriptSettingsStack {
|
||||
public:
|
||||
static ScriptSettingsStackEntry* Top() {
|
||||
return sScriptSettingsTLS.get();
|
||||
}
|
||||
|
||||
static void Push(ScriptSettingsStackEntry *aEntry) {
|
||||
MOZ_ASSERT(!aEntry->mOlder);
|
||||
// Whenever JSAPI use is disabled, the next stack entry pushed must
|
||||
// not be an AutoIncumbentScript.
|
||||
MOZ_ASSERT_IF(!Top() || Top()->NoJSAPI(),
|
||||
!aEntry->IsIncumbentScript());
|
||||
// Whenever the top entry is not an incumbent canidate, the next stack entry
|
||||
// pushed must not be an AutoIncumbentScript.
|
||||
MOZ_ASSERT_IF(Top() && !Top()->IsIncumbentCandidate(),
|
||||
!aEntry->IsIncumbentScript());
|
||||
|
||||
aEntry->mOlder = Top();
|
||||
sScriptSettingsTLS.set(aEntry);
|
||||
}
|
||||
|
||||
static void Pop(ScriptSettingsStackEntry *aEntry) {
|
||||
MOZ_ASSERT(aEntry == Top());
|
||||
sScriptSettingsTLS.set(aEntry->mOlder);
|
||||
}
|
||||
|
||||
static nsIGlobalObject* IncumbentGlobal() {
|
||||
ScriptSettingsStackEntry *entry = Top();
|
||||
while (entry) {
|
||||
if (entry->IsIncumbentCandidate()) {
|
||||
return entry->mGlobalObject;
|
||||
}
|
||||
entry = entry->mOlder;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static ScriptSettingsStackEntry* EntryPoint() {
|
||||
ScriptSettingsStackEntry *entry = Top();
|
||||
while (entry) {
|
||||
if (entry->IsEntryCandidate()) {
|
||||
return entry;
|
||||
}
|
||||
entry = entry->mOlder;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static nsIGlobalObject* EntryGlobal() {
|
||||
ScriptSettingsStackEntry *entry = EntryPoint();
|
||||
if (!entry) {
|
||||
return nullptr;
|
||||
}
|
||||
return entry->mGlobalObject;
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
static ScriptSettingsStackEntry* TopNonIncumbentScript() {
|
||||
ScriptSettingsStackEntry *entry = Top();
|
||||
while (entry) {
|
||||
if (!entry->IsIncumbentScript()) {
|
||||
return entry;
|
||||
}
|
||||
entry = entry->mOlder;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
#endif // DEBUG
|
||||
|
||||
};
|
||||
|
||||
static unsigned long gRunToCompletionListeners = 0;
|
||||
|
||||
void
|
||||
UseEntryScriptProfiling()
|
||||
{
|
||||
MOZ_ASSERT(NS_IsMainThread());
|
||||
++gRunToCompletionListeners;
|
||||
}
|
||||
|
||||
void
|
||||
UnuseEntryScriptProfiling()
|
||||
{
|
||||
MOZ_ASSERT(NS_IsMainThread());
|
||||
MOZ_ASSERT(gRunToCompletionListeners > 0);
|
||||
--gRunToCompletionListeners;
|
||||
}
|
||||
|
||||
void
|
||||
InitScriptSettings()
|
||||
{
|
||||
bool success = sScriptSettingsTLS.init();
|
||||
if (!success) {
|
||||
MOZ_CRASH();
|
||||
}
|
||||
|
||||
sScriptSettingsTLS.set(nullptr);
|
||||
sScriptSettingsTLSInitialized = true;
|
||||
}
|
||||
|
||||
void
|
||||
DestroyScriptSettings()
|
||||
{
|
||||
MOZ_ASSERT(sScriptSettingsTLS.get() == nullptr);
|
||||
}
|
||||
|
||||
bool
|
||||
ScriptSettingsInitialized()
|
||||
{
|
||||
return sScriptSettingsTLSInitialized;
|
||||
}
|
||||
|
||||
ScriptSettingsStackEntry::ScriptSettingsStackEntry(nsIGlobalObject *aGlobal,
|
||||
Type aType)
|
||||
: mGlobalObject(aGlobal)
|
||||
, mType(aType)
|
||||
, mOlder(nullptr)
|
||||
{
|
||||
MOZ_ASSERT_IF(IsIncumbentCandidate() && !NoJSAPI(), mGlobalObject);
|
||||
MOZ_ASSERT(!mGlobalObject || mGlobalObject->GetGlobalJSObject(),
|
||||
"Must have an actual JS global for the duration on the stack");
|
||||
MOZ_ASSERT(!mGlobalObject ||
|
||||
JS_IsGlobalObject(mGlobalObject->GetGlobalJSObject()),
|
||||
"No outer windows allowed");
|
||||
}
|
||||
|
||||
ScriptSettingsStackEntry::~ScriptSettingsStackEntry()
|
||||
{
|
||||
// We must have an actual JS global for the entire time this is on the stack.
|
||||
MOZ_ASSERT_IF(mGlobalObject, mGlobalObject->GetGlobalJSObject());
|
||||
}
|
||||
|
||||
// If the entry or incumbent global ends up being something that the subject
|
||||
// principal doesn't subsume, we don't want to use it. This never happens on
|
||||
// the web, but can happen with asymmetric privilege relationships (i.e.
|
||||
// ExpandedPrincipal and System Principal).
|
||||
//
|
||||
// The most correct thing to use instead would be the topmost global on the
|
||||
// callstack whose principal is subsumed by the subject principal. But that's
|
||||
// hard to compute, so we just substitute the global of the current
|
||||
// compartment. In practice, this is fine.
|
||||
//
|
||||
// Note that in particular things like:
|
||||
//
|
||||
// |SpecialPowers.wrap(crossOriginWindow).eval(open())|
|
||||
//
|
||||
// trigger this case. Although both the entry global and the current global
|
||||
// have normal principals, the use of Gecko-specific System-Principaled JS
|
||||
// puts the code from two different origins on the callstack at once, which
|
||||
// doesn't happen normally on the web.
|
||||
static nsIGlobalObject*
|
||||
ClampToSubject(nsIGlobalObject* aGlobalOrNull)
|
||||
{
|
||||
if (!aGlobalOrNull || !NS_IsMainThread()) {
|
||||
return aGlobalOrNull;
|
||||
}
|
||||
|
||||
nsIPrincipal* globalPrin = aGlobalOrNull->PrincipalOrNull();
|
||||
NS_ENSURE_TRUE(globalPrin, GetCurrentGlobal());
|
||||
if (!nsContentUtils::SubjectPrincipalOrSystemIfNativeCaller()->SubsumesConsideringDomain(globalPrin)) {
|
||||
return GetCurrentGlobal();
|
||||
}
|
||||
|
||||
return aGlobalOrNull;
|
||||
}
|
||||
|
||||
nsIGlobalObject*
|
||||
GetEntryGlobal()
|
||||
{
|
||||
return ClampToSubject(ScriptSettingsStack::EntryGlobal());
|
||||
}
|
||||
|
||||
nsIDocument*
|
||||
GetEntryDocument()
|
||||
{
|
||||
nsIGlobalObject* global = GetEntryGlobal();
|
||||
nsCOMPtr<nsPIDOMWindowInner> entryWin = do_QueryInterface(global);
|
||||
|
||||
// If our entry global isn't a window, see if it's an addon scope associated
|
||||
// with a window. If it is, the caller almost certainly wants that rather
|
||||
// than null.
|
||||
if (!entryWin && global) {
|
||||
if (auto* win = xpc::AddonWindowOrNull(global->GetGlobalJSObject())) {
|
||||
entryWin = win->AsInner();
|
||||
}
|
||||
}
|
||||
|
||||
return entryWin ? entryWin->GetExtantDoc() : nullptr;
|
||||
}
|
||||
|
||||
nsIGlobalObject*
|
||||
GetIncumbentGlobal()
|
||||
{
|
||||
// We need the current JSContext in order to check the JS for
|
||||
// scripted frames that may have appeared since anyone last
|
||||
// manipulated the stack. If it's null, that means that there
|
||||
// must be no entry global on the stack, and therefore no incumbent
|
||||
// global either.
|
||||
JSContext *cx = nsContentUtils::GetCurrentJSContextForThread();
|
||||
if (!cx) {
|
||||
MOZ_ASSERT(ScriptSettingsStack::EntryGlobal() == nullptr);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// See what the JS engine has to say. If we've got a scripted caller
|
||||
// override in place, the JS engine will lie to us and pretend that
|
||||
// there's nothing on the JS stack, which will cause us to check the
|
||||
// incumbent script stack below.
|
||||
if (JSObject *global = JS::GetScriptedCallerGlobal(cx)) {
|
||||
return ClampToSubject(xpc::NativeGlobal(global));
|
||||
}
|
||||
|
||||
// Ok, nothing from the JS engine. Let's use whatever's on the
|
||||
// explicit stack.
|
||||
return ClampToSubject(ScriptSettingsStack::IncumbentGlobal());
|
||||
}
|
||||
|
||||
nsIGlobalObject*
|
||||
GetCurrentGlobal()
|
||||
{
|
||||
JSContext *cx = nsContentUtils::GetCurrentJSContextForThread();
|
||||
if (!cx) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
JSObject *global = JS::CurrentGlobalOrNull(cx);
|
||||
if (!global) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return xpc::NativeGlobal(global);
|
||||
}
|
||||
|
||||
nsIPrincipal*
|
||||
GetWebIDLCallerPrincipal()
|
||||
{
|
||||
MOZ_ASSERT(NS_IsMainThread());
|
||||
ScriptSettingsStackEntry *entry = ScriptSettingsStack::EntryPoint();
|
||||
|
||||
// If we have an entry point that is not NoJSAPI, we know it must be an
|
||||
// AutoEntryScript.
|
||||
if (!entry || entry->NoJSAPI()) {
|
||||
return nullptr;
|
||||
}
|
||||
AutoEntryScript* aes = static_cast<AutoEntryScript*>(entry);
|
||||
|
||||
return aes->mWebIDLCallerPrincipal;
|
||||
}
|
||||
|
||||
bool
|
||||
IsJSAPIActive()
|
||||
{
|
||||
ScriptSettingsStackEntry* topEntry = ScriptSettingsStack::Top();
|
||||
return topEntry && !topEntry->NoJSAPI();
|
||||
}
|
||||
|
||||
namespace danger {
|
||||
JSContext*
|
||||
GetJSContext()
|
||||
{
|
||||
return CycleCollectedJSContext::Get()->Context();
|
||||
}
|
||||
} // namespace danger
|
||||
|
||||
JS::RootingContext*
|
||||
RootingCx()
|
||||
{
|
||||
return CycleCollectedJSContext::Get()->RootingCx();
|
||||
}
|
||||
|
||||
AutoJSAPI::AutoJSAPI()
|
||||
: ScriptSettingsStackEntry(nullptr, eJSAPI)
|
||||
, mCx(nullptr)
|
||||
, mIsMainThread(false) // For lack of anything better
|
||||
{
|
||||
}
|
||||
|
||||
AutoJSAPI::~AutoJSAPI()
|
||||
{
|
||||
if (!mCx) {
|
||||
// No need to do anything here: we never managed to Init, so can't have an
|
||||
// exception on our (nonexistent) JSContext. We also don't need to restore
|
||||
// any state on it. Finally, we never made it to pushing outselves onto the
|
||||
// ScriptSettingsStack, so shouldn't pop.
|
||||
MOZ_ASSERT(ScriptSettingsStack::Top() != this);
|
||||
return;
|
||||
}
|
||||
|
||||
ReportException();
|
||||
|
||||
if (mOldWarningReporter.isSome()) {
|
||||
JS::SetWarningReporter(cx(), mOldWarningReporter.value());
|
||||
}
|
||||
|
||||
// Leave the request before popping.
|
||||
if (mIsMainThread) {
|
||||
mAutoRequest.reset();
|
||||
}
|
||||
|
||||
ScriptSettingsStack::Pop(this);
|
||||
}
|
||||
|
||||
void
|
||||
WarningOnlyErrorReporter(JSContext* aCx, JSErrorReport* aRep);
|
||||
|
||||
void
|
||||
AutoJSAPI::InitInternal(nsIGlobalObject* aGlobalObject, JSObject* aGlobal,
|
||||
JSContext* aCx, bool aIsMainThread)
|
||||
{
|
||||
MOZ_ASSERT(aCx);
|
||||
MOZ_ASSERT(aCx == danger::GetJSContext());
|
||||
MOZ_ASSERT(aIsMainThread == NS_IsMainThread());
|
||||
MOZ_ASSERT(bool(aGlobalObject) == bool(aGlobal));
|
||||
MOZ_ASSERT_IF(aGlobalObject, aGlobalObject->GetGlobalJSObject() == aGlobal);
|
||||
#ifdef DEBUG
|
||||
bool haveException = JS_IsExceptionPending(aCx);
|
||||
#endif // DEBUG
|
||||
|
||||
mCx = aCx;
|
||||
mIsMainThread = aIsMainThread;
|
||||
mGlobalObject = aGlobalObject;
|
||||
if (aIsMainThread) {
|
||||
// We _could_ just unconditionally emplace mAutoRequest here. It's just not
|
||||
// needed on worker threads, and we're hoping to kill it on the main thread
|
||||
// too.
|
||||
mAutoRequest.emplace(mCx);
|
||||
}
|
||||
if (aGlobal) {
|
||||
JS::ExposeObjectToActiveJS(aGlobal);
|
||||
}
|
||||
mAutoNullableCompartment.emplace(mCx, aGlobal);
|
||||
|
||||
ScriptSettingsStack::Push(this);
|
||||
|
||||
mOldWarningReporter.emplace(JS::GetWarningReporter(aCx));
|
||||
|
||||
JS::SetWarningReporter(aCx, WarningOnlyErrorReporter);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (haveException) {
|
||||
JS::Rooted<JS::Value> exn(aCx);
|
||||
JS_GetPendingException(aCx, &exn);
|
||||
|
||||
JS_ClearPendingException(aCx);
|
||||
if (exn.isObject()) {
|
||||
JS::Rooted<JSObject*> exnObj(aCx, &exn.toObject());
|
||||
|
||||
// Make sure we can actually read things from it. This UncheckedUwrap is
|
||||
// safe because we're only getting data for a debug printf. In
|
||||
// particular, we do not expose this data to anyone, which is very
|
||||
// important; otherwise it could be a cross-origin information leak.
|
||||
exnObj = js::UncheckedUnwrap(exnObj);
|
||||
JSAutoCompartment ac(aCx, exnObj);
|
||||
|
||||
nsAutoJSString stack, filename, name, message;
|
||||
int32_t line;
|
||||
|
||||
JS::Rooted<JS::Value> tmp(aCx);
|
||||
if (!JS_GetProperty(aCx, exnObj, "filename", &tmp)) {
|
||||
JS_ClearPendingException(aCx);
|
||||
}
|
||||
if (tmp.isUndefined()) {
|
||||
if (!JS_GetProperty(aCx, exnObj, "fileName", &tmp)) {
|
||||
JS_ClearPendingException(aCx);
|
||||
}
|
||||
}
|
||||
|
||||
if (!filename.init(aCx, tmp)) {
|
||||
JS_ClearPendingException(aCx);
|
||||
}
|
||||
|
||||
if (!JS_GetProperty(aCx, exnObj, "stack", &tmp) ||
|
||||
!stack.init(aCx, tmp)) {
|
||||
JS_ClearPendingException(aCx);
|
||||
}
|
||||
|
||||
if (!JS_GetProperty(aCx, exnObj, "name", &tmp) ||
|
||||
!name.init(aCx, tmp)) {
|
||||
JS_ClearPendingException(aCx);
|
||||
}
|
||||
|
||||
if (!JS_GetProperty(aCx, exnObj, "message", &tmp) ||
|
||||
!message.init(aCx, tmp)) {
|
||||
JS_ClearPendingException(aCx);
|
||||
}
|
||||
|
||||
if (!JS_GetProperty(aCx, exnObj, "lineNumber", &tmp) ||
|
||||
!JS::ToInt32(aCx, tmp, &line)) {
|
||||
JS_ClearPendingException(aCx);
|
||||
line = 0;
|
||||
}
|
||||
|
||||
printf_stderr("PREEXISTING EXCEPTION OBJECT: '%s: %s'\n%s:%d\n%s\n",
|
||||
NS_ConvertUTF16toUTF8(name).get(),
|
||||
NS_ConvertUTF16toUTF8(message).get(),
|
||||
NS_ConvertUTF16toUTF8(filename).get(), line,
|
||||
NS_ConvertUTF16toUTF8(stack).get());
|
||||
} else {
|
||||
// It's a primitive... not much we can do other than stringify it.
|
||||
nsAutoJSString exnStr;
|
||||
if (!exnStr.init(aCx, exn)) {
|
||||
JS_ClearPendingException(aCx);
|
||||
}
|
||||
|
||||
printf_stderr("PREEXISTING EXCEPTION PRIMITIVE: %s\n",
|
||||
NS_ConvertUTF16toUTF8(exnStr).get());
|
||||
}
|
||||
MOZ_ASSERT(false, "We had an exception; we should not have");
|
||||
}
|
||||
#endif // DEBUG
|
||||
}
|
||||
|
||||
AutoJSAPI::AutoJSAPI(nsIGlobalObject* aGlobalObject,
|
||||
bool aIsMainThread,
|
||||
Type aType)
|
||||
: ScriptSettingsStackEntry(aGlobalObject, aType)
|
||||
, mIsMainThread(aIsMainThread)
|
||||
{
|
||||
MOZ_ASSERT(aGlobalObject);
|
||||
MOZ_ASSERT(aGlobalObject->GetGlobalJSObject(), "Must have a JS global");
|
||||
MOZ_ASSERT(aIsMainThread == NS_IsMainThread());
|
||||
|
||||
InitInternal(aGlobalObject, aGlobalObject->GetGlobalJSObject(),
|
||||
danger::GetJSContext(), aIsMainThread);
|
||||
}
|
||||
|
||||
void
|
||||
AutoJSAPI::Init()
|
||||
{
|
||||
MOZ_ASSERT(!mCx, "An AutoJSAPI should only be initialised once");
|
||||
|
||||
InitInternal(/* aGlobalObject */ nullptr, /* aGlobal */ nullptr,
|
||||
danger::GetJSContext(), NS_IsMainThread());
|
||||
}
|
||||
|
||||
bool
|
||||
AutoJSAPI::Init(nsIGlobalObject* aGlobalObject, JSContext* aCx)
|
||||
{
|
||||
MOZ_ASSERT(!mCx, "An AutoJSAPI should only be initialised once");
|
||||
MOZ_ASSERT(aCx);
|
||||
|
||||
if (NS_WARN_IF(!aGlobalObject)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
JSObject* global = aGlobalObject->GetGlobalJSObject();
|
||||
if (NS_WARN_IF(!global)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
InitInternal(aGlobalObject, global, aCx, NS_IsMainThread());
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
AutoJSAPI::Init(nsIGlobalObject* aGlobalObject)
|
||||
{
|
||||
return Init(aGlobalObject, danger::GetJSContext());
|
||||
}
|
||||
|
||||
bool
|
||||
AutoJSAPI::Init(JSObject* aObject)
|
||||
{
|
||||
return Init(xpc::NativeGlobal(aObject));
|
||||
}
|
||||
|
||||
bool
|
||||
AutoJSAPI::Init(nsPIDOMWindowInner* aWindow, JSContext* aCx)
|
||||
{
|
||||
return Init(nsGlobalWindow::Cast(aWindow), aCx);
|
||||
}
|
||||
|
||||
bool
|
||||
AutoJSAPI::Init(nsPIDOMWindowInner* aWindow)
|
||||
{
|
||||
return Init(nsGlobalWindow::Cast(aWindow));
|
||||
}
|
||||
|
||||
bool
|
||||
AutoJSAPI::Init(nsGlobalWindow* aWindow, JSContext* aCx)
|
||||
{
|
||||
return Init(static_cast<nsIGlobalObject*>(aWindow), aCx);
|
||||
}
|
||||
|
||||
bool
|
||||
AutoJSAPI::Init(nsGlobalWindow* aWindow)
|
||||
{
|
||||
return Init(static_cast<nsIGlobalObject*>(aWindow));
|
||||
}
|
||||
|
||||
// Even with autoJSAPIOwnsErrorReporting, the JS engine still sends warning
|
||||
// reports to the JSErrorReporter as soon as they are generated. These go
|
||||
// directly to the console, so we can handle them easily here.
|
||||
//
|
||||
// Eventually, SpiderMonkey will have a special-purpose callback for warnings
|
||||
// only.
|
||||
void
|
||||
WarningOnlyErrorReporter(JSContext* aCx, JSErrorReport* aRep)
|
||||
{
|
||||
MOZ_ASSERT(JSREPORT_IS_WARNING(aRep->flags));
|
||||
if (!NS_IsMainThread()) {
|
||||
// Reporting a warning on workers is a bit complicated because we have to
|
||||
// climb our parent chain until we get to the main thread. So go ahead and
|
||||
// just go through the worker ReportError codepath here.
|
||||
//
|
||||
// That said, it feels like we should be able to short-circuit things a bit
|
||||
// here by posting an appropriate runnable to the main thread directly...
|
||||
// Worth looking into sometime.
|
||||
workers::WorkerPrivate* worker = workers::GetWorkerPrivateFromContext(aCx);
|
||||
MOZ_ASSERT(worker);
|
||||
|
||||
worker->ReportError(aCx, JS::ConstUTF8CharsZ(), aRep);
|
||||
return;
|
||||
}
|
||||
|
||||
RefPtr<xpc::ErrorReport> xpcReport = new xpc::ErrorReport();
|
||||
nsGlobalWindow* win = xpc::CurrentWindowOrNull(aCx);
|
||||
if (!win) {
|
||||
// We run addons in a separate privileged compartment, but if we're in an
|
||||
// addon compartment we should log warnings to the console of the associated
|
||||
// DOM Window.
|
||||
win = xpc::AddonWindowOrNull(JS::CurrentGlobalOrNull(aCx));
|
||||
}
|
||||
xpcReport->Init(aRep, nullptr, nsContentUtils::IsSystemCaller(aCx),
|
||||
win ? win->AsInner()->WindowID() : 0);
|
||||
xpcReport->LogToConsole();
|
||||
}
|
||||
|
||||
void
|
||||
AutoJSAPI::ReportException()
|
||||
{
|
||||
if (!HasException()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// AutoJSAPI uses a JSAutoNullableCompartment, and may be in a null
|
||||
// compartment when the destructor is called. However, the JS engine
|
||||
// requires us to be in a compartment when we fetch the pending exception.
|
||||
// In this case, we enter the privileged junk scope and don't dispatch any
|
||||
// error events.
|
||||
JS::Rooted<JSObject*> errorGlobal(cx(), JS::CurrentGlobalOrNull(cx()));
|
||||
if (!errorGlobal) {
|
||||
if (mIsMainThread) {
|
||||
errorGlobal = xpc::PrivilegedJunkScope();
|
||||
} else {
|
||||
errorGlobal = workers::GetCurrentThreadWorkerGlobal();
|
||||
}
|
||||
}
|
||||
JSAutoCompartment ac(cx(), errorGlobal);
|
||||
JS::Rooted<JS::Value> exn(cx());
|
||||
js::ErrorReport jsReport(cx());
|
||||
if (StealException(&exn) &&
|
||||
jsReport.init(cx(), exn, js::ErrorReport::WithSideEffects)) {
|
||||
if (mIsMainThread) {
|
||||
RefPtr<xpc::ErrorReport> xpcReport = new xpc::ErrorReport();
|
||||
|
||||
RefPtr<nsGlobalWindow> win = xpc::WindowGlobalOrNull(errorGlobal);
|
||||
if (!win) {
|
||||
// We run addons in a separate privileged compartment, but they still
|
||||
// expect to trigger the onerror handler of their associated DOM Window.
|
||||
win = xpc::AddonWindowOrNull(errorGlobal);
|
||||
}
|
||||
nsPIDOMWindowInner* inner = win ? win->AsInner() : nullptr;
|
||||
bool isChrome = nsContentUtils::IsSystemPrincipal(
|
||||
nsContentUtils::ObjectPrincipal(errorGlobal));
|
||||
xpcReport->Init(jsReport.report(), jsReport.toStringResult().c_str(),
|
||||
isChrome,
|
||||
inner ? inner->WindowID() : 0);
|
||||
if (inner && jsReport.report()->errorNumber != JSMSG_OUT_OF_MEMORY) {
|
||||
JS::RootingContext* rcx = JS::RootingContext::get(cx());
|
||||
DispatchScriptErrorEvent(inner, rcx, xpcReport, exn);
|
||||
} else {
|
||||
JS::Rooted<JSObject*> stack(cx(),
|
||||
xpc::FindExceptionStackForConsoleReport(inner, exn));
|
||||
xpcReport->LogToConsoleWithStack(stack);
|
||||
}
|
||||
} else {
|
||||
// On a worker, we just use the worker error reporting mechanism and don't
|
||||
// bother with xpc::ErrorReport. This will ensure that all the right
|
||||
// events (which are a lot more complicated than in the window case) get
|
||||
// fired.
|
||||
workers::WorkerPrivate* worker = workers::GetCurrentThreadWorkerPrivate();
|
||||
MOZ_ASSERT(worker);
|
||||
MOZ_ASSERT(worker->GetJSContext() == cx());
|
||||
// Before invoking ReportError, put the exception back on the context,
|
||||
// because it may want to put it in its error events and has no other way
|
||||
// to get hold of it. After we invoke ReportError, clear the exception on
|
||||
// cx(), just in case ReportError didn't.
|
||||
JS_SetPendingException(cx(), exn);
|
||||
worker->ReportError(cx(), jsReport.toStringResult(), jsReport.report());
|
||||
ClearException();
|
||||
}
|
||||
} else {
|
||||
NS_WARNING("OOMed while acquiring uncaught exception from JSAPI");
|
||||
ClearException();
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
AutoJSAPI::PeekException(JS::MutableHandle<JS::Value> aVal)
|
||||
{
|
||||
MOZ_ASSERT_IF(mIsMainThread, IsStackTop());
|
||||
MOZ_ASSERT(HasException());
|
||||
MOZ_ASSERT(js::GetContextCompartment(cx()));
|
||||
if (!JS_GetPendingException(cx(), aVal)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
AutoJSAPI::StealException(JS::MutableHandle<JS::Value> aVal)
|
||||
{
|
||||
if (!PeekException(aVal)) {
|
||||
return false;
|
||||
}
|
||||
JS_ClearPendingException(cx());
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
bool
|
||||
AutoJSAPI::IsStackTop() const
|
||||
{
|
||||
return ScriptSettingsStack::TopNonIncumbentScript() == this;
|
||||
}
|
||||
#endif // DEBUG
|
||||
|
||||
AutoEntryScript::AutoEntryScript(nsIGlobalObject* aGlobalObject,
|
||||
const char *aReason,
|
||||
bool aIsMainThread)
|
||||
: AutoJSAPI(aGlobalObject, aIsMainThread, eEntryScript)
|
||||
, mWebIDLCallerPrincipal(nullptr)
|
||||
// This relies on us having a cx() because the AutoJSAPI constructor already
|
||||
// ran.
|
||||
, mCallerOverride(cx())
|
||||
{
|
||||
MOZ_ASSERT(aGlobalObject);
|
||||
|
||||
if (aIsMainThread && gRunToCompletionListeners > 0) {
|
||||
mDocShellEntryMonitor.emplace(cx(), aReason);
|
||||
}
|
||||
}
|
||||
|
||||
AutoEntryScript::AutoEntryScript(JSObject* aObject,
|
||||
const char *aReason,
|
||||
bool aIsMainThread)
|
||||
: AutoEntryScript(xpc::NativeGlobal(aObject), aReason, aIsMainThread)
|
||||
{
|
||||
}
|
||||
|
||||
AutoEntryScript::~AutoEntryScript()
|
||||
{
|
||||
// GC when we pop a script entry point. This is a useful heuristic that helps
|
||||
// us out on certain (flawed) benchmarks like sunspider, because it lets us
|
||||
// avoid GCing during the timing loop.
|
||||
JS_MaybeGC(cx());
|
||||
}
|
||||
|
||||
AutoEntryScript::DocshellEntryMonitor::DocshellEntryMonitor(JSContext* aCx,
|
||||
const char* aReason)
|
||||
: JS::dbg::AutoEntryMonitor(aCx)
|
||||
, mReason(aReason)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
AutoEntryScript::DocshellEntryMonitor::Entry(JSContext* aCx, JSFunction* aFunction,
|
||||
JSScript* aScript, JS::Handle<JS::Value> aAsyncStack,
|
||||
const char* aAsyncCause)
|
||||
{
|
||||
JS::Rooted<JSFunction*> rootedFunction(aCx);
|
||||
if (aFunction) {
|
||||
rootedFunction = aFunction;
|
||||
}
|
||||
JS::Rooted<JSScript*> rootedScript(aCx);
|
||||
if (aScript) {
|
||||
rootedScript = aScript;
|
||||
}
|
||||
|
||||
nsCOMPtr<nsPIDOMWindowInner> window =
|
||||
do_QueryInterface(xpc::NativeGlobal(JS::CurrentGlobalOrNull(aCx)));
|
||||
if (!window || !window->GetDocShell() ||
|
||||
!window->GetDocShell()->GetRecordProfileTimelineMarkers()) {
|
||||
return;
|
||||
}
|
||||
|
||||
nsCOMPtr<nsIDocShell> docShellForJSRunToCompletion = window->GetDocShell();
|
||||
nsString filename;
|
||||
uint32_t lineNumber = 0;
|
||||
|
||||
js::AutoStableStringChars functionName(aCx);
|
||||
if (rootedFunction) {
|
||||
JS::Rooted<JSString*> displayId(aCx, JS_GetFunctionDisplayId(rootedFunction));
|
||||
if (displayId) {
|
||||
if (!functionName.initTwoByte(aCx, displayId)) {
|
||||
JS_ClearPendingException(aCx);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!rootedScript) {
|
||||
rootedScript = JS_GetFunctionScript(aCx, rootedFunction);
|
||||
}
|
||||
if (rootedScript) {
|
||||
filename = NS_ConvertUTF8toUTF16(JS_GetScriptFilename(rootedScript));
|
||||
lineNumber = JS_GetScriptBaseLineNumber(aCx, rootedScript);
|
||||
}
|
||||
|
||||
if (!filename.IsEmpty() || functionName.isTwoByte()) {
|
||||
const char16_t* functionNameChars = functionName.isTwoByte() ?
|
||||
functionName.twoByteChars() : nullptr;
|
||||
|
||||
docShellForJSRunToCompletion->NotifyJSRunToCompletionStart(mReason,
|
||||
functionNameChars,
|
||||
filename.BeginReading(),
|
||||
lineNumber, aAsyncStack,
|
||||
aAsyncCause);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
AutoEntryScript::DocshellEntryMonitor::Exit(JSContext* aCx)
|
||||
{
|
||||
nsCOMPtr<nsPIDOMWindowInner> window =
|
||||
do_QueryInterface(xpc::NativeGlobal(JS::CurrentGlobalOrNull(aCx)));
|
||||
// Not really worth checking GetRecordProfileTimelineMarkers here.
|
||||
if (window && window->GetDocShell()) {
|
||||
nsCOMPtr<nsIDocShell> docShellForJSRunToCompletion = window->GetDocShell();
|
||||
docShellForJSRunToCompletion->NotifyJSRunToCompletionStop();
|
||||
}
|
||||
}
|
||||
|
||||
AutoIncumbentScript::AutoIncumbentScript(nsIGlobalObject* aGlobalObject)
|
||||
: ScriptSettingsStackEntry(aGlobalObject, eIncumbentScript)
|
||||
, mCallerOverride(nsContentUtils::GetCurrentJSContextForThread())
|
||||
{
|
||||
ScriptSettingsStack::Push(this);
|
||||
}
|
||||
|
||||
AutoIncumbentScript::~AutoIncumbentScript()
|
||||
{
|
||||
ScriptSettingsStack::Pop(this);
|
||||
}
|
||||
|
||||
AutoNoJSAPI::AutoNoJSAPI()
|
||||
: ScriptSettingsStackEntry(nullptr, eNoJSAPI)
|
||||
{
|
||||
ScriptSettingsStack::Push(this);
|
||||
}
|
||||
|
||||
AutoNoJSAPI::~AutoNoJSAPI()
|
||||
{
|
||||
ScriptSettingsStack::Pop(this);
|
||||
}
|
||||
|
||||
} // namespace dom
|
||||
|
||||
AutoJSContext::AutoJSContext(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_IN_IMPL)
|
||||
: mCx(nullptr)
|
||||
{
|
||||
JS::AutoSuppressGCAnalysis nogc;
|
||||
MOZ_ASSERT(!mCx, "mCx should not be initialized!");
|
||||
MOZ_ASSERT(NS_IsMainThread());
|
||||
|
||||
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
|
||||
|
||||
if (dom::IsJSAPIActive()) {
|
||||
mCx = dom::danger::GetJSContext();
|
||||
} else {
|
||||
mJSAPI.Init();
|
||||
mCx = mJSAPI.cx();
|
||||
}
|
||||
}
|
||||
|
||||
AutoJSContext::operator JSContext*() const
|
||||
{
|
||||
return mCx;
|
||||
}
|
||||
|
||||
AutoSafeJSContext::AutoSafeJSContext(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_IN_IMPL)
|
||||
: AutoJSAPI()
|
||||
{
|
||||
MOZ_ASSERT(NS_IsMainThread());
|
||||
|
||||
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
|
||||
|
||||
DebugOnly<bool> ok = Init(xpc::UnprivilegedJunkScope());
|
||||
MOZ_ASSERT(ok,
|
||||
"This is quite odd. We should have crashed in the "
|
||||
"xpc::NativeGlobal() call if xpc::UnprivilegedJunkScope() "
|
||||
"returned null, and inited correctly otherwise!");
|
||||
}
|
||||
|
||||
AutoSlowOperation::AutoSlowOperation(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_IN_IMPL)
|
||||
: AutoJSAPI()
|
||||
{
|
||||
MOZ_ASSERT(NS_IsMainThread());
|
||||
|
||||
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
|
||||
|
||||
Init();
|
||||
}
|
||||
|
||||
void
|
||||
AutoSlowOperation::CheckForInterrupt()
|
||||
{
|
||||
// JS_CheckForInterrupt expects us to be in a compartment.
|
||||
JSAutoCompartment ac(cx(), xpc::UnprivilegedJunkScope());
|
||||
JS_CheckForInterrupt(cx());
|
||||
}
|
||||
|
||||
} // namespace mozilla
|
||||
Reference in New Issue
Block a user