mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-22 17:55:50 +00:00
d2ed260822
Summary: Really sorry for the size of the patch. It's mostly automatic s/nsIDocument/Document/ but I had to fix up in a bunch of places manually to add the right namespacing and such. Overall it's not a very interesting patch I think. nsDocument.cpp turns into Document.cpp, nsIDocument.h into Document.h and nsIDocumentInlines.h into DocumentInlines.h. I also changed a bunch of nsCOMPtr usage to RefPtr, but not all of it. While fixing up some of the bits I also removed some unneeded OwnerDoc() null checks and such, but I didn't do anything riskier than that.
303 lines
10 KiB
C++
303 lines
10 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 "InProcessTabChildMessageManager.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsDocShell.h"
|
|
#include "nsIScriptSecurityManager.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsIComponentManager.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsComponentManagerUtils.h"
|
|
#include "nsFrameLoader.h"
|
|
#include "xpcpublic.h"
|
|
#include "nsIMozBrowserFrame.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/dom/ChromeMessageSender.h"
|
|
#include "mozilla/dom/MessageManagerBinding.h"
|
|
#include "mozilla/dom/SameProcessMessageQueue.h"
|
|
#include "mozilla/dom/ScriptLoader.h"
|
|
#include "mozilla/dom/WindowProxyHolder.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
using namespace mozilla::dom::ipc;
|
|
|
|
bool InProcessTabChildMessageManager::DoSendBlockingMessage(
|
|
JSContext* aCx, const nsAString& aMessage, StructuredCloneData& aData,
|
|
JS::Handle<JSObject*> aCpows, nsIPrincipal* aPrincipal,
|
|
nsTArray<StructuredCloneData>* aRetVal, bool aIsSync) {
|
|
SameProcessMessageQueue* queue = SameProcessMessageQueue::Get();
|
|
queue->Flush();
|
|
|
|
if (mChromeMessageManager) {
|
|
SameProcessCpowHolder cpows(JS::RootingContext::get(aCx), aCpows);
|
|
RefPtr<nsFrameMessageManager> mm = mChromeMessageManager;
|
|
RefPtr<nsFrameLoader> fl = GetFrameLoader();
|
|
mm->ReceiveMessage(mOwner, fl, aMessage, true, &aData, &cpows, aPrincipal,
|
|
aRetVal, IgnoreErrors());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
class nsAsyncMessageToParent : public nsSameProcessAsyncMessageBase,
|
|
public SameProcessMessageQueue::Runnable {
|
|
public:
|
|
nsAsyncMessageToParent(JS::RootingContext* aRootingCx,
|
|
JS::Handle<JSObject*> aCpows,
|
|
InProcessTabChildMessageManager* aTabChild)
|
|
: nsSameProcessAsyncMessageBase(aRootingCx, aCpows),
|
|
mTabChild(aTabChild) {}
|
|
|
|
virtual nsresult HandleMessage() override {
|
|
RefPtr<nsFrameLoader> fl = mTabChild->GetFrameLoader();
|
|
ReceiveMessage(mTabChild->mOwner, fl, mTabChild->mChromeMessageManager);
|
|
return NS_OK;
|
|
}
|
|
RefPtr<InProcessTabChildMessageManager> mTabChild;
|
|
};
|
|
|
|
nsresult InProcessTabChildMessageManager::DoSendAsyncMessage(
|
|
JSContext* aCx, const nsAString& aMessage, StructuredCloneData& aData,
|
|
JS::Handle<JSObject*> aCpows, nsIPrincipal* aPrincipal) {
|
|
SameProcessMessageQueue* queue = SameProcessMessageQueue::Get();
|
|
JS::RootingContext* rcx = JS::RootingContext::get(aCx);
|
|
RefPtr<nsAsyncMessageToParent> ev =
|
|
new nsAsyncMessageToParent(rcx, aCpows, this);
|
|
|
|
nsresult rv = ev->Init(aMessage, aData, aPrincipal);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
queue->Push(ev);
|
|
return NS_OK;
|
|
}
|
|
|
|
InProcessTabChildMessageManager::InProcessTabChildMessageManager(
|
|
nsDocShell* aShell, nsIContent* aOwner, nsFrameMessageManager* aChrome)
|
|
: ContentFrameMessageManager(new nsFrameMessageManager(this)),
|
|
mDocShell(aShell),
|
|
mLoadingScript(false),
|
|
mPreventEventsEscaping(false),
|
|
mOwner(aOwner),
|
|
mChromeMessageManager(aChrome) {
|
|
mozilla::HoldJSObjects(this);
|
|
|
|
// If owner corresponds to an <iframe mozbrowser>, we'll have to tweak our
|
|
// GetEventTargetParent implementation.
|
|
nsCOMPtr<nsIMozBrowserFrame> browserFrame = do_QueryInterface(mOwner);
|
|
if (browserFrame) {
|
|
mIsBrowserFrame = browserFrame->GetReallyIsBrowser();
|
|
} else {
|
|
mIsBrowserFrame = false;
|
|
}
|
|
}
|
|
|
|
InProcessTabChildMessageManager::~InProcessTabChildMessageManager() {
|
|
mAnonymousGlobalScopes.Clear();
|
|
mozilla::DropJSObjects(this);
|
|
}
|
|
|
|
// This method isn't automatically forwarded safely because it's notxpcom, so
|
|
// the IDL binding doesn't know what value to return.
|
|
void InProcessTabChildMessageManager::MarkForCC() {
|
|
MarkScopesForCC();
|
|
MessageManagerGlobal::MarkForCC();
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(InProcessTabChildMessageManager)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(
|
|
InProcessTabChildMessageManager, DOMEventTargetHelper)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMessageManager)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocShell)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(InProcessTabChildMessageManager,
|
|
DOMEventTargetHelper)
|
|
tmp->nsMessageManagerScriptExecutor::Trace(aCallbacks, aClosure);
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(InProcessTabChildMessageManager,
|
|
DOMEventTargetHelper)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mMessageManager)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocShell)
|
|
tmp->nsMessageManagerScriptExecutor::Unlink();
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(InProcessTabChildMessageManager)
|
|
NS_INTERFACE_MAP_ENTRY(nsIMessageSender)
|
|
NS_INTERFACE_MAP_ENTRY(nsIInProcessContentFrameMessageManager)
|
|
NS_INTERFACE_MAP_ENTRY(ContentFrameMessageManager)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
|
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(InProcessTabChildMessageManager, DOMEventTargetHelper)
|
|
NS_IMPL_RELEASE_INHERITED(InProcessTabChildMessageManager, DOMEventTargetHelper)
|
|
|
|
JSObject* InProcessTabChildMessageManager::WrapObject(
|
|
JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
|
|
return ContentFrameMessageManager_Binding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
void InProcessTabChildMessageManager::CacheFrameLoader(
|
|
nsFrameLoader* aFrameLoader) {
|
|
mFrameLoader = aFrameLoader;
|
|
}
|
|
|
|
Nullable<WindowProxyHolder> InProcessTabChildMessageManager::GetContent(
|
|
ErrorResult& aError) {
|
|
if (!mDocShell) {
|
|
return nullptr;
|
|
}
|
|
return WindowProxyHolder(mDocShell->GetBrowsingContext());
|
|
}
|
|
|
|
already_AddRefed<nsIEventTarget>
|
|
InProcessTabChildMessageManager::GetTabEventTarget() {
|
|
nsCOMPtr<nsIEventTarget> target = GetMainThreadEventTarget();
|
|
return target.forget();
|
|
}
|
|
|
|
uint64_t InProcessTabChildMessageManager::ChromeOuterWindowID() {
|
|
if (!mDocShell) {
|
|
return 0;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> root;
|
|
nsresult rv = mDocShell->GetRootTreeItem(getter_AddRefs(root));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return 0;
|
|
}
|
|
|
|
nsPIDOMWindowOuter* topWin = root->GetWindow();
|
|
if (!topWin) {
|
|
return 0;
|
|
}
|
|
|
|
return topWin->WindowID();
|
|
}
|
|
|
|
void InProcessTabChildMessageManager::FireUnloadEvent() {
|
|
// We're called from Document::MaybeInitializeFinalizeFrameLoaders, so it
|
|
// should be safe to run script.
|
|
MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
|
|
|
|
// Don't let the unload event propagate to chrome event handlers.
|
|
mPreventEventsEscaping = true;
|
|
DOMEventTargetHelper::DispatchTrustedEvent(NS_LITERAL_STRING("unload"));
|
|
|
|
// Allow events fired during docshell destruction (pagehide, unload) to
|
|
// propagate to the <browser> element since chrome code depends on this.
|
|
mPreventEventsEscaping = false;
|
|
}
|
|
|
|
void InProcessTabChildMessageManager::DisconnectEventListeners() {
|
|
if (mDocShell) {
|
|
if (nsCOMPtr<nsPIDOMWindowOuter> win = mDocShell->GetWindow()) {
|
|
win->SetChromeEventHandler(win->GetChromeEventHandler());
|
|
}
|
|
}
|
|
if (mListenerManager) {
|
|
mListenerManager->Disconnect();
|
|
}
|
|
|
|
mDocShell = nullptr;
|
|
}
|
|
|
|
void InProcessTabChildMessageManager::Disconnect() {
|
|
mChromeMessageManager = nullptr;
|
|
mOwner = nullptr;
|
|
if (mMessageManager) {
|
|
static_cast<nsFrameMessageManager*>(mMessageManager.get())->Disconnect();
|
|
mMessageManager = nullptr;
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP_(nsIContent*)
|
|
InProcessTabChildMessageManager::GetOwnerContent() { return mOwner; }
|
|
|
|
void InProcessTabChildMessageManager::GetEventTargetParent(
|
|
EventChainPreVisitor& aVisitor) {
|
|
aVisitor.mForceContentDispatch = true;
|
|
aVisitor.mCanHandle = true;
|
|
|
|
#ifdef DEBUG
|
|
if (mOwner) {
|
|
nsCOMPtr<nsIFrameLoaderOwner> owner = do_QueryInterface(mOwner);
|
|
RefPtr<nsFrameLoader> fl = owner->GetFrameLoader();
|
|
if (fl) {
|
|
NS_ASSERTION(this == fl->GetTabChildMessageManager(),
|
|
"Wrong event target!");
|
|
NS_ASSERTION(fl->mMessageManager == mChromeMessageManager,
|
|
"Wrong message manager!");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (mPreventEventsEscaping) {
|
|
aVisitor.SetParentTarget(nullptr, false);
|
|
return;
|
|
}
|
|
|
|
if (mIsBrowserFrame &&
|
|
(!mOwner || !nsContentUtils::IsInChromeDocshell(mOwner->OwnerDoc()))) {
|
|
if (mOwner) {
|
|
if (nsPIDOMWindowInner* innerWindow =
|
|
mOwner->OwnerDoc()->GetInnerWindow()) {
|
|
// 'this' is already a "chrome handler", so we consider window's
|
|
// parent target to be part of that same part of the event path.
|
|
aVisitor.SetParentTarget(innerWindow->GetParentTarget(), false);
|
|
}
|
|
}
|
|
} else {
|
|
aVisitor.SetParentTarget(mOwner, false);
|
|
}
|
|
}
|
|
|
|
class nsAsyncScriptLoad : public Runnable {
|
|
public:
|
|
nsAsyncScriptLoad(InProcessTabChildMessageManager* aTabChild,
|
|
const nsAString& aURL, bool aRunInGlobalScope)
|
|
: mozilla::Runnable("nsAsyncScriptLoad"),
|
|
mTabChild(aTabChild),
|
|
mURL(aURL),
|
|
mRunInGlobalScope(aRunInGlobalScope) {}
|
|
|
|
NS_IMETHOD Run() override {
|
|
mTabChild->LoadFrameScript(mURL, mRunInGlobalScope);
|
|
return NS_OK;
|
|
}
|
|
RefPtr<InProcessTabChildMessageManager> mTabChild;
|
|
nsString mURL;
|
|
bool mRunInGlobalScope;
|
|
};
|
|
|
|
void InProcessTabChildMessageManager::LoadFrameScript(const nsAString& aURL,
|
|
bool aRunInGlobalScope) {
|
|
if (!nsContentUtils::IsSafeToRunScript()) {
|
|
nsContentUtils::AddScriptRunner(
|
|
new nsAsyncScriptLoad(this, aURL, aRunInGlobalScope));
|
|
return;
|
|
}
|
|
bool tmp = mLoadingScript;
|
|
mLoadingScript = true;
|
|
JS::Rooted<JSObject*> mm(mozilla::dom::RootingCx(), GetOrCreateWrapper());
|
|
LoadScriptInternal(mm, aURL, !aRunInGlobalScope);
|
|
mLoadingScript = tmp;
|
|
}
|
|
|
|
already_AddRefed<nsFrameLoader>
|
|
InProcessTabChildMessageManager::GetFrameLoader() {
|
|
nsCOMPtr<nsIFrameLoaderOwner> owner = do_QueryInterface(mOwner);
|
|
RefPtr<nsFrameLoader> fl = owner ? owner->GetFrameLoader() : nullptr;
|
|
if (!fl) {
|
|
fl = mFrameLoader;
|
|
}
|
|
return fl.forget();
|
|
}
|