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

Bug 1451973 - Split off process from non-process message managers. r=bz.

Browse Source 
Process and non-process managers have different script loader interfaces
(ProcessScriptLoader/GlobalProcessScriptLoader vs FrameScriptLoader). The WebIDL
conversion used the same interface for some process and
non-process managers, but because of the different script loader interfaces they really
should be using separate interfaces.

--HG--
rename : dom/base/ChromeMessageBroadcaster.cpp => dom/base/MessageBroadcaster.cpp
rename : dom/base/ChromeMessageBroadcaster.h => dom/base/MessageBroadcaster.h
rename : dom/base/ChromeMessageBroadcaster.cpp => dom/base/ParentProcessMessageManager.cpp
rename : dom/base/ChromeMessageBroadcaster.h => dom/base/ParentProcessMessageManager.h
rename : dom/base/ChromeMessageSender.cpp => dom/base/ProcessMessageManager.cpp
rename : dom/base/ChromeMessageSender.h => dom/base/ProcessMessageManager.h
extra : rebase_source : 6694ae975bc2af1b496db6b8cef645ec62582d9a
This commit is contained in:
Peter Van der Beken 2018-04-16 15:18:48 +02:00
parent a074d3d299
commit 3659b3ea86
35 changed files with 442 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
dom/base/ChromeMessageBroadcaster.cpp
View File

@ -7,34 +7,11 @@
#include "mozilla/dom/ChromeMessageBroadcaster.h"
#include "AccessCheck.h"
#include "mozilla/HoldDropJSObjects.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/MessageManagerBinding.h"
namespace mozilla {
namespace dom {
ChromeMessageBroadcaster::ChromeMessageBroadcaster(ChromeMessageBroadcaster* 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);
}
}
JSObject*
ChromeMessageBroadcaster::WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto)
@ -44,28 +21,5 @@ ChromeMessageBroadcaster::WrapObject(JSContext* aCx,
return ChromeMessageBroadcasterBinding::Wrap(aCx, this, aGivenProto);
}
void
ChromeMessageBroadcaster::ReleaseCachedProcesses()
{
ContentParent::ReleaseCachedProcesses();
}
void
ChromeMessageBroadcaster::AddChildManager(MessageListenerManager* aManager)
{
mChildManagers.AppendElement(aManager);
RefPtr<nsFrameMessageManager> kungfuDeathGrip = this;
RefPtr<nsFrameMessageManager> kungfuDeathGrip2 = aManager;
LoadPendingScripts(this, aManager);
}
void
ChromeMessageBroadcaster::RemoveChildManager(MessageListenerManager* aManager)
{
mChildManagers.RemoveElement(aManager);
}
} // namespace dom
} // namespace mozilla

70
dom/base/ChromeMessageBroadcaster.h
View File

@ -7,74 +7,31 @@
#ifndef mozilla_dom_ChromeMessageBroadcaster_h
#define mozilla_dom_ChromeMessageBroadcaster_h
#include "mozilla/dom/MessageListenerManager.h"
#include "mozilla/dom/MessageBroadcaster.h"
namespace mozilla {
namespace dom {
class ChromeMessageBroadcaster final : public MessageListenerManager
/**
* Implementation for the WebIDL ChromeMessageBroadcaster interface. Used for window and
* group message managers.
*/
class ChromeMessageBroadcaster final : public MessageBroadcaster
{
public:
explicit ChromeMessageBroadcaster(MessageManagerFlags aFlags)
: ChromeMessageBroadcaster(nullptr, aFlags)
{
MOZ_ASSERT(!(aFlags & ~(MessageManagerFlags::MM_GLOBAL |
MessageManagerFlags::MM_PROCESSMANAGER |
MessageManagerFlags::MM_OWNSCALLBACK)));
}
explicit ChromeMessageBroadcaster(ChromeMessageBroadcaster* aParentManager)
explicit ChromeMessageBroadcaster(MessageBroadcaster* aParentManager)
: ChromeMessageBroadcaster(aParentManager, MessageManagerFlags::MM_NONE)
{}
static ChromeMessageBroadcaster* From(nsFrameMessageManager* aManager)
{
if (aManager->IsBroadcaster() && aManager->IsChrome()) {
return static_cast<ChromeMessageBroadcaster*>(aManager);
}
return nullptr;
}
virtual JSObject* WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) override;
void BroadcastAsyncMessage(JSContext* aCx, const nsAString& aMessageName,
JS::Handle<JS::Value> aObj,
JS::Handle<JSObject*> aObjects,
mozilla::ErrorResult& aError)
{
DispatchAsyncMessage(aCx, aMessageName, aObj, aObjects, nullptr,
JS::UndefinedHandleValue, aError);
}
uint32_t ChildCount()
{
return mChildManagers.Length();
}
MessageListenerManager* GetChildAt(uint32_t aIndex)
{
return mChildManagers.SafeElementAt(aIndex);
}
void ReleaseCachedProcesses();
// ProcessScriptLoader
void LoadProcessScript(const nsAString& aUrl, bool aAllowDelayedLoad,
mozilla::ErrorResult& aError)
{
LoadScript(aUrl, aAllowDelayedLoad, false, aError);
}
void RemoveDelayedProcessScript(const nsAString& aURL)
{
RemoveDelayedScript(aURL);
}
void GetDelayedProcessScripts(JSContext* aCx,
nsTArray<nsTArray<JS::Value>>& aScripts,
mozilla::ErrorResult& aError)
{
GetDelayedScripts(aCx, aScripts, aError);
}
// GlobalProcessScriptLoader
using nsFrameMessageManager::GetInitialProcessData;
// FrameScriptLoader
void LoadFrameScript(const nsAString& aUrl, bool aAllowDelayedLoad,
bool aRunInGlobalScope, mozilla::ErrorResult& aError)
@ -92,13 +49,14 @@ public:
GetDelayedScripts(aCx, aScripts, aError);
}
void AddChildManager(MessageListenerManager* aManager);
void RemoveChildManager(MessageListenerManager* aManager);
private:
ChromeMessageBroadcaster(ChromeMessageBroadcaster* aParentManager,
MessageManagerFlags aFlags);
virtual ~ChromeMessageBroadcaster();
ChromeMessageBroadcaster(MessageBroadcaster* aParentManager,
MessageManagerFlags aFlags)
: MessageBroadcaster(aParentManager,
aFlags |
MessageManagerFlags::MM_BROADCASTER |
MessageManagerFlags::MM_CHROME)
{}
};
} // namespace dom

