Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-17 07:15:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 888600 - Move ContentFrameMessageManager to WebIDL. Part 3: Add message manager concrete classes for WebIDL. r=bz.

Browse Source 
--HG--
extra : rebase_source : 8fb313cbfda3eeec985ba2060abdfe307963a553
This commit is contained in:
Peter Van der Beken 2017-06-14 16:44:17 +02:00
parent e0424a7bae
commit 0dc914a027
32 changed files with 470 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
dom/base/ChildProcessMessageManager.h Normal file
View File

@ -0,0 +1,36 @@
/* -*- 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/. */
#ifndef mozilla_dom_ChildProcessMessageManager_h
#define mozilla_dom_ChildProcessMessageManager_h
#include "mozilla/dom/SyncMessageSender.h"
namespace mozilla {
namespace dom {
class ChildProcessMessageManager final : public SyncMessageSender
{
public:
explicit ChildProcessMessageManager(ipc::MessageManagerCallback* aCallback)
: SyncMessageSender(aCallback,
MessageManagerFlags::MM_PROCESSMANAGER |
MessageManagerFlags::MM_OWNSCALLBACK)
{
mozilla::HoldJSObjects(this);
}
protected:
virtual ~ChildProcessMessageManager()
{
mozilla::DropJSObjects(this);
}
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_ChildProcessMessageManager_h

36
dom/base/ChromeMessageBroadcaster.cpp Normal file
View File

@ -0,0 +1,36 @@
/* -*- 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/ChromeMessageBroadcaster.h"
#include "mozilla/HoldDropJSObjects.h"
namespace mozilla {
namespace dom {
ChromeMessageBroadcaster::ChromeMessageBroadcaster(nsFrameMessageManager* aParentManager,
MessageManagerFlags aFlags)
: MessageListenerManager(nullptr, aParentManager,
aFlags |
MessageManagerFlags::MM_BROADCASTER |
MessageManagerFlags::MM_CHROME)
{
if (mIsProcessManager) {
mozilla::HoldJSObjects(this);
}
if (aParentManager) {
aParentManager->AddChildManager(this);
}
}
ChromeMessageBroadcaster::~ChromeMessageBroadcaster()
{
if (mIsProcessManager) {
mozilla::DropJSObjects(this);
}
}
} // namespace dom
} // namespace mozilla

38
dom/base/ChromeMessageBroadcaster.h Normal file
View File

@ -0,0 +1,38 @@
/* -*- 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/. */
#ifndef mozilla_dom_ChromeMessageBroadcaster_h
#define mozilla_dom_ChromeMessageBroadcaster_h
#include "mozilla/dom/MessageListenerManager.h"
namespace mozilla {
namespace dom {
class ChromeMessageBroadcaster final : public MessageListenerManager
{
public:
explicit ChromeMessageBroadcaster(MessageManagerFlags aFlags)
: ChromeMessageBroadcaster(nullptr, aFlags)
{
MOZ_ASSERT(!(aFlags & ~(MessageManagerFlags::MM_GLOBAL |
MessageManagerFlags::MM_PROCESSMANAGER |
MessageManagerFlags::MM_OWNSCALLBACK)));
}
explicit ChromeMessageBroadcaster(nsFrameMessageManager* aParentManager)
: ChromeMessageBroadcaster(aParentManager, MessageManagerFlags::MM_NONE)
{}
private:
ChromeMessageBroadcaster(nsFrameMessageManager* aParentManager,
MessageManagerFlags aFlags);
virtual ~ChromeMessageBroadcaster();
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_ChromeMessageBroadcaster_h

31
dom/base/ChromeMessageSender.cpp Normal file
View File

@ -0,0 +1,31 @@
/* -*- 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/ChromeMessageSender.h"
namespace mozilla {
namespace dom {
ChromeMessageSender::ChromeMessageSender(ipc::MessageManagerCallback* aCallback,
nsFrameMessageManager* aParentManager,
MessageManagerFlags aFlags)
: MessageSender(aCallback, aParentManager, aFlags | MessageManagerFlags::MM_CHROME)
{
MOZ_ASSERT(!(aFlags & ~(MessageManagerFlags::MM_GLOBAL |
MessageManagerFlags::MM_PROCESSMANAGER |
MessageManagerFlags::MM_OWNSCALLBACK)));
// This is a bit hackish. We attach to the parent, but only if we have a callback. We
// don't have a callback for the frame message manager, and for parent process message
// managers (except the parent in-process message manager). In those cases we wait until
// the child process is running (see MessageSender::InitWithCallback).
if (aParentManager && mCallback) {
aParentManager->AddChildManager(this);
}
}
} // namespace dom
} // namespace mozilla

26
dom/base/ChromeMessageSender.h Normal file
View File

@ -0,0 +1,26 @@
/* -*- 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/. */
#ifndef mozilla_dom_ChromeMessageSender_h
#define mozilla_dom_ChromeMessageSender_h
#include "mozilla/dom/MessageSender.h"
namespace mozilla {
namespace dom {
class ChromeMessageSender final : public MessageSender
{
public:
ChromeMessageSender(ipc::MessageManagerCallback* aCallback,
nsFrameMessageManager* aParentManager,
MessageManagerFlags aFlags=MessageManagerFlags::MM_NONE);
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_ChromeMessageSender_h

2
dom/base/DOMMatrix.cpp
View File

@ -12,8 +12,10 @@
#include "mozilla/dom/DOMPointBinding.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/ToJSValue.h"
#include "mozilla/RuleNodeCacheConditions.h"
#include "mozilla/ServoCSSParser.h"
#include "nsCSSParser.h"
#include "nsGlobalWindowInner.h"
#include "nsStyleTransformMatrix.h"
#include <math.h>

49
dom/base/MessageListenerManager.cpp Normal file
View File

@ -0,0 +1,49 @@
/* -*- 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/MessageListenerManager.h"
namespace mozilla {
namespace dom {
MessageListenerManager::MessageListenerManager(ipc::MessageManagerCallback* aCallback,
nsFrameMessageManager* aParentManager,
ipc::MessageManagerFlags aFlags)
: nsFrameMessageManager(aCallback, aFlags),
mParentManager(aParentManager)
{
}
MessageListenerManager::~MessageListenerManager()
{
}
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MessageListenerManager)
NS_INTERFACE_MAP_END_INHERITING(nsFrameMessageManager)
NS_IMPL_ADDREF_INHERITED(MessageListenerManager, nsFrameMessageManager)
NS_IMPL_RELEASE_INHERITED(MessageListenerManager, nsFrameMessageManager)
NS_IMPL_CYCLE_COLLECTION_CLASS(MessageListenerManager)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(MessageListenerManager,
nsFrameMessageManager)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParentManager)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(MessageListenerManager,
nsFrameMessageManager)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mParentManager)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
void
MessageListenerManager::ClearParentManager(bool aRemove)
{
if (aRemove && mParentManager) {
mParentManager->RemoveChildManager(this);
}
mParentManager = nullptr;
}
} // namespace dom
} // namespace mozilla

46
dom/base/MessageListenerManager.h Normal file
View File

@ -0,0 +1,46 @@
/* -*- 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/. */
#ifndef mozilla_dom_MessageListenerManager_h
#define mozilla_dom_MessageListenerManager_h
#include "nsCycleCollectionNoteChild.h"
#include "nsFrameMessageManager.h"
namespace mozilla {
namespace dom {
class MessageListenerManager : public nsFrameMessageManager
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(MessageListenerManager,
nsFrameMessageManager)
virtual nsFrameMessageManager* GetParentManager() override
{
return mParentManager;
}
/**
* If aRemove is true then RemoveChildManager(this) will be called on the parent manager
* first.
*/
virtual void ClearParentManager(bool aRemove) override;
protected:
MessageListenerManager(ipc::MessageManagerCallback* aCallback,
nsFrameMessageManager* aParentManager,
MessageManagerFlags aFlags);
virtual ~MessageListenerManager();
RefPtr<nsFrameMessageManager> mParentManager;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_MessageListenerManager_h

33
dom/base/MessageSender.cpp Normal file
View File

@ -0,0 +1,33 @@
/* -*- 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/MessageSender.h"
namespace mozilla {
namespace dom {
void
MessageSender::InitWithCallback(ipc::MessageManagerCallback* aCallback)
{
if (mCallback) {
// Initialization should only happen once.
return;
}
SetCallback(aCallback);
// First load parent scripts by adding this to parent manager.
if (mParentManager) {
mParentManager->AddChildManager(this);
}
for (uint32_t i = 0; i < mPendingScripts.Length(); ++i) {
LoadFrameScript(mPendingScripts[i], false, mPendingScriptsGlobalStates[i]);
}
}
} // namespace dom
} // namespace mozilla

31
dom/base/MessageSender.h Normal file
View File

@ -0,0 +1,31 @@
/* -*- 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/. */
#ifndef mozilla_dom_MessageSender_h
#define mozilla_dom_MessageSender_h
#include "mozilla/dom/MessageListenerManager.h"
namespace mozilla {
namespace dom {
class MessageSender : public MessageListenerManager
{
public:
void InitWithCallback(ipc::MessageManagerCallback* aCallback);
protected:
MessageSender(ipc::MessageManagerCallback* aCallback,
nsFrameMessageManager* aParentManager,
MessageManagerFlags aFlags)
: MessageListenerManager(aCallback, aParentManager, aFlags)
{}
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_MessageSender_h

27
dom/base/SyncMessageSender.h Normal file
View File

@ -0,0 +1,27 @@
/* -*- 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/. */
#ifndef mozilla_dom_SyncMessageSender_h
#define mozilla_dom_SyncMessageSender_h
#include "mozilla/dom/MessageSender.h"
namespace mozilla {
namespace dom {
class SyncMessageSender : public MessageSender
{
protected:
SyncMessageSender(ipc::MessageManagerCallback* aCallback,
MessageManagerFlags aFlags)
: MessageSender(aCallback, nullptr, aFlags)
{}
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_SyncMessageSender_h

1
dom/base/TextInputProcessor.cpp
View File

@ -18,6 +18,7 @@
#include "nsPIDOMWindow.h"
#include "nsPresContext.h"
using mozilla::dom::KeyboardEvent;
using namespace mozilla::widget;
namespace mozilla {

1
dom/base/TimeoutExecutor.cpp
View File

@ -8,6 +8,7 @@
#include "mozilla/dom/TimeoutManager.h"
#include "nsComponentManagerUtils.h"
#include "nsIEventTarget.h"
#include "nsString.h"
namespace mozilla {

1
dom/base/TimeoutManager.h
View File

@ -12,6 +12,7 @@
class nsIEventTarget;
class nsITimeoutHandler;
class nsITimer;
class nsGlobalWindowInner;
namespace mozilla {

10
dom/base/moz.build
View File

@ -156,6 +156,9 @@ EXPORTS.mozilla.dom += [
'BodyUtil.h',
'BorrowedAttrInfo.h',
'ChildIterator.h',
'ChildProcessMessageManager.h',
'ChromeMessageBroadcaster.h',
'ChromeMessageSender.h',
'ChromeNodeList.h',
'ChromeUtils.h',
'Comment.h',
@ -195,6 +198,8 @@ EXPORTS.mozilla.dom += [
'IntlUtils.h',
'Link.h',
'Location.h',
'MessageListenerManager.h',
'MessageSender.h',
'NameSpaceConstants.h',
'Navigator.h',
'NodeInfo.h',
@ -212,6 +217,7 @@ EXPORTS.mozilla.dom += [
'StructuredCloneTags.h',
'StyleSheetList.h',
'SubtleCrypto.h',
'SyncMessageSender.h',
'TabGroup.h',
'Text.h',
'Timeout.h',
@ -234,6 +240,8 @@ UNIFIED_SOURCES += [
'BodyUtil.cpp',
'BorrowedAttrInfo.cpp',
'ChildIterator.cpp',
'ChromeMessageBroadcaster.cpp',
'ChromeMessageSender.cpp',
'ChromeNodeList.cpp',
'ChromeUtils.cpp',
'Comment.cpp',
@ -269,6 +277,8 @@ UNIFIED_SOURCES += [
'IntlUtils.cpp',
'Link.cpp',
'Location.cpp',
'MessageListenerManager.cpp',
'MessageSender.cpp',
'Navigator.cpp',
'NodeInfo.cpp',
'NodeIterator.cpp',

1
dom/base/nsContentIterator.cpp
View File

@ -18,6 +18,7 @@
#include "nsElementTable.h"
using mozilla::DebugOnly;
using mozilla::Move;
using mozilla::RawRangeBoundary;
// couple of utility static functs

6
dom/base/nsFrameLoader.cpp
View File

@ -79,6 +79,7 @@
#include "mozilla/HTMLEditor.h"
#include "mozilla/Preferences.h"
#include "mozilla/Unused.h"
#include "mozilla/dom/ChromeMessageSender.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/FrameLoaderBinding.h"
#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
@ -3106,9 +3107,8 @@ nsFrameLoader::EnsureMessageManager()
parentManager = do_GetService("@mozilla.org/globalmessagemanager;1");
}
mMessageManager = new nsFrameMessageManager(nullptr,
static_cast<nsFrameMessageManager*>(parentManager.get()),
MM_CHROME);
mMessageManager = new ChromeMessageSender(nullptr,
static_cast<nsFrameMessageManager*>(parentManager.get()));
if (!IsRemoteFrame()) {
nsresult rv = MaybeCreateDocShell();
if (NS_FAILED(rv)) {

5
dom/base/nsFrameLoader.h
View File

@ -44,6 +44,7 @@ namespace mozilla {
class OriginAttributes;
namespace dom {
class ChromeMessageSender;
class ContentParent;
class PBrowserParent;
class Promise;
@ -268,7 +269,7 @@ public:
*/
RenderFrameParent* GetCurrentRenderFrame() const;
nsFrameMessageManager* GetFrameMessageManager() { return mMessageManager; }
mozilla::dom::ChromeMessageSender* GetFrameMessageManager() { return mMessageManager; }
mozilla::dom::Element* GetOwnerContent() { return mOwnerContent; }
bool ShouldClipSubdocument() { return mClipSubdocument; }
@ -319,7 +320,7 @@ public:
virtual nsIMessageSender* GetProcessMessageManager() const override;
// public because a callback needs these.
RefPtr<nsFrameMessageManager> mMessageManager;
RefPtr<mozilla::dom::ChromeMessageSender> mMessageManager;
nsCOMPtr<nsIInProcessContentFrameMessageManager> mChildMessageManager;
virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto) override;

115
dom/base/nsFrameMessageManager.cpp
View File

@ -37,6 +37,9 @@
#include "mozilla/ScriptPreloader.h"
#include "mozilla/Telemetry.h"
#include "mozilla/dom/DOMPrefs.h"
#include "mozilla/dom/ChildProcessMessageManager.h"
#include "mozilla/dom/ChromeMessageBroadcaster.h"
#include "mozilla/dom/ChromeMessageSender.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/MessagePort.h"
#include "mozilla/dom/ContentParent.h"
@ -71,33 +74,20 @@ using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::dom::ipc;
nsFrameMessageManager::nsFrameMessageManager(mozilla::dom::ipc::MessageManagerCallback* aCallback,
nsFrameMessageManager* aParentManager,
/* mozilla::dom::ipc::MessageManagerFlags */ uint32_t aFlags)
: mChrome(!!(aFlags & mozilla::dom::ipc::MM_CHROME)),
mGlobal(!!(aFlags & mozilla::dom::ipc::MM_GLOBAL)),
mIsProcessManager(!!(aFlags & mozilla::dom::ipc::MM_PROCESSMANAGER)),
mIsBroadcaster(!!(aFlags & mozilla::dom::ipc::MM_BROADCASTER)),
mOwnsCallback(!!(aFlags & mozilla::dom::ipc::MM_OWNSCALLBACK)),
nsFrameMessageManager::nsFrameMessageManager(MessageManagerCallback* aCallback,
MessageManagerFlags aFlags)
: mChrome(aFlags & MessageManagerFlags::MM_CHROME),
mGlobal(aFlags & MessageManagerFlags::MM_GLOBAL),
mIsProcessManager(aFlags & MessageManagerFlags::MM_PROCESSMANAGER),
mIsBroadcaster(aFlags & MessageManagerFlags::MM_BROADCASTER),
mOwnsCallback(aFlags & MessageManagerFlags::MM_OWNSCALLBACK),
mHandlingMessage(false),
mClosed(false),
mDisconnected(false),
mCallback(aCallback),
mParentManager(aParentManager)
mCallback(aCallback)
{
NS_ASSERTION(mChrome || !aParentManager, "Should not set parent manager!");
NS_ASSERTION(!mIsBroadcaster || !mCallback,
"Broadcasters cannot have callbacks!");
if (mIsProcessManager && (!mChrome || IsBroadcaster())) {
mozilla::HoldJSObjects(this);
}
// This is a bit hackish. When parent manager is global, we want
// to attach the message manager to it immediately.
// Is it just the frame message manager which waits until the
// content process is running.
if (mParentManager && (mCallback || IsBroadcaster())) {
mParentManager->AddChildManager(this);
}
if (mOwnsCallback) {
mOwnedCallback = aCallback;
}
@ -105,9 +95,6 @@ nsFrameMessageManager::nsFrameMessageManager(mozilla::dom::ipc::MessageManagerCa
nsFrameMessageManager::~nsFrameMessageManager()
{
if (mIsProcessManager && (!mChrome || IsBroadcaster())) {
mozilla::DropJSObjects(this);
}
for (int32_t i = mChildManagers.Count(); i > 0; --i) {
static_cast<nsFrameMessageManager*>(mChildManagers[i - 1])->
Disconnect(false);
@ -138,7 +125,6 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsFrameMessageManager)
}
}
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChildManagers)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParentManager)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsFrameMessageManager)
@ -152,7 +138,6 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsFrameMessageManager)
Disconnect(false);
}
NS_IMPL_CYCLE_COLLECTION_UNLINK(mChildManagers)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mParentManager)
tmp->mInitialProcessData.setNull();
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
@ -606,7 +591,6 @@ nsFrameMessageManager::SendMessage(const nsAString& aMessageName,
NS_ASSERTION(!IsGlobal(), "Should not call SendSyncMessage in chrome");
NS_ASSERTION(!IsBroadcaster(), "Should not call SendSyncMessage in chrome");
NS_ASSERTION(!mParentManager, "Should not have parent manager in content!");
aRetval.setUndefined();
NS_ENSURE_TRUE(mCallback, NS_ERROR_NOT_INITIALIZED);
@ -1123,7 +1107,7 @@ nsFrameMessageManager::ReceiveMessage(nsISupports* aTarget,
}
}
RefPtr<nsFrameMessageManager> kungFuDeathGrip = mParentManager;
RefPtr<nsFrameMessageManager> kungFuDeathGrip = GetParentManager();
if (kungFuDeathGrip) {
return kungFuDeathGrip->ReceiveMessage(aTarget, aTargetFrameLoader,
aTargetClosed, aMessage,
@ -1153,8 +1137,9 @@ nsFrameMessageManager::LoadPendingScripts(nsFrameMessageManager* aManager,
// In that case we want to load the pending scripts from all parent
// message managers in the hierarchy. Process the parent first so
// that pending scripts higher up in the hierarchy are loaded before others.
if (aManager->mParentManager) {
LoadPendingScripts(aManager->mParentManager, aChildMM);
nsFrameMessageManager* parentManager = aManager->GetParentManager();
if (parentManager) {
LoadPendingScripts(parentManager, aChildMM);
}
for (uint32_t i = 0; i < aManager->mPendingScripts.Length(); ++i) {
@ -1184,37 +1169,6 @@ nsFrameMessageManager::SetCallback(MessageManagerCallback* aCallback)
}
}
void
nsFrameMessageManager::InitWithCallback(MessageManagerCallback* aCallback)
{
if (mCallback) {
// Initialization should only happen once.
return;
}
SetCallback(aCallback);
// First load parent scripts by adding this to parent manager.
if (mParentManager) {
mParentManager->AddChildManager(this);
}
for (uint32_t i = 0; i < mPendingScripts.Length(); ++i) {
LoadFrameScript(mPendingScripts[i], false, mPendingScriptsGlobalStates[i]);
}
}
void
nsFrameMessageManager::RemoveFromParent()
{
if (mParentManager) {
mParentManager->RemoveChildManager(this);
}
mParentManager = nullptr;
mCallback = nullptr;
mOwnedCallback = nullptr;
}
void
nsFrameMessageManager::Close()
{
@ -1243,11 +1197,10 @@ nsFrameMessageManager::Disconnect(bool aRemoveFromParent)
"message-manager-disconnect", nullptr);
}
}
if (mParentManager && aRemoveFromParent) {
mParentManager->RemoveChildManager(this);
}
ClearParentManager(aRemoveFromParent);
mDisconnected = true;
mParentManager = nullptr;
if (!mHandlingMessage) {
mListeners.Clear();
}
@ -1484,9 +1437,8 @@ NS_NewGlobalMessageManager(nsIMessageBroadcaster** aResult)
{
NS_ENSURE_TRUE(XRE_IsParentProcess(),
NS_ERROR_NOT_AVAILABLE);
RefPtr<nsFrameMessageManager> mm = new nsFrameMessageManager(nullptr,
nullptr,
MM_CHROME | MM_GLOBAL | MM_BROADCASTER);
RefPtr<nsFrameMessageManager> mm =
new ChromeMessageBroadcaster(MessageManagerFlags::MM_GLOBAL);
RegisterStrongMemoryReporter(new MessageManagerReporter());
mm.forget(aResult);
return NS_OK;
@ -1747,7 +1699,7 @@ nsMessageManagerScriptExecutor::MarkScopesForCC()
NS_IMPL_ISUPPORTS(nsScriptCacheCleaner, nsIObserver)
nsFrameMessageManager* nsFrameMessageManager::sChildProcessManager = nullptr;
ChildProcessMessageManager* nsFrameMessageManager::sChildProcessManager = nullptr;
nsFrameMessageManager* nsFrameMessageManager::sParentProcessManager = nullptr;
nsFrameMessageManager* nsFrameMessageManager::sSameProcessParentManager = nullptr;
@ -1968,9 +1920,8 @@ NS_NewParentProcessMessageManager(nsIMessageBroadcaster** aResult)
{
NS_ASSERTION(!nsFrameMessageManager::sParentProcessManager,
"Re-creating sParentProcessManager");
RefPtr<nsFrameMessageManager> mm = new nsFrameMessageManager(nullptr,
nullptr,
MM_CHROME | MM_PROCESSMANAGER | MM_BROADCASTER);
RefPtr<nsFrameMessageManager> mm =
new ChromeMessageBroadcaster(MessageManagerFlags::MM_PROCESSMANAGER);
nsFrameMessageManager::sParentProcessManager = mm;
nsFrameMessageManager::NewProcessMessageManager(false); // Create same process message manager.
mm.forget(aResult);
@ -1978,7 +1929,7 @@ NS_NewParentProcessMessageManager(nsIMessageBroadcaster** aResult)
}
nsFrameMessageManager*
ChromeMessageSender*
nsFrameMessageManager::NewProcessMessageManager(bool aIsRemote)
{
if (!nsFrameMessageManager::sParentProcessManager) {
@ -1988,17 +1939,18 @@ nsFrameMessageManager::NewProcessMessageManager(bool aIsRemote)
MOZ_ASSERT(nsFrameMessageManager::sParentProcessManager,
"parent process manager not created");
nsFrameMessageManager* mm;
ChromeMessageSender* mm;
if (aIsRemote) {
// Callback is set in ContentParent::InitInternal so that the process has
// already started when we send pending scripts.
mm = new nsFrameMessageManager(nullptr,
nsFrameMessageManager::sParentProcessManager,
MM_CHROME | MM_PROCESSMANAGER);
mm = new ChromeMessageSender(nullptr,
nsFrameMessageManager::sParentProcessManager,
MessageManagerFlags::MM_PROCESSMANAGER);
} else {
mm = new nsFrameMessageManager(new SameParentProcessMessageManagerCallback(),
nsFrameMessageManager::sParentProcessManager,
MM_CHROME | MM_PROCESSMANAGER | MM_OWNSCALLBACK);
mm = new ChromeMessageSender(new SameParentProcessMessageManagerCallback(),
nsFrameMessageManager::sParentProcessManager,
MessageManagerFlags::MM_PROCESSMANAGER |
MessageManagerFlags::MM_OWNSCALLBACK);
sSameProcessParentManager = mm;
}
return mm;
@ -2017,8 +1969,7 @@ NS_NewChildProcessMessageManager(nsISyncMessageSender** aResult)
cb = new ChildProcessMessageManagerCallback();
RegisterStrongMemoryReporter(new MessageManagerReporter());
}
auto* mm = new nsFrameMessageManager(cb, nullptr,
MM_PROCESSMANAGER | MM_OWNSCALLBACK);
auto* mm = new ChildProcessMessageManager(cb);
nsFrameMessageManager::SetChildProcessManager(mm);
RefPtr<ProcessGlobal> global = new ProcessGlobal(mm);
NS_ENSURE_TRUE(global->Init(), NS_ERROR_UNEXPECTED);

57
dom/base/nsFrameMessageManager.h
View File

@ -28,6 +28,7 @@
#include "mozilla/Attributes.h"
#include "js/RootingAPI.h"
#include "nsTObserverArray.h"
#include "mozilla/TypedEnumBits.h"
#include "mozilla/dom/SameProcessMessageQueue.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/jsipc/CpowHolder.h"
@ -39,6 +40,8 @@ namespace dom {
class nsIContentParent;
class nsIContentChild;
class ChildProcessMessageManager;
class ChromeMessageSender;
class ClonedMessageData;
class MessageManagerReporter;
@ -48,14 +51,15 @@ namespace ipc {
// of 1 ms actually captures from 500us and above.
static const uint32_t kMinTelemetrySyncMessageManagerLatencyMs = 1;
enum MessageManagerFlags {
MM_CHILD = 0,
enum class MessageManagerFlags {
MM_NONE = 0,
MM_CHROME = 1,
MM_GLOBAL = 2,
MM_PROCESSMANAGER = 4,
MM_BROADCASTER = 8,
MM_OWNSCALLBACK = 16
};
MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(MessageManagerFlags);
class MessageManagerCallback
{
@ -150,22 +154,27 @@ private:
JS::Rooted<JSObject*> mObj;
};
class nsFrameMessageManager final : public nsIContentFrameMessageManager,
public nsIMessageBroadcaster,
public nsIFrameScriptLoader,
public nsIGlobalProcessScriptLoader
class nsFrameMessageManager : public nsIContentFrameMessageManager,
public nsIMessageBroadcaster,
public nsIFrameScriptLoader,
public nsIGlobalProcessScriptLoader
{
friend class mozilla::dom::MessageManagerReporter;
typedef mozilla::dom::ipc::StructuredCloneData StructuredCloneData;
public:
protected:
typedef mozilla::dom::ipc::MessageManagerFlags MessageManagerFlags;
nsFrameMessageManager(mozilla::dom::ipc::MessageManagerCallback* aCallback,
nsFrameMessageManager* aParentManager,
/* mozilla::dom::ipc::MessageManagerFlags */ uint32_t aFlags);
MessageManagerFlags aFlags);
private:
~nsFrameMessageManager();
virtual ~nsFrameMessageManager();
public:
explicit nsFrameMessageManager(mozilla::dom::ipc::MessageManagerCallback* aCallback)
: nsFrameMessageManager(aCallback, MessageManagerFlags::MM_NONE)
{}
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsFrameMessageManager,
nsIContentFrameMessageManager)
@ -179,7 +188,7 @@ public:
NS_DECL_NSIPROCESSSCRIPTLOADER
NS_DECL_NSIGLOBALPROCESSSCRIPTLOADER
static nsFrameMessageManager*
static mozilla::dom::ChromeMessageSender*
NewProcessMessageManager(bool aIsRemote);
nsresult ReceiveMessage(nsISupports* aTarget, nsIFrameLoader* aTargetFrameLoader,
@ -196,7 +205,6 @@ public:
void Disconnect(bool aRemoveFromParent = true);
void Close();
void InitWithCallback(mozilla::dom::ipc::MessageManagerCallback* aCallback);
void SetCallback(mozilla::dom::ipc::MessageManagerCallback* aCallback);
mozilla::dom::ipc::MessageManagerCallback* GetCallback()
@ -217,14 +225,6 @@ public:
StructuredCloneData& aData,
JS::Handle<JSObject*> aCpows,
nsIPrincipal* aPrincipal);
void RemoveFromParent();
nsFrameMessageManager* GetParentManager() { return mParentManager; }
void SetParentManager(nsFrameMessageManager* aParent)
{
NS_ASSERTION(!mParentManager, "We have parent manager already!");
NS_ASSERTION(mChrome, "Should not set parent manager!");
mParentManager = aParent;
}
bool IsGlobal() { return mGlobal; }
bool IsBroadcaster() { return mIsBroadcaster; }
@ -232,11 +232,11 @@ public:
{
return sParentProcessManager;
}
static nsFrameMessageManager* GetChildProcessManager()
static mozilla::dom::ChildProcessMessageManager* GetChildProcessManager()
{
return sChildProcessManager;
}
static void SetChildProcessManager(nsFrameMessageManager* aManager)
static void SetChildProcessManager(mozilla::dom::ChildProcessMessageManager* aManager)
{
sChildProcessManager = aManager;
}
@ -246,6 +246,14 @@ public:
void LoadPendingScripts();
private:
virtual nsFrameMessageManager* GetParentManager()
{
return nullptr;
}
virtual void ClearParentManager(bool aRemove)
{
}
nsresult SendMessage(const nsAString& aMessageName,
JS::Handle<JS::Value> aJSON,
JS::Handle<JS::Value> aObjects,
@ -284,7 +292,6 @@ protected:
bool mDisconnected;
mozilla::dom::ipc::MessageManagerCallback* mCallback;
nsAutoPtr<mozilla::dom::ipc::MessageManagerCallback> mOwnedCallback;
RefPtr<nsFrameMessageManager> mParentManager;
nsTArray<nsString> mPendingScripts;
nsTArray<bool> mPendingScriptsGlobalStates;
JS::Heap<JS::Value> mInitialProcessData;
@ -296,7 +303,7 @@ public:
static nsFrameMessageManager* sSameProcessParentManager;
static nsTArray<nsCOMPtr<nsIRunnable> >* sPendingSameProcessAsyncMessages;
private:
static nsFrameMessageManager* sChildProcessManager;
static mozilla::dom::ChildProcessMessageManager* sChildProcessManager;
enum ProcessCheckerType {
PROCESS_CHECKER_PERMISSION,
PROCESS_CHECKER_MANIFEST_URL,

20
dom/base/nsGlobalWindowInner.cpp
View File

@ -1246,8 +1246,7 @@ nsGlobalWindowInner::CleanUp()
if (mCleanMessageManager) {
MOZ_ASSERT(mIsChrome, "only chrome should have msg manager cleaned");
if (mChromeFields.mMessageManager) {
static_cast<nsFrameMessageManager*>(
mChromeFields.mMessageManager.get())->Disconnect();
mChromeFields.mMessageManager->Disconnect();
}
}
@ -7593,7 +7592,7 @@ nsGlobalWindowInner::GetMessageManager(nsIMessageBroadcaster** aManager)
return rv.StealNSResult();
}
nsIMessageBroadcaster*
ChromeMessageBroadcaster*
nsGlobalWindowInner::GetMessageManager(ErrorResult& aError)
{
MOZ_ASSERT(IsChromeWindow());
@ -7601,9 +7600,7 @@ nsGlobalWindowInner::GetMessageManager(ErrorResult& aError)
nsCOMPtr<nsIMessageBroadcaster> globalMM =
do_GetService("@mozilla.org/globalmessagemanager;1");
mChromeFields.mMessageManager =
new nsFrameMessageManager(nullptr,
static_cast<nsFrameMessageManager*>(globalMM.get()),
MM_CHROME | MM_BROADCASTER);
new ChromeMessageBroadcaster(static_cast<nsFrameMessageManager*>(globalMM.get()));
}
return mChromeFields.mMessageManager;
}
@ -7618,21 +7615,18 @@ nsGlobalWindowInner::GetGroupMessageManager(const nsAString& aGroup,
return rv.StealNSResult();
}
nsIMessageBroadcaster*
ChromeMessageBroadcaster*
nsGlobalWindowInner::GetGroupMessageManager(const nsAString& aGroup,
ErrorResult& aError)
{
MOZ_ASSERT(IsChromeWindow());
nsCOMPtr<nsIMessageBroadcaster> messageManager =
RefPtr<ChromeMessageBroadcaster> messageManager =
mChromeFields.mGroupMessageManagers.LookupForAdd(aGroup).OrInsert(
[this, &aError] () {
nsFrameMessageManager* parent =
static_cast<nsFrameMessageManager*>(GetMessageManager(aError));
nsFrameMessageManager* parent = GetMessageManager(aError);
return new nsFrameMessageManager(nullptr,
parent,
MM_CHROME | MM_BROADCASTER);
return new ChromeMessageBroadcaster(parent);
});
return messageManager;
}

19
dom/base/nsGlobalWindowInner.h
View File

@ -37,11 +37,11 @@
#include "prclist.h"
#include "mozilla/dom/DOMPrefs.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/ChromeMessageBroadcaster.h"
#include "mozilla/dom/StorageEvent.h"
#include "mozilla/dom/StorageEventBinding.h"
#include "mozilla/dom/UnionTypes.h"
#include "mozilla/ErrorResult.h"
#include "nsFrameMessageManager.h"
#include "mozilla/Attributes.h"
#include "mozilla/GuardObjects.h"
#include "mozilla/LinkedList.h"
@ -941,9 +941,11 @@ public:
void Restore();
void NotifyDefaultButtonLoaded(mozilla::dom::Element& aDefaultButton,
mozilla::ErrorResult& aError);
nsIMessageBroadcaster* GetMessageManager(mozilla::ErrorResult& aError);
nsIMessageBroadcaster* GetGroupMessageManager(const nsAString& aGroup,
mozilla::ErrorResult& aError);
mozilla::dom::ChromeMessageBroadcaster*
GetMessageManager(mozilla::ErrorResult& aError);
mozilla::dom::ChromeMessageBroadcaster*
GetGroupMessageManager(const nsAString& aGroup,
mozilla::ErrorResult& aError);
void BeginWindowMove(mozilla::dom::Event& aMouseDownEvent,
mozilla::dom::Element* aPanel,
mozilla::ErrorResult& aError);
@ -1271,9 +1273,9 @@ private:
{
MOZ_RELEASE_ASSERT(IsChromeWindow());
for (auto iter = mChromeFields.mGroupMessageManagers.Iter(); !iter.Done(); iter.Next()) {
nsIMessageBroadcaster* mm = iter.UserData();
mozilla::dom::ChromeMessageBroadcaster* mm = iter.UserData();
if (mm) {
static_cast<nsFrameMessageManager*>(mm)->Disconnect();
mm->Disconnect();
}
}
mChromeFields.mGroupMessageManagers.Clear();
@ -1473,8 +1475,9 @@ protected:
: mGroupMessageManagers(1)
{}
nsCOMPtr<nsIMessageBroadcaster> mMessageManager;
nsInterfaceHashtable<nsStringHashKey, nsIMessageBroadcaster> mGroupMessageManagers;
RefPtr<mozilla::dom::ChromeMessageBroadcaster> mMessageManager;
nsRefPtrHashtable<nsStringHashKey,
mozilla::dom::ChromeMessageBroadcaster> mGroupMessageManagers;
} mChromeFields;
// These fields are used by the inner and outer windows to prevent

2
dom/base/nsGlobalWindowOuter.h
View File

@ -37,11 +37,11 @@
#include "mozilla/FlushType.h"
#include "prclist.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/ChromeMessageBroadcaster.h"
#include "mozilla/dom/StorageEvent.h"
#include "mozilla/dom/StorageEventBinding.h"
#include "mozilla/dom/UnionTypes.h"
#include "mozilla/ErrorResult.h"
#include "nsFrameMessageManager.h"
#include "mozilla/Attributes.h"
#include "mozilla/GuardObjects.h"
#include "mozilla/LinkedList.h"

4
dom/base/nsInProcessTabChildGlobal.cpp
View File

@ -131,9 +131,7 @@ nsInProcessTabChildGlobal::Init()
InitTabChildGlobal();
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
"Couldn't initialize nsInProcessTabChildGlobal");
mMessageManager = new nsFrameMessageManager(this,
nullptr,
dom::ipc::MM_CHILD);
mMessageManager = new nsFrameMessageManager(this);
return NS_OK;
}

1
dom/base/nsJSUtils.cpp
View File

@ -15,6 +15,7 @@
#include "jsapi.h"
#include "jsfriendapi.h"
#include "nsIScriptContext.h"
#include "nsIScriptElement.h"
#include "nsIScriptGlobalObject.h"
#include "nsIXPConnect.h"
#include "nsCOMPtr.h"

1
dom/ipc/ContentBridgeParent.cpp
View File

@ -5,6 +5,7 @@
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/dom/ContentBridgeParent.h"
#include "mozilla/dom/ChromeMessageSender.h"
#include "mozilla/dom/TabParent.h"
#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
#include "nsXULAppAPI.h"

1
dom/ipc/ContentChild.cpp
View File

@ -24,6 +24,7 @@
#include "mozilla/docshell/OfflineCacheUpdateChild.h"
#include "mozilla/dom/ClientManager.h"
#include "mozilla/dom/ClientOpenWindowOpActors.h"
#include "mozilla/dom/ChildProcessMessageManager.h"
#include "mozilla/dom/ContentBridgeChild.h"
#include "mozilla/dom/ContentBridgeParent.h"
#include "mozilla/dom/DOMPrefs.h"

4
dom/ipc/TabChild.cpp
View File

@ -3486,9 +3486,7 @@ void
TabChildGlobal::Init()
{
NS_ASSERTION(!mMessageManager, "Re-initializing?!?");
mMessageManager = new nsFrameMessageManager(mTabChild,
nullptr,
MM_CHILD);
mMessageManager = new nsFrameMessageManager(mTabChild);
TelemetryScrollProbe::Create(this);
}

1
dom/ipc/TabParent.cpp
View File

@ -13,6 +13,7 @@
#include "nsAccessibilityService.h"
#endif
#include "mozilla/BrowserElementParent.h"
#include "mozilla/dom/ChromeMessageSender.h"
#include "mozilla/dom/ContentBridgeParent.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/DataTransfer.h"

1
dom/ipc/nsIContentChild.cpp
View File

@ -7,6 +7,7 @@
#include "nsIContentChild.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/ChildProcessMessageManager.h"
#include "mozilla/dom/DOMTypes.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/PermissionMessageUtils.h"

2
dom/ipc/nsIContentParent.cpp
View File

@ -8,6 +8,7 @@
#include "mozilla/Preferences.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/ChromeMessageSender.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/ContentBridgeParent.h"
#include "mozilla/dom/ContentProcessManager.h"
@ -24,7 +25,6 @@
#include "mozilla/ipc/IPCStreamSource.h"
#include "mozilla/Unused.h"
#include "nsFrameMessageManager.h"
#include "nsIWebBrowserChrome.h"
#include "nsPrintfCString.h"
#include "xpcpublic.h"

5
dom/ipc/nsIContentParent.h
View File

@ -44,6 +44,7 @@ namespace dom {
class Blob;
class BlobConstructorParams;
class BlobImpl;
class ChromeMessageSender;
class ContentParent;
class ContentBridgeParent;
class IPCTabContext;
@ -88,7 +89,7 @@ public:
ContentBridgeParent* AsContentBridgeParent();
nsFrameMessageManager* GetMessageManager() const { return mMessageManager; }
mozilla::dom::ChromeMessageSender* GetMessageManager() const { return mMessageManager; }
virtual bool SendActivate(PBrowserParent* aTab) = 0;
@ -161,7 +162,7 @@ protected: // IPDL methods
const ClonedMessageData& aData);
protected: // members
RefPtr<nsFrameMessageManager> mMessageManager;
RefPtr<mozilla::dom::ChromeMessageSender> mMessageManager;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIContentParent, NS_ICONTENTPARENT_IID)