2015-05-03 22:32:37 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
2012-05-21 15:12:37 +04:00
|
|
|
/* 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/. */
|
2010-05-18 16:28:37 +04:00
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
#include "InProcessBrowserChildMessageManager.h"
|
2010-05-18 16:28:37 +04:00
|
|
|
#include "nsContentUtils.h"
|
2019-01-02 16:27:05 +03:00
|
|
|
#include "nsDocShell.h"
|
2010-05-18 16:28:37 +04:00
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
|
|
#include "nsComponentManagerUtils.h"
|
|
|
|
#include "nsFrameLoader.h"
|
2019-04-12 01:15:07 +03:00
|
|
|
#include "nsFrameLoaderOwner.h"
|
|
|
|
#include "nsQueryObject.h"
|
2011-01-15 01:03:21 +03:00
|
|
|
#include "xpcpublic.h"
|
2012-05-08 20:20:35 +04:00
|
|
|
#include "nsIMozBrowserFrame.h"
|
2014-03-18 08:48:21 +04:00
|
|
|
#include "mozilla/EventDispatcher.h"
|
2017-07-19 15:59:02 +03:00
|
|
|
#include "mozilla/dom/ChromeMessageSender.h"
|
|
|
|
#include "mozilla/dom/MessageManagerBinding.h"
|
2015-03-24 23:05:39 +03:00
|
|
|
#include "mozilla/dom/SameProcessMessageQueue.h"
|
2017-05-08 09:24:22 +03:00
|
|
|
#include "mozilla/dom/ScriptLoader.h"
|
2019-01-02 16:26:56 +03:00
|
|
|
#include "mozilla/dom/WindowProxyHolder.h"
|
2020-04-30 19:42:53 +03:00
|
|
|
#include "mozilla/dom/JSActorService.h"
|
2012-08-02 10:02:29 +04:00
|
|
|
|
2014-03-18 08:48:19 +04:00
|
|
|
using namespace mozilla;
|
2015-05-13 08:36:00 +03:00
|
|
|
using namespace mozilla::dom;
|
2015-09-10 23:50:58 +03:00
|
|
|
using namespace mozilla::dom::ipc;
|
2010-05-18 16:28:37 +04:00
|
|
|
|
2019-10-07 22:35:06 +03:00
|
|
|
/* static */
|
|
|
|
already_AddRefed<InProcessBrowserChildMessageManager>
|
|
|
|
InProcessBrowserChildMessageManager::Create(nsDocShell* aShell,
|
|
|
|
nsIContent* aOwner,
|
|
|
|
nsFrameMessageManager* aChrome) {
|
|
|
|
RefPtr<InProcessBrowserChildMessageManager> mm =
|
|
|
|
new InProcessBrowserChildMessageManager(aShell, aOwner, aChrome);
|
|
|
|
|
|
|
|
NS_ENSURE_TRUE(mm->Init(), nullptr);
|
|
|
|
|
|
|
|
if (XRE_IsParentProcess()) {
|
2020-04-30 19:42:53 +03:00
|
|
|
RefPtr<JSActorService> wasvc = JSActorService::GetSingleton();
|
2019-10-07 22:35:06 +03:00
|
|
|
wasvc->RegisterChromeEventTarget(mm);
|
|
|
|
}
|
|
|
|
|
|
|
|
return mm.forget();
|
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
bool InProcessBrowserChildMessageManager::DoSendBlockingMessage(
|
2020-04-21 17:07:57 +03:00
|
|
|
const nsAString& aMessage, StructuredCloneData& aData,
|
|
|
|
nsTArray<StructuredCloneData>* aRetVal) {
|
2015-03-24 23:05:39 +03:00
|
|
|
SameProcessMessageQueue* queue = SameProcessMessageQueue::Get();
|
|
|
|
queue->Flush();
|
|
|
|
|
2012-09-28 09:43:12 +04:00
|
|
|
if (mChromeMessageManager) {
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<nsFrameMessageManager> mm = mChromeMessageManager;
|
2018-03-22 05:43:17 +03:00
|
|
|
RefPtr<nsFrameLoader> fl = GetFrameLoader();
|
2020-04-21 17:07:57 +03:00
|
|
|
mm->ReceiveMessage(mOwner, fl, aMessage, true, &aData, aRetVal,
|
2020-04-21 01:15:19 +03:00
|
|
|
IgnoreErrors());
|
2010-05-18 16:28:37 +04:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-03-12 18:22:00 +04:00
|
|
|
class nsAsyncMessageToParent : public nsSameProcessAsyncMessageBase,
|
2015-03-24 23:05:39 +03:00
|
|
|
public SameProcessMessageQueue::Runnable {
|
2010-05-18 16:28:37 +04:00
|
|
|
public:
|
2020-04-21 17:07:57 +03:00
|
|
|
explicit nsAsyncMessageToParent(
|
|
|
|
InProcessBrowserChildMessageManager* aBrowserChild)
|
|
|
|
: nsSameProcessAsyncMessageBase(), mBrowserChild(aBrowserChild) {}
|
2013-07-11 02:05:39 +04:00
|
|
|
|
2015-03-24 23:05:39 +03:00
|
|
|
virtual nsresult HandleMessage() override {
|
2019-04-10 01:39:01 +03:00
|
|
|
RefPtr<nsFrameLoader> fl = mBrowserChild->GetFrameLoader();
|
|
|
|
ReceiveMessage(mBrowserChild->mOwner, fl,
|
|
|
|
mBrowserChild->mChromeMessageManager);
|
2010-05-18 16:28:37 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2019-04-10 01:39:01 +03:00
|
|
|
RefPtr<InProcessBrowserChildMessageManager> mBrowserChild;
|
2010-05-18 16:28:37 +04:00
|
|
|
};
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
nsresult InProcessBrowserChildMessageManager::DoSendAsyncMessage(
|
2020-04-21 17:07:57 +03:00
|
|
|
const nsAString& aMessage, StructuredCloneData& aData) {
|
2015-03-24 23:05:39 +03:00
|
|
|
SameProcessMessageQueue* queue = SameProcessMessageQueue::Get();
|
2020-04-21 17:07:57 +03:00
|
|
|
RefPtr<nsAsyncMessageToParent> ev = new nsAsyncMessageToParent(this);
|
2015-10-07 13:42:43 +03:00
|
|
|
|
2020-04-21 01:15:19 +03:00
|
|
|
nsresult rv = ev->Init(aMessage, aData);
|
2015-10-07 13:42:43 +03:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2015-03-24 23:05:39 +03:00
|
|
|
queue->Push(ev);
|
2015-10-07 13:42:43 +03:00
|
|
|
return NS_OK;
|
2010-05-18 16:28:37 +04:00
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
InProcessBrowserChildMessageManager::InProcessBrowserChildMessageManager(
|
2019-01-02 16:27:05 +03:00
|
|
|
nsDocShell* aShell, nsIContent* aOwner, nsFrameMessageManager* aChrome)
|
2018-04-17 14:59:44 +03:00
|
|
|
: ContentFrameMessageManager(new nsFrameMessageManager(this)),
|
|
|
|
mDocShell(aShell),
|
|
|
|
mLoadingScript(false),
|
2015-02-27 08:35:26 +03:00
|
|
|
mPreventEventsEscaping(false),
|
2014-04-19 03:00:06 +04:00
|
|
|
mOwner(aOwner),
|
|
|
|
mChromeMessageManager(aChrome) {
|
2014-06-13 21:56:38 +04:00
|
|
|
mozilla::HoldJSObjects(this);
|
2012-05-08 20:20:35 +04:00
|
|
|
|
2016-10-15 04:46:26 +03:00
|
|
|
// If owner corresponds to an <iframe mozbrowser>, we'll have to tweak our
|
2016-10-21 05:11:07 +03:00
|
|
|
// GetEventTargetParent implementation.
|
2012-05-08 20:20:35 +04:00
|
|
|
nsCOMPtr<nsIMozBrowserFrame> browserFrame = do_QueryInterface(mOwner);
|
|
|
|
if (browserFrame) {
|
2016-10-15 04:46:26 +03:00
|
|
|
mIsBrowserFrame = browserFrame->GetReallyIsBrowser();
|
Bug 802366 - The main event: Let a browser process inherit its app's id. r=bz,cjones
The main bug fixed here is that in half of our interfaces, we use "is browser frame/element" to mean "browser or app", and in the other half, we use it to mean "is browser not app".
There's a related, functional bug also fixed here, which is that a browser process doesn't inherit its parent's app-id. This causes problems e.g. for IndexedDB: If a browser inside an app uses IndexedDB, the DB should have the app's app-id.
I also modified Tab{Parent,Child} and nsFrameLoader to call "app" "ownOrContainingApp", to emphasize that we might have inherited the app from a parent process. I left nsIDocShell::appId alone, because changing that would have necessitated changing nsILoadGroup and therefore a /lot/ of users in Necko; it's also not clear it would have clarified anything in those cases.
2012-11-10 22:32:37 +04:00
|
|
|
} else {
|
2016-10-15 04:46:26 +03:00
|
|
|
mIsBrowserFrame = false;
|
2012-05-08 20:20:35 +04:00
|
|
|
}
|
2010-05-18 16:28:37 +04:00
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
InProcessBrowserChildMessageManager::~InProcessBrowserChildMessageManager() {
|
2019-10-07 22:35:06 +03:00
|
|
|
if (XRE_IsParentProcess()) {
|
2020-04-30 19:42:53 +03:00
|
|
|
JSActorService::UnregisterChromeEventTarget(this);
|
2019-10-07 22:35:06 +03:00
|
|
|
}
|
|
|
|
|
2014-06-13 21:56:38 +04:00
|
|
|
mAnonymousGlobalScopes.Clear();
|
|
|
|
mozilla::DropJSObjects(this);
|
2010-05-18 16:28:37 +04:00
|
|
|
}
|
|
|
|
|
2012-08-09 12:33:38 +04:00
|
|
|
// This method isn't automatically forwarded safely because it's notxpcom, so
|
|
|
|
// the IDL binding doesn't know what value to return.
|
2019-04-10 01:39:01 +03:00
|
|
|
void InProcessBrowserChildMessageManager::MarkForCC() {
|
2015-02-25 01:23:53 +03:00
|
|
|
MarkScopesForCC();
|
2018-02-16 17:28:31 +03:00
|
|
|
MessageManagerGlobal::MarkForCC();
|
2012-08-09 12:33:38 +04:00
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(InProcessBrowserChildMessageManager)
|
2014-06-13 21:56:38 +04:00
|
|
|
|
2018-08-11 00:08:07 +03:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(
|
2019-04-10 01:39:01 +03:00
|
|
|
InProcessBrowserChildMessageManager, DOMEventTargetHelper)
|
2014-06-13 21:56:38 +04:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMessageManager)
|
2017-10-02 17:58:42 +03:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocShell)
|
2014-06-13 21:56:38 +04:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(
|
|
|
|
InProcessBrowserChildMessageManager, DOMEventTargetHelper)
|
2016-02-10 01:08:53 +03:00
|
|
|
tmp->nsMessageManagerScriptExecutor::Trace(aCallbacks, aClosure);
|
2014-06-13 21:56:38 +04:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_END
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(
|
|
|
|
InProcessBrowserChildMessageManager, DOMEventTargetHelper)
|
2020-05-27 01:19:31 +03:00
|
|
|
if (XRE_IsParentProcess()) {
|
|
|
|
JSActorService::UnregisterChromeEventTarget(tmp);
|
|
|
|
}
|
|
|
|
|
2014-06-13 21:56:38 +04:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mMessageManager)
|
2017-10-02 17:58:42 +03:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocShell)
|
2017-05-15 23:05:18 +03:00
|
|
|
tmp->nsMessageManagerScriptExecutor::Unlink();
|
2020-02-25 22:44:39 +03:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_REFERENCE
|
2014-06-13 21:56:38 +04:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
2010-05-18 16:28:37 +04:00
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(InProcessBrowserChildMessageManager)
|
2012-08-27 18:13:02 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIMessageSender)
|
2010-05-18 16:28:37 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIInProcessContentFrameMessageManager)
|
2018-08-18 02:14:43 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(ContentFrameMessageManager)
|
2013-04-04 13:27:40 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
2014-04-01 10:13:50 +04:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
|
2010-05-18 16:28:37 +04:00
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
NS_IMPL_ADDREF_INHERITED(InProcessBrowserChildMessageManager,
|
|
|
|
DOMEventTargetHelper)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(InProcessBrowserChildMessageManager,
|
|
|
|
DOMEventTargetHelper)
|
2010-05-18 16:28:37 +04:00
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
JSObject* InProcessBrowserChildMessageManager::WrapObject(
|
2018-08-11 00:03:18 +03:00
|
|
|
JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
|
|
|
|
return ContentFrameMessageManager_Binding::Wrap(aCx, this, aGivenProto);
|
2017-07-19 15:59:02 +03:00
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
void InProcessBrowserChildMessageManager::CacheFrameLoader(
|
2018-08-11 00:08:07 +03:00
|
|
|
nsFrameLoader* aFrameLoader) {
|
2015-04-16 18:17:54 +03:00
|
|
|
mFrameLoader = aFrameLoader;
|
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
Nullable<WindowProxyHolder> InProcessBrowserChildMessageManager::GetContent(
|
2019-01-02 16:26:56 +03:00
|
|
|
ErrorResult& aError) {
|
2019-01-02 16:27:05 +03:00
|
|
|
if (!mDocShell) {
|
2019-01-02 16:26:56 +03:00
|
|
|
return nullptr;
|
|
|
|
}
|
2019-01-02 16:27:05 +03:00
|
|
|
return WindowProxyHolder(mDocShell->GetBrowsingContext());
|
2017-07-19 15:59:02 +03:00
|
|
|
}
|
2018-03-01 12:51:09 +03:00
|
|
|
|
2017-07-19 15:59:02 +03:00
|
|
|
already_AddRefed<nsIEventTarget>
|
2019-04-10 01:39:01 +03:00
|
|
|
InProcessBrowserChildMessageManager::GetTabEventTarget() {
|
2017-07-19 15:59:02 +03:00
|
|
|
nsCOMPtr<nsIEventTarget> target = GetMainThreadEventTarget();
|
|
|
|
return target.forget();
|
2010-05-18 16:28:37 +04:00
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
uint64_t InProcessBrowserChildMessageManager::ChromeOuterWindowID() {
|
2018-07-11 05:31:55 +03:00
|
|
|
if (!mDocShell) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> root;
|
2019-08-07 22:24:00 +03:00
|
|
|
nsresult rv = mDocShell->GetInProcessRootTreeItem(getter_AddRefs(root));
|
2018-07-11 05:31:55 +03:00
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsPIDOMWindowOuter* topWin = root->GetWindow();
|
|
|
|
if (!topWin) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return topWin->WindowID();
|
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
void InProcessBrowserChildMessageManager::FireUnloadEvent() {
|
2019-01-02 16:05:23 +03:00
|
|
|
// We're called from Document::MaybeInitializeFinalizeFrameLoaders, so it
|
2015-02-27 08:35:26 +03:00
|
|
|
// should be safe to run script.
|
|
|
|
MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
|
|
|
|
|
|
|
|
// Don't let the unload event propagate to chrome event handlers.
|
|
|
|
mPreventEventsEscaping = true;
|
2020-07-01 11:29:29 +03:00
|
|
|
DOMEventTargetHelper::DispatchTrustedEvent(u"unload"_ns);
|
2015-02-27 08:35:26 +03:00
|
|
|
|
|
|
|
// Allow events fired during docshell destruction (pagehide, unload) to
|
|
|
|
// propagate to the <browser> element since chrome code depends on this.
|
|
|
|
mPreventEventsEscaping = false;
|
2010-08-12 20:47:22 +04:00
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
void InProcessBrowserChildMessageManager::DisconnectEventListeners() {
|
2014-01-10 06:03:47 +04:00
|
|
|
if (mDocShell) {
|
2016-01-30 20:05:36 +03:00
|
|
|
if (nsCOMPtr<nsPIDOMWindowOuter> win = mDocShell->GetWindow()) {
|
2014-01-10 06:03:47 +04:00
|
|
|
win->SetChromeEventHandler(win->GetChromeEventHandler());
|
|
|
|
}
|
2010-06-16 15:42:42 +04:00
|
|
|
}
|
2015-02-27 08:35:26 +03:00
|
|
|
if (mListenerManager) {
|
|
|
|
mListenerManager->Disconnect();
|
|
|
|
}
|
|
|
|
|
2012-07-30 18:20:58 +04:00
|
|
|
mDocShell = nullptr;
|
2015-02-27 08:35:26 +03:00
|
|
|
}
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
void InProcessBrowserChildMessageManager::Disconnect() {
|
2012-07-30 18:20:58 +04:00
|
|
|
mChromeMessageManager = nullptr;
|
2015-02-27 08:35:26 +03:00
|
|
|
mOwner = nullptr;
|
2010-05-18 16:28:37 +04:00
|
|
|
if (mMessageManager) {
|
|
|
|
static_cast<nsFrameMessageManager*>(mMessageManager.get())->Disconnect();
|
2012-07-30 18:20:58 +04:00
|
|
|
mMessageManager = nullptr;
|
2010-05-18 16:28:37 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP_(nsIContent*)
|
2019-04-10 01:39:01 +03:00
|
|
|
InProcessBrowserChildMessageManager::GetOwnerContent() { return mOwner; }
|
2010-05-18 16:28:37 +04:00
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
void InProcessBrowserChildMessageManager::GetEventTargetParent(
|
2018-08-11 00:08:07 +03:00
|
|
|
EventChainPreVisitor& aVisitor) {
|
2015-04-03 02:15:00 +03:00
|
|
|
aVisitor.mForceContentDispatch = true;
|
2011-10-17 18:59:28 +04:00
|
|
|
aVisitor.mCanHandle = true;
|
2012-05-08 20:20:35 +04:00
|
|
|
|
2015-02-27 08:35:26 +03:00
|
|
|
if (mPreventEventsEscaping) {
|
2017-12-18 19:07:36 +03:00
|
|
|
aVisitor.SetParentTarget(nullptr, false);
|
2018-04-05 20:42:41 +03:00
|
|
|
return;
|
2015-02-27 08:35:26 +03:00
|
|
|
}
|
|
|
|
|
2016-10-15 04:46:26 +03:00
|
|
|
if (mIsBrowserFrame &&
|
2015-02-27 08:35:26 +03:00
|
|
|
(!mOwner || !nsContentUtils::IsInChromeDocshell(mOwner->OwnerDoc()))) {
|
|
|
|
if (mOwner) {
|
2016-01-30 20:05:36 +03:00
|
|
|
if (nsPIDOMWindowInner* innerWindow =
|
|
|
|
mOwner->OwnerDoc()->GetInnerWindow()) {
|
2017-12-18 19:07:36 +03:00
|
|
|
// '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);
|
2015-02-27 08:35:26 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2017-12-18 19:07:36 +03:00
|
|
|
aVisitor.SetParentTarget(mOwner, false);
|
2015-02-27 08:35:26 +03:00
|
|
|
}
|
2010-05-18 16:28:37 +04:00
|
|
|
}
|
|
|
|
|
2016-04-26 03:23:21 +03:00
|
|
|
class nsAsyncScriptLoad : public Runnable {
|
2011-05-19 18:48:17 +04:00
|
|
|
public:
|
2019-04-10 01:39:01 +03:00
|
|
|
nsAsyncScriptLoad(InProcessBrowserChildMessageManager* aBrowserChild,
|
2017-06-12 22:34:10 +03:00
|
|
|
const nsAString& aURL, bool aRunInGlobalScope)
|
|
|
|
: mozilla::Runnable("nsAsyncScriptLoad"),
|
2019-04-10 01:39:01 +03:00
|
|
|
mBrowserChild(aBrowserChild),
|
2017-06-12 22:34:10 +03:00
|
|
|
mURL(aURL),
|
|
|
|
mRunInGlobalScope(aRunInGlobalScope) {}
|
2011-05-19 18:48:17 +04:00
|
|
|
|
2016-08-08 05:18:10 +03:00
|
|
|
NS_IMETHOD Run() override {
|
2019-04-10 01:39:01 +03:00
|
|
|
mBrowserChild->LoadFrameScript(mURL, mRunInGlobalScope);
|
2011-05-19 18:48:17 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2019-04-10 01:39:01 +03:00
|
|
|
RefPtr<InProcessBrowserChildMessageManager> mBrowserChild;
|
2011-05-19 18:48:17 +04:00
|
|
|
nsString mURL;
|
2013-11-24 09:32:45 +04:00
|
|
|
bool mRunInGlobalScope;
|
2011-05-19 18:48:17 +04:00
|
|
|
};
|
|
|
|
|
2019-04-10 01:39:01 +03:00
|
|
|
void InProcessBrowserChildMessageManager::LoadFrameScript(
|
|
|
|
const nsAString& aURL, bool aRunInGlobalScope) {
|
2011-05-19 18:48:17 +04:00
|
|
|
if (!nsContentUtils::IsSafeToRunScript()) {
|
2013-11-24 09:32:45 +04:00
|
|
|
nsContentUtils::AddScriptRunner(
|
|
|
|
new nsAsyncScriptLoad(this, aURL, aRunInGlobalScope));
|
2011-05-19 18:48:17 +04:00
|
|
|
return;
|
|
|
|
}
|
2011-09-29 10:19:26 +04:00
|
|
|
bool tmp = mLoadingScript;
|
2011-10-17 18:59:28 +04:00
|
|
|
mLoadingScript = true;
|
2018-08-11 00:03:18 +03:00
|
|
|
JS::Rooted<JSObject*> mm(mozilla::dom::RootingCx(), GetOrCreateWrapper());
|
|
|
|
LoadScriptInternal(mm, aURL, !aRunInGlobalScope);
|
2010-08-10 21:18:26 +04:00
|
|
|
mLoadingScript = tmp;
|
2010-05-18 16:28:37 +04:00
|
|
|
}
|
2015-04-16 18:17:54 +03:00
|
|
|
|
2018-03-22 05:43:17 +03:00
|
|
|
already_AddRefed<nsFrameLoader>
|
2019-04-10 01:39:01 +03:00
|
|
|
InProcessBrowserChildMessageManager::GetFrameLoader() {
|
2019-02-16 01:20:53 +03:00
|
|
|
RefPtr<nsFrameLoaderOwner> owner = do_QueryObject(mOwner);
|
2018-03-22 05:43:17 +03:00
|
|
|
RefPtr<nsFrameLoader> fl = owner ? owner->GetFrameLoader() : nullptr;
|
2015-04-16 18:17:54 +03:00
|
|
|
if (!fl) {
|
|
|
|
fl = mFrameLoader;
|
|
|
|
}
|
|
|
|
return fl.forget();
|
|
|
|
}
|