mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
e4e2da55c9
The bulk of this commit was generated with a script, executed at the top
level of a typical source code checkout. The only non-machine-generated
part was modifying MFBT's moz.build to reflect the new naming.
CLOSED TREE makes big refactorings like this a piece of cake.
# The main substitution.
find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \
xargs perl -p -i -e '
s/nsRefPtr\.h/RefPtr\.h/g; # handle includes
s/nsRefPtr ?</RefPtr</g; # handle declarations and variables
'
# Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h.
perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h
# Handle nsRefPtr.h itself, a couple places that define constructors
# from nsRefPtr, and code generators specially. We do this here, rather
# than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename
# things like nsRefPtrHashtable.
perl -p -i -e 's/nsRefPtr/RefPtr/g' \
mfbt/nsRefPtr.h \
xpcom/glue/nsCOMPtr.h \
xpcom/base/OwningNonNull.h \
ipc/ipdl/ipdl/lower.py \
ipc/ipdl/ipdl/builtin.py \
dom/bindings/Codegen.py \
python/lldbutils/lldbutils/utils.py
# In our indiscriminate substitution above, we renamed
# nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up.
find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \
xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g'
if [ -d .git ]; then
git mv mfbt/nsRefPtr.h mfbt/RefPtr.h
else
hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h
fi
431 lines
14 KiB
C++
431 lines
14 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef nsFrameMessageManager_h__
|
|
#define nsFrameMessageManager_h__
|
|
|
|
#include "nsIMessageManager.h"
|
|
#include "nsIObserver.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "nsCOMArray.h"
|
|
#include "nsTArray.h"
|
|
#include "nsIAtom.h"
|
|
#include "nsCycleCollectionParticipant.h"
|
|
#include "nsTArray.h"
|
|
#include "nsIPrincipal.h"
|
|
#include "nsIXPConnect.h"
|
|
#include "nsDataHashtable.h"
|
|
#include "nsClassHashtable.h"
|
|
#include "mozilla/Services.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "nsWeakPtr.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "js/RootingAPI.h"
|
|
#include "nsTObserverArray.h"
|
|
#include "mozilla/dom/SameProcessMessageQueue.h"
|
|
#include "mozilla/dom/ipc/StructuredCloneData.h"
|
|
#include "mozilla/jsipc/CpowHolder.h"
|
|
|
|
class nsIFrameLoader;
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
class nsIContentParent;
|
|
class nsIContentChild;
|
|
class ClonedMessageData;
|
|
class MessageManagerReporter;
|
|
|
|
namespace ipc {
|
|
|
|
enum MessageManagerFlags {
|
|
MM_CHILD = 0,
|
|
MM_CHROME = 1,
|
|
MM_GLOBAL = 2,
|
|
MM_PROCESSMANAGER = 4,
|
|
MM_BROADCASTER = 8,
|
|
MM_OWNSCALLBACK = 16
|
|
};
|
|
|
|
class MessageManagerCallback
|
|
{
|
|
public:
|
|
virtual ~MessageManagerCallback() {}
|
|
|
|
virtual bool DoLoadMessageManagerScript(const nsAString& aURL, bool aRunInGlobalScope)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
virtual bool DoSendBlockingMessage(JSContext* aCx,
|
|
const nsAString& aMessage,
|
|
StructuredCloneData& aData,
|
|
JS::Handle<JSObject*> aCpows,
|
|
nsIPrincipal* aPrincipal,
|
|
nsTArray<StructuredCloneData>* aRetVal,
|
|
bool aIsSync)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
virtual nsresult DoSendAsyncMessage(JSContext* aCx,
|
|
const nsAString& aMessage,
|
|
StructuredCloneData& aData,
|
|
JS::Handle<JSObject*> aCpows,
|
|
nsIPrincipal* aPrincipal)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
virtual bool CheckPermission(const nsAString& aPermission)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
virtual bool CheckManifestURL(const nsAString& aManifestURL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
virtual bool CheckAppHasPermission(const nsAString& aPermission)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
virtual bool CheckAppHasStatus(unsigned short aStatus)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
virtual bool KillChild()
|
|
{
|
|
// By default, does nothing.
|
|
return false;
|
|
}
|
|
|
|
protected:
|
|
bool BuildClonedMessageDataForParent(nsIContentParent* aParent,
|
|
StructuredCloneData& aData,
|
|
ClonedMessageData& aClonedData);
|
|
bool BuildClonedMessageDataForChild(nsIContentChild* aChild,
|
|
StructuredCloneData& aData,
|
|
ClonedMessageData& aClonedData);
|
|
};
|
|
|
|
void UnpackClonedMessageDataForParent(const ClonedMessageData& aClonedData,
|
|
StructuredCloneData& aData);
|
|
|
|
void UnpackClonedMessageDataForChild(const ClonedMessageData& aClonedData,
|
|
StructuredCloneData& aData);
|
|
|
|
} // namespace ipc
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
struct nsMessageListenerInfo
|
|
{
|
|
bool operator==(const nsMessageListenerInfo& aOther) const
|
|
{
|
|
return &aOther == this;
|
|
}
|
|
|
|
// Exactly one of mStrongListener and mWeakListener must be non-null.
|
|
nsCOMPtr<nsIMessageListener> mStrongListener;
|
|
nsWeakPtr mWeakListener;
|
|
bool mListenWhenClosed;
|
|
};
|
|
|
|
|
|
class MOZ_STACK_CLASS SameProcessCpowHolder : public mozilla::jsipc::CpowHolder
|
|
{
|
|
public:
|
|
SameProcessCpowHolder(JSRuntime *aRuntime, JS::Handle<JSObject*> aObj)
|
|
: mObj(aRuntime, aObj)
|
|
{
|
|
}
|
|
|
|
virtual bool ToObject(JSContext* aCx, JS::MutableHandle<JSObject*> aObjp)
|
|
override;
|
|
|
|
private:
|
|
JS::Rooted<JSObject*> mObj;
|
|
};
|
|
|
|
class nsFrameMessageManager final : public nsIContentFrameMessageManager,
|
|
public nsIMessageBroadcaster,
|
|
public nsIFrameScriptLoader,
|
|
public nsIGlobalProcessScriptLoader,
|
|
public nsIProcessChecker
|
|
{
|
|
friend class mozilla::dom::MessageManagerReporter;
|
|
typedef mozilla::dom::ipc::StructuredCloneData StructuredCloneData;
|
|
public:
|
|
nsFrameMessageManager(mozilla::dom::ipc::MessageManagerCallback* aCallback,
|
|
nsFrameMessageManager* aParentManager,
|
|
/* mozilla::dom::ipc::MessageManagerFlags */ uint32_t aFlags);
|
|
|
|
private:
|
|
~nsFrameMessageManager();
|
|
|
|
public:
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsFrameMessageManager,
|
|
nsIContentFrameMessageManager)
|
|
NS_DECL_NSIMESSAGELISTENERMANAGER
|
|
NS_DECL_NSIMESSAGESENDER
|
|
NS_DECL_NSIMESSAGEBROADCASTER
|
|
NS_DECL_NSISYNCMESSAGESENDER
|
|
NS_DECL_NSIMESSAGEMANAGERGLOBAL
|
|
NS_DECL_NSICONTENTFRAMEMESSAGEMANAGER
|
|
NS_DECL_NSIFRAMESCRIPTLOADER
|
|
NS_DECL_NSIPROCESSSCRIPTLOADER
|
|
NS_DECL_NSIGLOBALPROCESSSCRIPTLOADER
|
|
NS_DECL_NSIPROCESSCHECKER
|
|
|
|
static nsFrameMessageManager*
|
|
NewProcessMessageManager(bool aIsRemote);
|
|
|
|
nsresult ReceiveMessage(nsISupports* aTarget, nsIFrameLoader* aTargetFrameLoader,
|
|
const nsAString& aMessage,
|
|
bool aIsSync, StructuredCloneData* aCloneData,
|
|
mozilla::jsipc::CpowHolder* aCpows, nsIPrincipal* aPrincipal,
|
|
nsTArray<StructuredCloneData>* aRetVal);
|
|
|
|
void AddChildManager(nsFrameMessageManager* aManager);
|
|
void RemoveChildManager(nsFrameMessageManager* aManager)
|
|
{
|
|
mChildManagers.RemoveObject(aManager);
|
|
}
|
|
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()
|
|
{
|
|
return mCallback;
|
|
}
|
|
|
|
nsresult DispatchAsyncMessage(const nsAString& aMessageName,
|
|
const JS::Value& aJSON,
|
|
const JS::Value& aObjects,
|
|
nsIPrincipal* aPrincipal,
|
|
JSContext* aCx,
|
|
uint8_t aArgc);
|
|
nsresult DispatchAsyncMessageInternal(JSContext* aCx,
|
|
const nsAString& aMessage,
|
|
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; }
|
|
|
|
static nsFrameMessageManager* GetParentProcessManager()
|
|
{
|
|
return sParentProcessManager;
|
|
}
|
|
static nsFrameMessageManager* GetChildProcessManager()
|
|
{
|
|
return sChildProcessManager;
|
|
}
|
|
static void SetChildProcessManager(nsFrameMessageManager* aManager)
|
|
{
|
|
sChildProcessManager = aManager;
|
|
}
|
|
|
|
void SetInitialProcessData(JS::HandleValue aInitialData);
|
|
|
|
void LoadPendingScripts();
|
|
|
|
private:
|
|
nsresult SendMessage(const nsAString& aMessageName,
|
|
JS::Handle<JS::Value> aJSON,
|
|
JS::Handle<JS::Value> aObjects,
|
|
nsIPrincipal* aPrincipal,
|
|
JSContext* aCx,
|
|
uint8_t aArgc,
|
|
JS::MutableHandle<JS::Value> aRetval,
|
|
bool aIsSync);
|
|
|
|
nsresult ReceiveMessage(nsISupports* aTarget, nsIFrameLoader* aTargetFrameLoader,
|
|
bool aTargetClosed, const nsAString& aMessage,
|
|
bool aIsSync, StructuredCloneData* aCloneData,
|
|
mozilla::jsipc::CpowHolder* aCpows, nsIPrincipal* aPrincipal,
|
|
nsTArray<StructuredCloneData>* aRetVal);
|
|
|
|
NS_IMETHOD LoadScript(const nsAString& aURL,
|
|
bool aAllowDelayedLoad,
|
|
bool aRunInGlobalScope);
|
|
NS_IMETHOD RemoveDelayedScript(const nsAString& aURL);
|
|
NS_IMETHOD GetDelayedScripts(JSContext* aCx, JS::MutableHandle<JS::Value> aList);
|
|
|
|
protected:
|
|
friend class MMListenerRemover;
|
|
// We keep the message listeners as arrays in a hastable indexed by the
|
|
// message name. That gives us fast lookups in ReceiveMessage().
|
|
nsClassHashtable<nsStringHashKey,
|
|
nsAutoTObserverArray<nsMessageListenerInfo, 1>> mListeners;
|
|
nsCOMArray<nsIContentFrameMessageManager> mChildManagers;
|
|
bool mChrome; // true if we're in the chrome process
|
|
bool mGlobal; // true if we're the global frame message manager
|
|
bool mIsProcessManager; // true if the message manager belongs to the process realm
|
|
bool mIsBroadcaster; // true if the message manager is a broadcaster
|
|
bool mOwnsCallback;
|
|
bool mHandlingMessage;
|
|
bool mClosed; // true if we can no longer send messages
|
|
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;
|
|
|
|
void LoadPendingScripts(nsFrameMessageManager* aManager,
|
|
nsFrameMessageManager* aChildMM);
|
|
public:
|
|
static nsFrameMessageManager* sParentProcessManager;
|
|
static nsFrameMessageManager* sSameProcessParentManager;
|
|
static nsTArray<nsCOMPtr<nsIRunnable> >* sPendingSameProcessAsyncMessages;
|
|
private:
|
|
static nsFrameMessageManager* sChildProcessManager;
|
|
enum ProcessCheckerType {
|
|
PROCESS_CHECKER_PERMISSION,
|
|
PROCESS_CHECKER_MANIFEST_URL,
|
|
ASSERT_APP_HAS_PERMISSION
|
|
};
|
|
nsresult AssertProcessInternal(ProcessCheckerType aType,
|
|
const nsAString& aCapability,
|
|
bool* aValid);
|
|
};
|
|
|
|
/* A helper class for taking care of many details for async message sending
|
|
within a single process. Intended to be used like so:
|
|
|
|
class MyAsyncMessage : public nsSameProcessAsyncMessageBase, public nsRunnable
|
|
{
|
|
NS_IMETHOD Run() {
|
|
ReceiveMessage(..., ...);
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
|
|
RefPtr<nsSameProcessAsyncMessageBase> ev = new MyAsyncMessage();
|
|
nsresult rv = ev->Init(...);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
NS_DispatchToMainThread(ev);
|
|
}
|
|
*/
|
|
class nsSameProcessAsyncMessageBase
|
|
{
|
|
public:
|
|
typedef mozilla::dom::ipc::StructuredCloneData StructuredCloneData;
|
|
|
|
nsSameProcessAsyncMessageBase(JSContext* aCx, JS::Handle<JSObject*> aCpows);
|
|
nsresult Init(JSContext* aCx,
|
|
const nsAString& aMessage,
|
|
StructuredCloneData& aData,
|
|
nsIPrincipal* aPrincipal);
|
|
|
|
void ReceiveMessage(nsISupports* aTarget, nsIFrameLoader* aTargetFrameLoader,
|
|
nsFrameMessageManager* aManager);
|
|
private:
|
|
nsSameProcessAsyncMessageBase(const nsSameProcessAsyncMessageBase&);
|
|
|
|
JSRuntime* mRuntime;
|
|
nsString mMessage;
|
|
StructuredCloneData mData;
|
|
JS::PersistentRooted<JSObject*> mCpows;
|
|
nsCOMPtr<nsIPrincipal> mPrincipal;
|
|
};
|
|
|
|
class nsScriptCacheCleaner;
|
|
|
|
struct nsMessageManagerScriptHolder
|
|
{
|
|
nsMessageManagerScriptHolder(JSContext* aCx,
|
|
JSScript* aScript,
|
|
bool aRunInGlobalScope)
|
|
: mScript(aCx, aScript), mRunInGlobalScope(aRunInGlobalScope)
|
|
{ MOZ_COUNT_CTOR(nsMessageManagerScriptHolder); }
|
|
|
|
~nsMessageManagerScriptHolder()
|
|
{ MOZ_COUNT_DTOR(nsMessageManagerScriptHolder); }
|
|
|
|
bool WillRunInGlobalScope() { return mRunInGlobalScope; }
|
|
|
|
JS::PersistentRooted<JSScript*> mScript;
|
|
bool mRunInGlobalScope;
|
|
};
|
|
|
|
class nsMessageManagerScriptExecutor
|
|
{
|
|
public:
|
|
static void Shutdown();
|
|
already_AddRefed<nsIXPConnectJSObjectHolder> GetGlobal()
|
|
{
|
|
nsCOMPtr<nsIXPConnectJSObjectHolder> ref = mGlobal;
|
|
return ref.forget();
|
|
}
|
|
|
|
void MarkScopesForCC();
|
|
protected:
|
|
friend class nsMessageManagerScriptCx;
|
|
nsMessageManagerScriptExecutor() { MOZ_COUNT_CTOR(nsMessageManagerScriptExecutor); }
|
|
~nsMessageManagerScriptExecutor() { MOZ_COUNT_DTOR(nsMessageManagerScriptExecutor); }
|
|
|
|
void DidCreateGlobal();
|
|
void LoadScriptInternal(const nsAString& aURL, bool aRunInGlobalScope);
|
|
void TryCacheLoadAndCompileScript(const nsAString& aURL,
|
|
bool aRunInGlobalScope,
|
|
bool aShouldCache,
|
|
JS::MutableHandle<JSScript*> aScriptp);
|
|
void TryCacheLoadAndCompileScript(const nsAString& aURL,
|
|
bool aRunInGlobalScope);
|
|
bool InitChildGlobalInternal(nsISupports* aScope, const nsACString& aID);
|
|
nsCOMPtr<nsIXPConnectJSObjectHolder> mGlobal;
|
|
nsCOMPtr<nsIPrincipal> mPrincipal;
|
|
nsAutoTArray<JS::Heap<JSObject*>, 2> mAnonymousGlobalScopes;
|
|
|
|
static nsDataHashtable<nsStringHashKey, nsMessageManagerScriptHolder*>* sCachedScripts;
|
|
static nsScriptCacheCleaner* sScriptCacheCleaner;
|
|
};
|
|
|
|
class nsScriptCacheCleaner final : public nsIObserver
|
|
{
|
|
~nsScriptCacheCleaner() {}
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
nsScriptCacheCleaner()
|
|
{
|
|
nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService();
|
|
if (obsSvc)
|
|
obsSvc->AddObserver(this, "xpcom-shutdown", false);
|
|
}
|
|
|
|
NS_IMETHODIMP Observe(nsISupports *aSubject,
|
|
const char *aTopic,
|
|
const char16_t *aData) override
|
|
{
|
|
nsMessageManagerScriptExecutor::Shutdown();
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
#endif
|