gecko-dev/dom/base/WindowDestroyedEvent.cpp
Boris Zbarsky e6c83d06e3 Bug 1548613. Get rid of FastGetGlobalJSObject. r=mccr8,jonco
Marking GetGlobalJSObject and GetGlobalJSObjectPreserveColor final and inline
on inner/outer windows allows compilers to de-virtualize and inline them, which
makes them just as fast as calling FastGetGlobalJSObject is now (in the case of
GetGlobalJSObjectPreserveColor; GetGlobalJSObject has to do the gray-unmarking,
which is a bit more work).

In WindowDestroyedEvent::Run we want to switch to GetGlobalJSObject(), because
we want to root the object and hence should unmark gray.

In nsGlobalWindowInner::RunTimeoutHandler we likewise want to unmark gray.  The
AutoEntryScript constructor likely did that already, but it's not that
expensive when it doesn't need to do any work.

Differential Revision: https://phabricator.services.mozilla.com/D29711

--HG--
extra : moz-landing-system : lando
2019-05-03 10:08:07 +00:00

141 lines
4.7 KiB
C++

/* -*- 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 "WindowDestroyedEvent.h"
#include "nsJSUtils.h"
#include "jsapi.h"
#include "js/Wrapper.h"
#include "nsIPrincipal.h"
#include "nsISupportsPrimitives.h"
#include "nsIAppStartup.h"
#include "nsCOMPtr.h"
#include "nsContentUtils.h"
#include "xpcpublic.h"
#include "mozilla/Components.h"
namespace mozilla {
struct BrowserCompartmentMatcher : public js::CompartmentFilter {
bool match(JS::Compartment* aC) const override {
return !xpc::MightBeWebContentCompartment(aC);
}
};
WindowDestroyedEvent::WindowDestroyedEvent(nsGlobalWindowInner* aWindow,
uint64_t aID, const char* aTopic)
: mozilla::Runnable("WindowDestroyedEvent"),
mID(aID),
mPhase(Phase::Destroying),
mTopic(aTopic),
mIsInnerWindow(true) {
mWindow = do_GetWeakReference(aWindow);
}
WindowDestroyedEvent::WindowDestroyedEvent(nsGlobalWindowOuter* aWindow,
uint64_t aID, const char* aTopic)
: mozilla::Runnable("WindowDestroyedEvent"),
mID(aID),
mPhase(Phase::Destroying),
mTopic(aTopic),
mIsInnerWindow(false) {
mWindow = do_GetWeakReference(aWindow);
}
NS_IMETHODIMP
WindowDestroyedEvent::Run() {
AUTO_PROFILER_LABEL("WindowDestroyedEvent::Run", OTHER);
nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();
if (!observerService) {
return NS_OK;
}
nsCOMPtr<nsISupportsPRUint64> wrapper =
do_CreateInstance(NS_SUPPORTS_PRUINT64_CONTRACTID);
if (wrapper) {
wrapper->SetData(mID);
observerService->NotifyObservers(wrapper, mTopic.get(), nullptr);
}
switch (mPhase) {
case Phase::Destroying: {
bool skipNukeCrossCompartment = false;
#ifndef DEBUG
nsCOMPtr<nsIAppStartup> appStartup = components::AppStartup::Service();
if (appStartup) {
appStartup->GetShuttingDown(&skipNukeCrossCompartment);
}
#endif
if (!skipNukeCrossCompartment) {
// The compartment nuking phase might be too expensive, so do that
// part off of idle dispatch.
// For the compartment nuking phase, we dispatch either an
// inner-window-nuked or an outer-window-nuked notification.
// This will allow tests to wait for compartment nuking to happen.
if (mTopic.EqualsLiteral("inner-window-destroyed")) {
mTopic.AssignLiteral("inner-window-nuked");
} else if (mTopic.EqualsLiteral("outer-window-destroyed")) {
mTopic.AssignLiteral("outer-window-nuked");
}
mPhase = Phase::Nuking;
nsCOMPtr<nsIRunnable> copy(this);
NS_DispatchToCurrentThreadQueue(copy.forget(), 1000,
EventQueuePriority::Idle);
}
} break;
case Phase::Nuking: {
nsCOMPtr<nsISupports> window = do_QueryReferent(mWindow);
if (window) {
nsGlobalWindowInner* currentInner;
if (mIsInnerWindow) {
currentInner = nsGlobalWindowInner::FromSupports(window);
} else {
nsGlobalWindowOuter* outer =
nsGlobalWindowOuter::FromSupports(window);
currentInner = outer->GetCurrentInnerWindowInternal();
}
NS_ENSURE_TRUE(currentInner, NS_OK);
AutoSafeJSContext cx;
JS::Rooted<JSObject*> obj(cx, currentInner->GetGlobalJSObject());
if (obj && !js::IsSystemRealm(js::GetNonCCWObjectRealm(obj))) {
JS::Realm* realm = js::GetNonCCWObjectRealm(obj);
xpc::NukeJSStackFrames(realm);
nsCOMPtr<nsIPrincipal> pc =
nsJSPrincipals::get(JS::GetRealmPrincipals(realm));
if (BasePrincipal::Cast(pc)->AddonPolicy()) {
// We want to nuke all references to the add-on realm.
xpc::NukeAllWrappersForRealm(cx, realm,
mIsInnerWindow
? js::DontNukeWindowReferences
: js::NukeWindowReferences);
} else {
// We only want to nuke wrappers for the chrome->content case
js::NukeCrossCompartmentWrappers(
cx, BrowserCompartmentMatcher(), realm,
mIsInnerWindow ? js::DontNukeWindowReferences
: js::NukeWindowReferences,
js::NukeIncomingReferences);
}
}
}
} break;
}
return NS_OK;
}
} // namespace mozilla