18
dom/base/ChromeMessageSender.cpp
View File

@ -10,24 +10,6 @@
namespace mozilla {
namespace dom {
ChromeMessageSender::ChromeMessageSender(ipc::MessageManagerCallback* aCallback,
ChromeMessageBroadcaster* 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);
}
}
JSObject*
ChromeMessageSender::WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto)

28
dom/base/ChromeMessageSender.h
View File

@ -12,35 +12,21 @@
namespace mozilla {
namespace dom {
class ChromeMessageBroadcaster;
class MessageBroadcaster;
class ChromeMessageSender final : public MessageSender
{
public:
ChromeMessageSender(ipc::MessageManagerCallback* aCallback,
ChromeMessageBroadcaster* aParentManager,
MessageManagerFlags aFlags=MessageManagerFlags::MM_NONE);
explicit ChromeMessageSender(MessageBroadcaster* aParentManager)
: MessageSender(nullptr, aParentManager, MessageManagerFlags::MM_CHROME)
{
// This is a bit hackish, we wait until the child process is running before attaching
// to the parent manager (see MessageSender::InitWithCallback).
}
virtual JSObject* WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) override;
// ProcessScriptLoader
void LoadProcessScript(const nsAString& aUrl, bool aAllowDelayedLoad,
mozilla::ErrorResult& aError)
{
LoadScript(aUrl, aAllowDelayedLoad, false, aError);
}
void RemoveDelayedProcessScript(const nsAString& aURL)
{
RemoveDelayedScript(aURL);
}
void GetDelayedProcessScripts(JSContext* aCx,
nsTArray<nsTArray<JS::Value>>& aScripts,
mozilla::ErrorResult& aError)
{
GetDelayedScripts(aCx, aScripts, aError);
}
// FrameScriptLoader
void LoadFrameScript(const nsAString& aUrl, bool aAllowDelayedLoad,
bool aRunInGlobalScope, mozilla::ErrorResult& aError)

2
dom/base/DocumentOrShadowRoot.h
View File

@ -13,6 +13,7 @@
#include "nsIdentifierMapEntry.h"
class nsContentList;
class nsIDocument;
class nsINode;
namespace mozilla {
@ -20,6 +21,7 @@ class StyleSheet;
namespace dom {
class Element;
class StyleSheetList;
class ShadowRoot;

48
dom/base/MessageBroadcaster.cpp Normal file
View File

@ -0,0 +1,48 @@
/* -*- 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/MessageBroadcaster.h"
#include "mozilla/dom/ContentParent.h"
namespace mozilla {
namespace dom {
MessageBroadcaster::MessageBroadcaster(MessageBroadcaster* aParentManager,
MessageManagerFlags aFlags)
: MessageListenerManager(nullptr, aParentManager,
aFlags |
MessageManagerFlags::MM_BROADCASTER)
{
if (aParentManager) {
aParentManager->AddChildManager(this);
}
}
void
MessageBroadcaster::ReleaseCachedProcesses()
{
ContentParent::ReleaseCachedProcesses();
}
void
MessageBroadcaster::AddChildManager(MessageListenerManager* aManager)
{
mChildManagers.AppendElement(aManager);
RefPtr<nsFrameMessageManager> kungfuDeathGrip = this;
RefPtr<nsFrameMessageManager> kungfuDeathGrip2 = aManager;
LoadPendingScripts(this, aManager);
}
void
MessageBroadcaster::RemoveChildManager(MessageListenerManager* aManager)
{
mChildManagers.RemoveElement(aManager);
}
} // namespace dom
} // namespace mozilla

58
dom/base/MessageBroadcaster.h Normal file
View File

@ -0,0 +1,58 @@
/* -*- 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_MessageBroadcaster_h
#define mozilla_dom_MessageBroadcaster_h
#include "mozilla/dom/MessageListenerManager.h"
namespace mozilla {
namespace dom {
/**
* Implementation for the WebIDL MessageBroadcaster interface. Base class for window and
* process broadcaster message managers.
*/
class MessageBroadcaster : public MessageListenerManager
{
public:
static MessageBroadcaster* From(MessageListenerManager* aManager)
{
if (aManager->IsBroadcaster()) {
return static_cast<MessageBroadcaster*>(aManager);
}
return nullptr;
}
void BroadcastAsyncMessage(JSContext* aCx, const nsAString& aMessageName,
JS::Handle<JS::Value> aObj,
JS::Handle<JSObject*> aObjects,
mozilla::ErrorResult& aError)
{
DispatchAsyncMessage(aCx, aMessageName, aObj, aObjects, nullptr,
JS::UndefinedHandleValue, aError);
}
uint32_t ChildCount()
{
return mChildManagers.Length();
}
MessageListenerManager* GetChildAt(uint32_t aIndex)
{
return mChildManagers.SafeElementAt(aIndex);
}
void ReleaseCachedProcesses();
void AddChildManager(MessageListenerManager* aManager);
void RemoveChildManager(MessageListenerManager* aManager);
protected:
MessageBroadcaster(MessageBroadcaster* aParentManager, MessageManagerFlags aFlags);
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_MessageBroadcaster_h

2
dom/base/MessageListenerManager.cpp
View File

@ -10,7 +10,7 @@ namespace mozilla {
namespace dom {
MessageListenerManager::MessageListenerManager(ipc::MessageManagerCallback* aCallback,
ChromeMessageBroadcaster* aParentManager,
MessageBroadcaster* aParentManager,
ipc::MessageManagerFlags aFlags)
: nsFrameMessageManager(aCallback, aFlags),
mParentManager(aParentManager)

14
dom/base/MessageListenerManager.h
View File

@ -14,6 +14,12 @@
namespace mozilla {
namespace dom {
class MessageBroadcaster;
/**
* Implementation for the WebIDL MessageListenerManager interface. Base class for message
* managers that are exposed to script.
*/
class MessageListenerManager : public nsFrameMessageManager,
public nsWrapperCache
{
@ -22,12 +28,12 @@ public:
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(MessageListenerManager,
nsFrameMessageManager)
ChromeMessageBroadcaster* GetParentObject()
MessageBroadcaster* GetParentObject()
{
return mParentManager;
}
virtual ChromeMessageBroadcaster* GetParentManager() override
virtual MessageBroadcaster* GetParentManager() override
{
return mParentManager;
}
@ -40,11 +46,11 @@ public:
protected:
MessageListenerManager(ipc::MessageManagerCallback* aCallback,
ChromeMessageBroadcaster* aParentManager,
MessageBroadcaster* aParentManager,
MessageManagerFlags aFlags);
virtual ~MessageListenerManager();
RefPtr<ChromeMessageBroadcaster> mParentManager;
RefPtr<MessageBroadcaster> mParentManager;
};
} // namespace dom

2
dom/base/MessageManagerGlobal.h
View File

@ -78,7 +78,7 @@ public:
mMessageManager->SendAsyncMessage(aCx, aMessageName, aObj, aObjects,
aPrincipal, aTransfers, aError);
}
already_AddRefed<ChromeMessageSender> GetProcessMessageManager(mozilla::ErrorResult& aError)
already_AddRefed<ProcessMessageManager> GetProcessMessageManager(mozilla::ErrorResult& aError)
{
if (!mMessageManager) {
aError.Throw(NS_ERROR_NULL_POINTER);

8
dom/base/MessageSender.h
View File

@ -12,6 +12,12 @@
namespace mozilla {
namespace dom {
class MessageBroadcaster;
/**
* Implementation for the WebIDL MessageSender interface. Base class for frame and child
* process message managers.
*/
class MessageSender : public MessageListenerManager
{
public:
@ -19,7 +25,7 @@ public:
protected:
MessageSender(ipc::MessageManagerCallback* aCallback,
ChromeMessageBroadcaster* aParentManager,
MessageBroadcaster* aParentManager,
MessageManagerFlags aFlags)
: MessageListenerManager(aCallback, aParentManager, aFlags)
{}

3
dom/base/MozQueryInterface.h
View File

@ -20,8 +20,9 @@
*/
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/ChromeUtilsBinding.h"
#include "mozilla/dom/NonRefcountedDOMObject.h"
#include "mozilla/ErrorResult.h"
#include "nsID.h"
namespace mozilla {
namespace dom {

2
dom/base/NameSpaceConstants.h
View File

@ -7,6 +7,8 @@
#ifndef mozilla_dom_NameSpaceConstants_h__
#define mozilla_dom_NameSpaceConstants_h__
#include <stdint.h>
#define kNameSpaceID_Unknown -1
// 0 is special at C++, so use a static const int32_t for
// kNameSpaceID_None to keep if from being cast to pointers

36
dom/base/ParentProcessMessageManager.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/ParentProcessMessageManager.h"
#include "AccessCheck.h"
#include "mozilla/HoldDropJSObjects.h"
#include "mozilla/dom/MessageManagerBinding.h"
namespace mozilla {
namespace dom {
ParentProcessMessageManager::ParentProcessMessageManager()
: MessageBroadcaster(nullptr, MessageManagerFlags::MM_PROCESSMANAGER)
{
mozilla::HoldJSObjects(this);
}
ParentProcessMessageManager::~ParentProcessMessageManager()
{
mozilla::DropJSObjects(this);
}
JSObject*
ParentProcessMessageManager::WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto)
{
MOZ_ASSERT(nsContentUtils::IsSystemCaller(aCx));
return ParentProcessMessageManagerBinding::Wrap(aCx, this, aGivenProto);
}
} // namespace dom
} // namespace mozilla

55
dom/base/ParentProcessMessageManager.h Normal file
View File

@ -0,0 +1,55 @@
/* -*- 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_ParentProcessMessageManager_h
#define mozilla_dom_ParentProcessMessageManager_h
#include "mozilla/dom/MessageBroadcaster.h"
namespace mozilla {
namespace dom {
/**
* Implementation for the WebIDL ParentProcessMessageManager interface.
* ParentProcessMessageManager is used in a parent process to communicate with all the
* child processes.
*/
class ParentProcessMessageManager final : public MessageBroadcaster
{
public:
ParentProcessMessageManager();
virtual JSObject* WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) override;
// ProcessScriptLoader
void LoadProcessScript(const nsAString& aUrl, bool aAllowDelayedLoad,
mozilla::ErrorResult& aError)
{
LoadScript(aUrl, aAllowDelayedLoad, false, aError);
}
void RemoveDelayedProcessScript(const nsAString& aURL)
{
RemoveDelayedScript(aURL);
}
void GetDelayedProcessScripts(JSContext* aCx,
nsTArray<nsTArray<JS::Value>>& aScripts,
mozilla::ErrorResult& aError)
{
GetDelayedScripts(aCx, aScripts, aError);
}
// GlobalProcessScriptLoader
using nsFrameMessageManager::GetInitialProcessData;
private:
virtual ~ParentProcessMessageManager();
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_ParentProcessMessageManager_h

41
dom/base/ProcessMessageManager.cpp Normal file
View File

@ -0,0 +1,41 @@
/* -*- 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/ProcessMessageManager.h"
#include "mozilla/dom/MessageManagerBinding.h"
namespace mozilla {
namespace dom {
ProcessMessageManager::ProcessMessageManager(ipc::MessageManagerCallback* aCallback,
ParentProcessMessageManager* aParentManager,
MessageManagerFlags aFlags)
: MessageSender(aCallback, aParentManager,
aFlags | MessageManagerFlags::MM_CHROME |
MessageManagerFlags::MM_PROCESSMANAGER)
{
MOZ_ASSERT(!(aFlags & ~(MessageManagerFlags::MM_GLOBAL |
MessageManagerFlags::MM_OWNSCALLBACK)));
// This is a bit hackish. We attach to the parent manager, but only if we have a
// callback (which is only for the in-process message manager). For other cases we wait
// until the child process is running (see MessageSender::InitWithCallback).
if (aParentManager && mCallback) {
aParentManager->AddChildManager(this);
}
}
JSObject*
ProcessMessageManager::WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto)
{
MOZ_ASSERT(nsContentUtils::IsSystemCaller(aCx));
return ProcessMessageManagerBinding::Wrap(aCx, this, aGivenProto);
}
} // namespace dom
} // namespace mozilla

52
dom/base/ProcessMessageManager.h Normal file
View File

@ -0,0 +1,52 @@
/* -*- 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_ProcessMessageManager_h
#define mozilla_dom_ProcessMessageManager_h
#include "mozilla/dom/MessageSender.h"
namespace mozilla {
namespace dom {
class ParentProcessMessageManager;
/**
* ProcessMessageManager is used in a parent process to communicate with a child process
* (or with the process itself in a single-process scenario).
*/
class ProcessMessageManager final : public MessageSender
{
public:
ProcessMessageManager(ipc::MessageManagerCallback* aCallback,
ParentProcessMessageManager* aParentManager,
MessageManagerFlags aFlags=MessageManagerFlags::MM_NONE);
virtual JSObject* WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) override;
// ProcessScriptLoader
void LoadProcessScript(const nsAString& aUrl, bool aAllowDelayedLoad,
mozilla::ErrorResult& aError)
{
LoadScript(aUrl, aAllowDelayedLoad, false, aError);
}
void RemoveDelayedProcessScript(const nsAString& aURL)
{
RemoveDelayedScript(aURL);
}
void GetDelayedProcessScripts(JSContext* aCx,
nsTArray<nsTArray<JS::Value>>& aScripts,
mozilla::ErrorResult& aError)
{
GetDelayedScripts(aCx, aScripts, aError);
}
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_ProcessMessageManager_h

1
dom/base/ShadowRoot.cpp
View File

@ -18,6 +18,7 @@
#include "mozilla/ServoStyleRuleMap.h"
#include "mozilla/StyleSheet.h"
#include "mozilla/StyleSheetInlines.h"
#include "mozilla/dom/StyleSheetList.h"
using namespace mozilla;
using namespace mozilla::dom;

1
dom/base/StyleSheetList.cpp
View File

@ -7,6 +7,7 @@
#include "mozilla/dom/StyleSheetList.h"
#include "mozilla/dom/StyleSheetListBinding.h"
#include "nsINode.h"
namespace mozilla {
namespace dom {

6
dom/base/moz.build
View File

@ -190,6 +190,7 @@ EXPORTS.mozilla.dom += [
'IntlUtils.h',
'Link.h',
'Location.h',
'MessageBroadcaster.h',
'MessageListenerManager.h',
'MessageManagerGlobal.h',
'MessageSender.h',
@ -199,8 +200,10 @@ EXPORTS.mozilla.dom += [
'NodeInfo.h',
'NodeInfoInlines.h',
'NodeIterator.h',
'ParentProcessMessageManager.h',
'Pose.h',
'ProcessGlobal.h',
'ProcessMessageManager.h',
'ResponsiveImageSelector.h',
'SameProcessMessageQueue.h',
'ScreenOrientation.h',
@ -271,6 +274,7 @@ UNIFIED_SOURCES += [
'IntlUtils.cpp',
'Link.cpp',
'Location.cpp',
'MessageBroadcaster.cpp',
'MessageListenerManager.cpp',
'MessageManagerGlobal.cpp',
'MessageSender.cpp',
@ -344,9 +348,11 @@ UNIFIED_SOURCES += [
'nsXHTMLContentSerializer.cpp',
'nsXMLContentSerializer.cpp',
'nsXMLNameSpaceMap.cpp',
'ParentProcessMessageManager.cpp',
'Pose.cpp',
'PostMessageEvent.cpp',
'ProcessGlobal.cpp',
'ProcessMessageManager.cpp',
'ResponsiveImageSelector.cpp',
'SameProcessMessageQueue.cpp',
'ScreenOrientation.cpp',

9
dom/base/nsCCUncollectableMarker.cpp
View File

@ -30,7 +30,9 @@
#include "mozilla/CycleCollectedJSContext.h"
#include "mozilla/CycleCollectedJSRuntime.h"
#include "mozilla/EventListenerManager.h"
#include "mozilla/dom/ChromeMessageBroadcaster.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/ParentProcessMessageManager.h"
#include "mozilla/dom/ProcessGlobal.h"
#include "mozilla/dom/TabChild.h"
#include "mozilla/dom/TimeoutManager.h"
@ -86,7 +88,7 @@ nsCCUncollectableMarker::Init()
}
static void
MarkChildMessageManagers(ChromeMessageBroadcaster* aMM)
MarkChildMessageManagers(MessageBroadcaster* aMM)
{
aMM->MarkForCC();
@ -97,9 +99,8 @@ MarkChildMessageManagers(ChromeMessageBroadcaster* aMM)
continue;
}
RefPtr<ChromeMessageBroadcaster> strongNonLeafMM =
ChromeMessageBroadcaster::From(childMM);
ChromeMessageBroadcaster* nonLeafMM = strongNonLeafMM;
RefPtr<MessageBroadcaster> strongNonLeafMM = MessageBroadcaster::From(childMM);
MessageBroadcaster* nonLeafMM = strongNonLeafMM;
MessageListenerManager* tabMM = childMM;

7
dom/base/nsContentUtils.cpp
View File

@ -39,6 +39,7 @@
#include "mozilla/LoadInfo.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/CustomElementRegistry.h"
#include "mozilla/dom/MessageBroadcaster.h"
#include "mozilla/dom/DocumentFragment.h"
#include "mozilla/dom/DOMException.h"
#include "mozilla/dom/DOMExceptionBinding.h"
@ -7718,7 +7719,7 @@ nsContentUtils::GetHostOrIPv6WithBrackets(nsIURI* aURI, nsAString& aHost)
}
bool
nsContentUtils::CallOnAllRemoteChildren(ChromeMessageBroadcaster* aManager,
nsContentUtils::CallOnAllRemoteChildren(MessageBroadcaster* aManager,
CallOnRemoteChildFunction aCallback,
void* aArg)
{
@ -7729,7 +7730,7 @@ nsContentUtils::CallOnAllRemoteChildren(ChromeMessageBroadcaster* aManager,
continue;
}
RefPtr<ChromeMessageBroadcaster> nonLeafMM = ChromeMessageBroadcaster::From(childMM);
RefPtr<MessageBroadcaster> nonLeafMM = MessageBroadcaster::From(childMM);
if (nonLeafMM) {
if (CallOnAllRemoteChildren(nonLeafMM, aCallback, aArg)) {
return true;
@ -7759,7 +7760,7 @@ nsContentUtils::CallOnAllRemoteChildren(nsPIDOMWindowOuter* aWindow,
{
nsGlobalWindowOuter* window = nsGlobalWindowOuter::Cast(aWindow);
if (window->IsChromeWindow()) {
RefPtr<ChromeMessageBroadcaster> windowMM = window->GetMessageManager();
RefPtr<MessageBroadcaster> windowMM = window->GetMessageManager();
if (windowMM) {
CallOnAllRemoteChildren(windowMM, aCallback, aArg);
}

4
dom/base/nsContentUtils.h
View File

@ -125,7 +125,6 @@ class EventListenerManager;
class HTMLEditor;
namespace dom {
class ChromeMessageBroadcaster;
struct CustomElementDefinition;
class DocumentFragment;
class Element;
@ -136,6 +135,7 @@ class IPCDataTransfer;
class IPCDataTransferItem;
struct LifecycleCallbackArgs;
struct LifecycleAdoptedCallbackArgs;
class MessageBroadcaster;
class NodeInfo;
class nsIContentChild;
class nsIContentParent;
@ -3329,7 +3329,7 @@ private:
mozilla::dom::AutocompleteInfo& aInfo,
bool aGrantAllValidValue = false);
static bool CallOnAllRemoteChildren(mozilla::dom::ChromeMessageBroadcaster* aManager,
static bool CallOnAllRemoteChildren(mozilla::dom::MessageBroadcaster* aManager,
CallOnRemoteChildFunction aCallback,
void* aArg);

5
dom/base/nsDOMMutationObserver.cpp
View File

@ -23,10 +23,7 @@
#include "nsThreadUtils.h"
using namespace mozilla;
using mozilla::dom::TreeOrderComparator;
using mozilla::dom::Animation;
using mozilla::dom::Element;
using namespace mozilla::dom;
AutoTArray<RefPtr<nsDOMMutationObserver>, 4>*
nsDOMMutationObserver::sScheduledMutationObservers = nullptr;

4
dom/base/nsFrameLoader.cpp
View File

@ -2947,7 +2947,7 @@ nsFrameLoader::EnsureMessageManager()
parentManager = nsFrameMessageManager::GetGlobalMessageManager();
}
mMessageManager = new ChromeMessageSender(nullptr, parentManager);
mMessageManager = new ChromeMessageSender(parentManager);
if (!IsRemoteFrame()) {
nsresult rv = MaybeCreateDocShell();
if (NS_FAILED(rv)) {
@ -3388,7 +3388,7 @@ nsFrameLoader::PopulateUserContextIdFromAttribute(OriginAttributes& aAttr)
return NS_OK;
}
ChromeMessageSender*
ProcessMessageManager*
nsFrameLoader::GetProcessMessageManager() const
{
return mRemoteBrowser ? mRemoteBrowser->Manager()->GetMessageManager()

3
dom/base/nsFrameLoader.h
View File

@ -53,6 +53,7 @@ class ChromeMessageSender;
class ContentParent;
class MessageSender;
class PBrowserParent;
class ProcessMessageManager;
class Promise;
class TabParent;
class MutableTabContext;
@ -333,7 +334,7 @@ public:
// Properly retrieves documentSize of any subdocument type.
nsresult GetWindowDimensions(nsIntRect& aRect);
virtual mozilla::dom::ChromeMessageSender* GetProcessMessageManager() const override;
virtual mozilla::dom::ProcessMessageManager* GetProcessMessageManager() const override;
// public because a callback needs these.
RefPtr<mozilla::dom::ChromeMessageSender> mMessageManager;

40
dom/base/nsFrameMessageManager.cpp
View File

@ -36,13 +36,14 @@
#include "mozilla/Telemetry.h"
#include "mozilla/dom/ChildProcessMessageManager.h"
#include "mozilla/dom/ChromeMessageBroadcaster.h"
#include "mozilla/dom/ChromeMessageSender.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/MessageManagerBinding.h"
#include "mozilla/dom/MessagePort.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/ParentProcessMessageManager.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/ProcessGlobal.h"
#include "mozilla/dom/ProcessMessageManager.h"
#include "mozilla/dom/ResolveSystemBinding.h"
#include "mozilla/dom/SameProcessMessageQueue.h"
#include "mozilla/dom/ScriptSettings.h"
@ -161,7 +162,7 @@ nsresult
MessageManagerCallback::DoGetRemoteType(nsAString& aRemoteType) const
{
aRemoteType.Truncate();
mozilla::dom::ChromeMessageSender* parent = GetProcessMessageManager();
mozilla::dom::ProcessMessageManager* parent = GetProcessMessageManager();
if (!parent) {
return NS_OK;
}
@ -951,8 +952,7 @@ nsFrameMessageManager::Close()
if (!mClosed) {
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->NotifyObservers(NS_ISUPPORTS_CAST(nsIContentFrameMessageManager*, this),
"message-manager-close", nullptr);
obs->NotifyObservers(this, "message-manager-close", nullptr);
}
}
mClosed = true;
@ -969,8 +969,7 @@ nsFrameMessageManager::Disconnect(bool aRemoveFromParent)
if (!mDisconnected) {
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->NotifyObservers(NS_ISUPPORTS_CAST(nsIContentFrameMessageManager*, this),
"message-manager-disconnect", nullptr);
obs->NotifyObservers(this, "message-manager-disconnect", nullptr);
}
}
@ -1035,10 +1034,10 @@ nsFrameMessageManager::GetInitialProcessData(JSContext* aCx,
aInitialProcessData.set(init);
}
already_AddRefed<ChromeMessageSender>
already_AddRefed<ProcessMessageManager>
nsFrameMessageManager::GetProcessMessageManager(ErrorResult& aError)
{
RefPtr<ChromeMessageSender> pmm;
RefPtr<ProcessMessageManager> pmm;
if (mCallback) {
pmm = mCallback->GetProcessMessageManager();
}
@ -1477,7 +1476,7 @@ nsMessageManagerScriptExecutor::MarkScopesForCC()
NS_IMPL_ISUPPORTS(nsScriptCacheCleaner, nsIObserver)
ChildProcessMessageManager* nsFrameMessageManager::sChildProcessManager = nullptr;
ChromeMessageBroadcaster* nsFrameMessageManager::sParentProcessManager = nullptr;
ParentProcessMessageManager* nsFrameMessageManager::sParentProcessManager = nullptr;
nsFrameMessageManager* nsFrameMessageManager::sSameProcessParentManager = nullptr;
class nsAsyncMessageToSameProcessChild : public nsSameProcessAsyncMessageBase,
@ -1492,7 +1491,7 @@ public:
NS_IMETHOD Run() override
{
nsFrameMessageManager* ppm = nsFrameMessageManager::GetChildProcessManager();
ReceiveMessage(static_cast<nsIContentFrameMessageManager*>(ppm), nullptr, ppm);
ReceiveMessage(ppm, nullptr, ppm);
return NS_OK;
}
};
@ -1629,7 +1628,7 @@ public:
nsresult HandleMessage() override
{
nsFrameMessageManager* ppm = nsFrameMessageManager::sSameProcessParentManager;
ReceiveMessage(static_cast<nsIContentFrameMessageManager*>(ppm), nullptr, ppm);
ReceiveMessage(ppm, nullptr, ppm);
return NS_OK;
}
};
@ -1697,8 +1696,7 @@ NS_NewParentProcessMessageManager(nsISupports** aResult)
{
NS_ASSERTION(!nsFrameMessageManager::sParentProcessManager,
"Re-creating sParentProcessManager");
RefPtr<ChromeMessageBroadcaster> mm =
new ChromeMessageBroadcaster(MessageManagerFlags::MM_PROCESSMANAGER);
RefPtr<ParentProcessMessageManager> mm = new ParentProcessMessageManager();
nsFrameMessageManager::sParentProcessManager = mm;
nsFrameMessageManager::NewProcessMessageManager(false); // Create same process message manager.
mm.forget(aResult);
@ -1706,7 +1704,7 @@ NS_NewParentProcessMessageManager(nsISupports** aResult)
}
ChromeMessageSender*
ProcessMessageManager*
nsFrameMessageManager::NewProcessMessageManager(bool aIsRemote)
{
if (!nsFrameMessageManager::sParentProcessManager) {
@ -1716,18 +1714,16 @@ nsFrameMessageManager::NewProcessMessageManager(bool aIsRemote)
MOZ_ASSERT(nsFrameMessageManager::sParentProcessManager,
"parent process manager not created");
ChromeMessageSender* mm;
ProcessMessageManager* mm;
if (aIsRemote) {
// Callback is set in ContentParent::InitInternal so that the process has
// already started when we send pending scripts.
mm = new ChromeMessageSender(nullptr,
nsFrameMessageManager::sParentProcessManager,
MessageManagerFlags::MM_PROCESSMANAGER);
mm = new ProcessMessageManager(nullptr,
nsFrameMessageManager::sParentProcessManager);
} else {
mm = new ChromeMessageSender(new SameParentProcessMessageManagerCallback(),
nsFrameMessageManager::sParentProcessManager,
MessageManagerFlags::MM_PROCESSMANAGER |
MessageManagerFlags::MM_OWNSCALLBACK);
mm = new ProcessMessageManager(new SameParentProcessMessageManagerCallback(),
nsFrameMessageManager::sParentProcessManager,
MessageManagerFlags::MM_OWNSCALLBACK);
sSameProcessParentManager = mm;
}
return mm;

17
dom/base/nsFrameMessageManager.h
View File

@ -43,12 +43,14 @@ class nsIContentParent;
class nsIContentChild;
class ChildProcessMessageManager;
class ChromeMessageBroadcaster;
class ChromeMessageSender;
class ClonedMessageData;
class MessageBroadcaster;
class MessageListener;
class MessageListenerManager;
class MessageManagerReporter;
template<typename T> class Optional;
class ParentProcessMessageManager;
class ProcessMessageManager;
namespace ipc {
@ -96,7 +98,7 @@ public:
return NS_OK;
}
virtual mozilla::dom::ChromeMessageSender* GetProcessMessageManager() const
virtual mozilla::dom::ProcessMessageManager* GetProcessMessageManager() const
{
return nullptr;
}
@ -201,7 +203,7 @@ public:
DispatchAsyncMessage(aCx, aMessageName, aObj, aObjects, aPrincipal, aTransfers,
aError);
}
already_AddRefed<mozilla::dom::ChromeMessageSender>
already_AddRefed<mozilla::dom::ProcessMessageManager>
GetProcessMessageManager(mozilla::ErrorResult& aError);
void GetRemoteType(nsAString& aRemoteType, mozilla::ErrorResult& aError) const;
@ -233,8 +235,7 @@ public:
NS_DECL_NSIMESSAGESENDER
NS_DECL_NSICONTENTFRAMEMESSAGEMANAGER
static mozilla::dom::ChromeMessageSender*
NewProcessMessageManager(bool aIsRemote);
static mozilla::dom::ProcessMessageManager* NewProcessMessageManager(bool aIsRemote);
void ReceiveMessage(nsISupports* aTarget, nsFrameLoader* aTargetFrameLoader,
const nsAString& aMessage, bool aIsSync,
@ -268,7 +269,7 @@ public:
// GetGlobalMessageManager creates the global message manager if it hasn't been yet.
static already_AddRefed<mozilla::dom::ChromeMessageBroadcaster>
GetGlobalMessageManager();
static mozilla::dom::ChromeMessageBroadcaster* GetParentProcessManager()
static mozilla::dom::ParentProcessMessageManager* GetParentProcessManager()
{
return sParentProcessManager;
}
@ -288,7 +289,7 @@ public:
protected:
friend class MMListenerRemover;
virtual mozilla::dom::ChromeMessageBroadcaster* GetParentManager()
virtual mozilla::dom::MessageBroadcaster* GetParentManager()
{
return nullptr;
}
@ -365,7 +366,7 @@ protected:
void LoadPendingScripts(nsFrameMessageManager* aManager,
nsFrameMessageManager* aChildMM);
public:
static mozilla::dom::ChromeMessageBroadcaster* sParentProcessManager;
static mozilla::dom::ParentProcessMessageManager* sParentProcessManager;
static nsFrameMessageManager* sSameProcessParentManager;
static nsTArray<nsCOMPtr<nsIRunnable> >* sPendingSameProcessAsyncMessages;
private:

7
dom/base/nsIdentifierMapEntry.h
View File

@ -19,6 +19,7 @@
#include "nsCOMPtr.h"
#include "nsAtom.h"
#include "nsHashKeys.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
@ -26,6 +27,12 @@ class nsIContent;
class nsContentList;
class nsBaseContentList;
namespace mozilla {
namespace dom {
class Element;
}
}
/**
* Right now our identifier map entries contain information for 'name'
* and 'id' mappings of a given string. This is so that

46
dom/chrome-webidl/MessageManager.webidl
View File

@ -19,7 +19,7 @@ interface Principal;
*
* Message managers that always have exactly one "other side" are of
* type MessageSender. Parent-side message managers that have many
* "other sides" are of type ChromeMessageBroadcaster.
* "other sides" are of type MessageBroadcaster.
*
* Child-side message managers can send synchronous messages to their
* parent side, but not the other way around.
@ -94,13 +94,13 @@ interface Principal;
* ----------
*
* The global MMg and window MMw's are message broadcasters implementing
* ChromeMessageBroadcaster while the frame MMp's are simple message
* senders (MessageSender). Their counterparts in the content processes
* are message senders implementing ContentFrameMessageManager.
* MessageBroadcaster while the frame MMp's are simple message senders (MessageSender).
* Their counterparts in the content processes are message senders implementing
* ContentFrameMessageManager.
*
* MessageListenerManager
* / \
* MessageSender ChromeMessageBroadcaster
* MessageSender MessageBroadcaster
* |
* SyncMessageSender (content process/in-process only)
* |
@ -352,6 +352,10 @@ interface SyncMessageSender : MessageSender
optional Principal? principal = null);
};
/**
* ChildProcessMessageManager is used in a child process to communicate with the parent
* process.
*/
[ChromeOnly]
interface ChildProcessMessageManager : SyncMessageSender
{
@ -503,7 +507,7 @@ ContentProcessMessageManager implements MessageManagerGlobal;
* managers within its window.
*/
[ChromeOnly]
interface ChromeMessageBroadcaster : MessageListenerManager
interface MessageBroadcaster : MessageListenerManager
{
/**
* Like |sendAsyncMessage()|, but also broadcasts this message to
@ -534,12 +538,38 @@ interface ChromeMessageBroadcaster : MessageListenerManager
*/
void releaseCachedProcesses();
};
ChromeMessageBroadcaster implements GlobalProcessScriptLoader;
/**
* ChromeMessageBroadcaster is used for window and group message managers.
*/
[ChromeOnly]
interface ChromeMessageBroadcaster : MessageBroadcaster
{
};
ChromeMessageBroadcaster implements FrameScriptLoader;
/**
* ParentProcessMessageManager is used in a parent process to communicate with all the
* child processes.
*/
[ChromeOnly]
interface ParentProcessMessageManager : MessageBroadcaster
{
};
ParentProcessMessageManager implements GlobalProcessScriptLoader;
[ChromeOnly]
interface ChromeMessageSender : MessageSender
{
};
ChromeMessageSender implements ProcessScriptLoader;
ChromeMessageSender implements FrameScriptLoader;
/**
* ProcessMessageManager is used in a parent process to communicate with a child process
* (or with the process itself in a single-process scenario).
*/
[ChromeOnly]
interface ProcessMessageManager : MessageSender
{
};
ProcessMessageManager implements ProcessScriptLoader;

2
dom/ipc/ContentBridgeParent.cpp
View File

@ -5,7 +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/ProcessMessageManager.h"
#include "mozilla/dom/TabParent.h"
#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
#include "nsXULAppAPI.h"

7
dom/ipc/ContentParent.cpp
View File

@ -157,7 +157,8 @@
#include "nsThread.h"
#include "nsWindowWatcher.h"
#include "nsIXULRuntime.h"
#include "mozilla/dom/ChromeMessageBroadcaster.h"
#include "mozilla/dom/ParentProcessMessageManager.h"
#include "mozilla/dom/ProcessMessageManager.h"
#include "mozilla/dom/nsMixedContentBlocker.h"
#include "nsMemoryInfoDumper.h"
#include "nsMemoryReporterManager.h"
@ -534,7 +535,7 @@ ScriptableCPInfo::GetMessageManager(nsISupports** aMessenger)
return NS_ERROR_NOT_INITIALIZED;
}
RefPtr<ChromeMessageSender> manager = mContentParent->GetMessageManager();
RefPtr<ProcessMessageManager> manager = mContentParent->GetMessageManager();
manager.forget(aMessenger);
return NS_OK;
}
@ -2238,7 +2239,7 @@ ContentParent::InitInternal(ProcessPriority aInitialPriority)
if (ssm) {
ssm->CloneDomainPolicy(&xpcomInit.domainPolicy());
if (ChromeMessageBroadcaster* mm = nsFrameMessageManager::sParentProcessManager) {
if (ParentProcessMessageManager* mm = nsFrameMessageManager::sParentProcessManager) {
AutoJSAPI jsapi;
if (NS_WARN_IF(!jsapi.Init(xpc::PrivilegedJunkScope()))) {
MOZ_CRASH();

2
dom/ipc/nsIContentParent.cpp
View File

@ -8,12 +8,12 @@
#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"
#include "mozilla/dom/PTabContext.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/ProcessMessageManager.h"
#include "mozilla/dom/TabParent.h"
#include "mozilla/dom/ipc/IPCBlobInputStreamParent.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"

6
dom/ipc/nsIContentParent.h
View File

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

1
layout/style/nsComputedDOMStyle.h
View File

@ -14,6 +14,7 @@
#include "mozilla/Attributes.h"
#include "mozilla/StyleComplexColor.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/dom/Element.h"
#include "nsCOMPtr.h"
#include "nsContentUtils.h"
#include "nscore.h"