corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1365097 - Convert NS_GetCurrentThread uses in dom (except for dom/media) (r=smaug)

Browse Source 
For the Quatum DOM project, it's better to work in terms of event targets than
threads. This patch converts DOM code to operate on event targets rather than
threads, when possible.

MozReview-Commit-ID: 5FgvpKadUA2
This commit is contained in:
Bill McCloskey
2017-06-01 13:42:05 -07:00
parent 44974a4452
commit 284c3f3132
46 changed files with 223 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
dom/asmjscache/AsmJSCache.cpp
View File

@@ -345,7 +345,7 @@ public:
ParentRunnable(const PrincipalInfo& aPrincipalInfo,
OpenMode aOpenMode,
WriteParams aWriteParams)
: mOwningThread(NS_GetCurrentThread()),
: mOwningEventTarget(GetCurrentThreadEventTarget()),
mPrincipalInfo(aPrincipalInfo),
mOpenMode(aOpenMode),
mWriteParams(aWriteParams),
@@ -370,10 +370,10 @@ private:
bool
IsOnOwningThread() const
{
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
bool current;
return NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)) && current;
return NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)) && current;
}
void
@@ -435,7 +435,7 @@ private:
mState != eFinished);
mState = eFailing;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
nsresult
@@ -543,7 +543,7 @@ private:
return IPC_OK();
}
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
const PrincipalInfo mPrincipalInfo;
const OpenMode mOpenMode;
const WriteParams mWriteParams;
@@ -820,7 +820,7 @@ ParentRunnable::Run()
}
mState = eWaitingToFinishInit;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@@ -867,7 +867,7 @@ ParentRunnable::Run()
if (mOpenMode == eOpenForRead) {
mState = eSendingMetadataForRead;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@@ -879,7 +879,7 @@ ParentRunnable::Run()
}
mState = eSendingCacheFile;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@@ -909,7 +909,7 @@ ParentRunnable::Run()
}
mState = eSendingCacheFile;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}

3
dom/base/DispatcherTrait.cpp
View File

@@ -24,8 +24,7 @@ DispatcherTrait::Dispatch(const char* aName,
nsIEventTarget*
DispatcherTrait::EventTargetFor(TaskCategory aCategory) const
{
nsCOMPtr<nsIEventTarget> main = do_GetMainThread();
return main;
return GetMainThreadEventTarget();
}
AbstractThread*

18
dom/base/ImageEncoder.cpp
View File

@@ -52,9 +52,9 @@ public:
}
already_AddRefed<gfx::DataSourceSurface> GetDataSurfaceSafe() {
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
MOZ_ASSERT(mainThread);
SyncRunnable::DispatchToThread(mainThread, this, false);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
MOZ_ASSERT(mainTarget);
SyncRunnable::DispatchToThread(mainTarget, this, false);
return mDataSourceSurface.forget();
}
@@ -90,9 +90,9 @@ public:
, mFailed(false)
{
if (!NS_IsMainThread() && workers::GetCurrentThreadWorkerPrivate()) {
mCreationThread = NS_GetCurrentThread();
mCreationEventTarget = GetCurrentThreadEventTarget();
} else {
NS_GetMainThread(getter_AddRefs(mCreationThread));
mCreationEventTarget = GetMainThreadEventTarget();
}
}
@@ -126,16 +126,16 @@ public:
mFailed = true;
}
nsIThread* GetCreationThread()
nsIEventTarget* GetCreationThreadEventTarget()
{
return mCreationThread;
return mCreationEventTarget;
}
private:
uint64_t mImgSize;
nsAutoString mType;
void* mImgData;
nsCOMPtr<nsIThread> mCreationThread;
nsCOMPtr<nsIEventTarget> mCreationEventTarget;
RefPtr<EncodeCompleteCallback> mEncodeCompleteCallback;
bool mFailed;
};
@@ -219,7 +219,7 @@ public:
} else {
mEncodingCompleteEvent->SetMembers(imgData, imgSize, mType);
}
rv = mEncodingCompleteEvent->GetCreationThread()->
rv = mEncodingCompleteEvent->GetCreationThreadEventTarget()->
Dispatch(mEncodingCompleteEvent, nsIThread::DISPATCH_NORMAL);
if (NS_FAILED(rv)) {
// Better to leak than to crash.

8
dom/base/StructuredCloneHolder.cpp
View File

@@ -250,7 +250,7 @@ StructuredCloneHolder::StructuredCloneHolder(CloningSupport aSupportsCloning,
, mSupportsTransferring(aSupportsTransferring == TransferringSupported)
, mParent(nullptr)
#ifdef DEBUG
, mCreationThread(NS_GetCurrentThread())
, mCreationEventTarget(GetCurrentThreadEventTarget())
#endif
{}
@@ -277,7 +277,7 @@ StructuredCloneHolder::Write(JSContext* aCx,
ErrorResult& aRv)
{
MOZ_ASSERT_IF(mStructuredCloneScope == StructuredCloneScope::SameProcessSameThread,
mCreationThread == NS_GetCurrentThread());
mCreationEventTarget->IsOnCurrentThread());
if (!StructuredCloneHolderBase::Write(aCx, aValue, aTransfer, cloneDataPolicy)) {
aRv.Throw(NS_ERROR_DOM_DATA_CLONE_ERR);
@@ -292,7 +292,7 @@ StructuredCloneHolder::Read(nsISupports* aParent,
ErrorResult& aRv)
{
MOZ_ASSERT_IF(mStructuredCloneScope == StructuredCloneScope::SameProcessSameThread,
mCreationThread == NS_GetCurrentThread());
mCreationEventTarget->IsOnCurrentThread());
MOZ_ASSERT(aParent);
mozilla::AutoRestore<nsISupports*> guard(mParent);
@@ -334,7 +334,7 @@ StructuredCloneHolder::ReadFromBuffer(nsISupports* aParent,
ErrorResult& aRv)
{
MOZ_ASSERT_IF(mStructuredCloneScope == StructuredCloneScope::SameProcessSameThread,
mCreationThread == NS_GetCurrentThread());
mCreationEventTarget->IsOnCurrentThread());
MOZ_ASSERT(!mBuffer, "ReadFromBuffer() must be called without a Write().");

2
dom/base/StructuredCloneHolder.h
View File

@@ -334,7 +334,7 @@ protected:
mutable nsTArray<MessagePortIdentifier> mPortIdentifiers;
#ifdef DEBUG
nsCOMPtr<nsIThread> mCreationThread;
nsCOMPtr<nsIEventTarget> mCreationEventTarget;
#endif
};

6
dom/base/nsJSEnvironment.cpp
View File

@@ -2666,13 +2666,13 @@ FinishAsyncTaskCallback(JS::AsyncTask* aTask)
{
// AsyncTasks can finish during shutdown so cannot simply
// NS_DispatchToMainThread.
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
if (!mainThread) {
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
if (!mainTarget) {
return false;
}
RefPtr<AsyncTaskRunnable> r = new AsyncTaskRunnable(aTask);
MOZ_ALWAYS_SUCCEEDS(mainThread->Dispatch(r.forget(), NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mainTarget->Dispatch(r.forget(), NS_DISPATCH_NORMAL));
return true;
}

64
dom/cache/Context.cpp vendored
View File

@@ -54,7 +54,7 @@ using mozilla::dom::quota::PersistenceType;
class Context::Data final : public Action::Data
{
public:
explicit Data(nsIThread* aTarget)
explicit Data(nsISerialEventTarget* aTarget)
: mTarget(aTarget)
{
MOZ_DIAGNOSTIC_ASSERT(mTarget);
@@ -63,14 +63,14 @@ public:
virtual mozIStorageConnection*
GetConnection() const override
{
MOZ_ASSERT(mTarget == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
return mConnection;
}
virtual void
SetConnection(mozIStorageConnection* aConn) override
{
MOZ_ASSERT(mTarget == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(!mConnection);
mConnection = aConn;
MOZ_DIAGNOSTIC_ASSERT(mConnection);
@@ -83,10 +83,10 @@ private:
// Context code should guarantee that we are destroyed on the target
// thread once the connection is initialized. If we're not, then
// QuotaManager might race and try to clear the origin out from under us.
MOZ_ASSERT_IF(mConnection, mTarget == NS_GetCurrentThread());
MOZ_ASSERT_IF(mConnection, mTarget->IsOnCurrentThread());
}
nsCOMPtr<nsIThread> mTarget;
nsCOMPtr<nsISerialEventTarget> mTarget;
nsCOMPtr<mozIStorageConnection> mConnection;
// Threadsafe counting because we're created on the PBackground thread
@@ -104,7 +104,7 @@ public:
QuotaInitRunnable(Context* aContext,
Manager* aManager,
Data* aData,
nsIThread* aTarget,
nsISerialEventTarget* aTarget,
Action* aInitAction)
: mContext(aContext)
, mThreadsafeHandle(aContext->CreateThreadsafeHandle())
@@ -112,7 +112,7 @@ public:
, mData(aData)
, mTarget(aTarget)
, mInitAction(aInitAction)
, mInitiatingThread(NS_GetCurrentThread())
, mInitiatingEventTarget(GetCurrentThreadEventTarget())
, mResult(NS_OK)
, mState(STATE_INIT)
, mCanceled(false)
@@ -121,7 +121,7 @@ public:
MOZ_DIAGNOSTIC_ASSERT(mManager);
MOZ_DIAGNOSTIC_ASSERT(mData);
MOZ_DIAGNOSTIC_ASSERT(mTarget);
MOZ_DIAGNOSTIC_ASSERT(mInitiatingThread);
MOZ_DIAGNOSTIC_ASSERT(mInitiatingEventTarget);
MOZ_DIAGNOSTIC_ASSERT(mInitAction);
}
@@ -215,7 +215,7 @@ private:
mState = STATE_COMPLETING;
MOZ_ALWAYS_SUCCEEDS(
mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL));
mInitiatingEventTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL));
}
void Clear()
@@ -231,9 +231,9 @@ private:
RefPtr<ThreadsafeHandle> mThreadsafeHandle;
RefPtr<Manager> mManager;
RefPtr<Data> mData;
nsCOMPtr<nsIThread> mTarget;
nsCOMPtr<nsISerialEventTarget> mTarget;
RefPtr<Action> mInitAction;
nsCOMPtr<nsIThread> mInitiatingThread;
nsCOMPtr<nsIEventTarget> mInitiatingEventTarget;
nsresult mResult;
QuotaInfo mQuotaInfo;
RefPtr<DirectoryLock> mDirectoryLock;
@@ -384,7 +384,7 @@ Context::QuotaInitRunnable::Run()
mState = STATE_CREATE_QUOTA_MANAGER;
MOZ_ALWAYS_SUCCEEDS(
mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL));
mInitiatingEventTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL));
break;
}
// ----------------------------------
@@ -450,7 +450,7 @@ Context::QuotaInitRunnable::Run()
// -------------------
case STATE_RUN_ON_TARGET:
{
MOZ_ASSERT(NS_GetCurrentThread() == mTarget);
MOZ_ASSERT(mTarget->IsOnCurrentThread());
mState = STATE_RUNNING;
@@ -506,14 +506,14 @@ class Context::ActionRunnable final : public nsIRunnable
, public Context::Activity
{
public:
ActionRunnable(Context* aContext, Data* aData, nsIEventTarget* aTarget,
ActionRunnable(Context* aContext, Data* aData, nsISerialEventTarget* aTarget,
Action* aAction, const QuotaInfo& aQuotaInfo)
: mContext(aContext)
, mData(aData)
, mTarget(aTarget)
, mAction(aAction)
, mQuotaInfo(aQuotaInfo)
, mInitiatingThread(NS_GetCurrentThread())
, mInitiatingThread(GetCurrentThreadEventTarget())
, mState(STATE_INIT)
, mResult(NS_OK)
, mExecutingRunOnTarget(false)
@@ -556,7 +556,7 @@ public:
virtual void Resolve(nsresult aRv) override
{
MOZ_ASSERT(mTarget == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(mState == STATE_RUNNING);
mResult = aRv;
@@ -610,10 +610,10 @@ private:
RefPtr<Context> mContext;
RefPtr<Data> mData;
nsCOMPtr<nsIEventTarget> mTarget;
nsCOMPtr<nsISerialEventTarget> mTarget;
RefPtr<Action> mAction;
const QuotaInfo mQuotaInfo;
nsCOMPtr<nsIThread> mInitiatingThread;
nsCOMPtr<nsIEventTarget> mInitiatingThread;
State mState;
nsresult mResult;
@@ -667,7 +667,7 @@ Context::ActionRunnable::Run()
// ----------------------
case STATE_RUN_ON_TARGET:
{
MOZ_ASSERT(NS_GetCurrentThread() == mTarget);
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(!mExecutingRunOnTarget);
// Note that we are calling RunOnTarget(). This lets us detect
@@ -694,7 +694,7 @@ Context::ActionRunnable::Run()
// -----------------
case STATE_RESOLVING:
{
MOZ_ASSERT(NS_GetCurrentThread() == mTarget);
MOZ_ASSERT(mTarget->IsOnCurrentThread());
// The call to Action::RunOnTarget() must have returned now if we
// are running on the target thread again. We may now proceed
// with completion.
@@ -729,7 +729,7 @@ Context::ActionRunnable::Run()
void
Context::ThreadsafeHandle::AllowToClose()
{
if (mOwningThread == NS_GetCurrentThread()) {
if (mOwningEventTarget->IsOnCurrentThread()) {
AllowToCloseOnOwningThread();
return;
}
@@ -739,13 +739,13 @@ Context::ThreadsafeHandle::AllowToClose()
nsCOMPtr<nsIRunnable> runnable =
NewRunnableMethod(this, &ThreadsafeHandle::AllowToCloseOnOwningThread);
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
void
Context::ThreadsafeHandle::InvalidateAndAllowToClose()
{
if (mOwningThread == NS_GetCurrentThread()) {
if (mOwningEventTarget->IsOnCurrentThread()) {
InvalidateAndAllowToCloseOnOwningThread();
return;
}
@@ -755,13 +755,13 @@ Context::ThreadsafeHandle::InvalidateAndAllowToClose()
nsCOMPtr<nsIRunnable> runnable =
NewRunnableMethod(this, &ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread);
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
Context::ThreadsafeHandle::ThreadsafeHandle(Context* aContext)
: mStrongRef(aContext)
, mWeakRef(aContext)
, mOwningThread(NS_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadSerialEventTarget())
{
}
@@ -771,19 +771,19 @@ Context::ThreadsafeHandle::~ThreadsafeHandle()
// however, because when we do use mStrongRef on the owning thread we are
// always holding a strong ref to the ThreadsafeHandle via the owning
// runnable. So we cannot run the ThreadsafeHandle destructor simultaneously.
if (!mStrongRef || mOwningThread == NS_GetCurrentThread()) {
if (!mStrongRef || mOwningEventTarget->IsOnCurrentThread()) {
return;
}
// Dispatch is guaranteed to succeed here because we block shutdown until
// all Contexts have been destroyed.
NS_ProxyRelease(mOwningThread, mStrongRef.forget());
NS_ProxyRelease(mOwningEventTarget, mStrongRef.forget());
}
void
Context::ThreadsafeHandle::AllowToCloseOnOwningThread()
{
MOZ_ASSERT(mOwningThread == NS_GetCurrentThread());
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
// A Context "closes" when its ref count drops to zero. Dropping this
// strong ref is necessary, but not sufficient for the close to occur.
@@ -806,7 +806,7 @@ Context::ThreadsafeHandle::AllowToCloseOnOwningThread()
void
Context::ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread()
{
MOZ_ASSERT(mOwningThread == NS_GetCurrentThread());
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
// Cancel the Context through the weak reference. This means we can
// allow the Context to close by dropping the strong ref, but then
// still cancel ongoing IO if necessary.
@@ -821,7 +821,7 @@ Context::ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread()
void
Context::ThreadsafeHandle::ContextDestroyed(Context* aContext)
{
MOZ_ASSERT(mOwningThread == NS_GetCurrentThread());
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(!mStrongRef);
MOZ_DIAGNOSTIC_ASSERT(mWeakRef);
MOZ_DIAGNOSTIC_ASSERT(mWeakRef == aContext);
@@ -830,7 +830,7 @@ Context::ThreadsafeHandle::ContextDestroyed(Context* aContext)
// static
already_AddRefed<Context>
Context::Create(Manager* aManager, nsIThread* aTarget,
Context::Create(Manager* aManager, nsISerialEventTarget* aTarget,
Action* aInitAction, Context* aOldContext)
{
RefPtr<Context> context = new Context(aManager, aTarget, aInitAction);
@@ -838,7 +838,7 @@ Context::Create(Manager* aManager, nsIThread* aTarget,
return context.forget();
}
Context::Context(Manager* aManager, nsIThread* aTarget, Action* aInitAction)
Context::Context(Manager* aManager, nsISerialEventTarget* aTarget, Action* aInitAction)
: mManager(aManager)
, mTarget(aTarget)
, mData(new Data(aTarget))

8
dom/cache/Context.h vendored
View File

@@ -97,7 +97,7 @@ public:
// safe to access on owning thread.
Context* mWeakRef;
nsCOMPtr<nsIThread> mOwningThread;
nsCOMPtr<nsISerialEventTarget> mOwningEventTarget;
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(cache::Context::ThreadsafeHandle)
};
@@ -118,7 +118,7 @@ public:
// will run on the QuotaManager IO thread. Note, this Action must
// be execute synchronously.
static already_AddRefed<Context>
Create(Manager* aManager, nsIThread* aTarget,
Create(Manager* aManager, nsISerialEventTarget* aTarget,
Action* aInitAction, Context* aOldContext);
// Execute given action on the target once the quota manager has been
@@ -183,7 +183,7 @@ private:
RefPtr<Action> mAction;
};
Context(Manager* aManager, nsIThread* aTarget, Action* aInitAction);
Context(Manager* aManager, nsISerialEventTarget* aTarget, Action* aInitAction);
~Context();
void Init(Context* aOldContext);
void Start();
@@ -202,7 +202,7 @@ private:
DoomTargetData();
RefPtr<Manager> mManager;
nsCOMPtr<nsIThread> mTarget;
nsCOMPtr<nsISerialEventTarget> mTarget;
RefPtr<Data> mData;
State mState;
bool mOrphanedData;

22
dom/cache/Manager.cpp vendored
View File

@@ -649,9 +649,9 @@ private:
MOZ_DIAGNOSTIC_ASSERT(!mDBDir);
MOZ_DIAGNOSTIC_ASSERT(!mConn);
MOZ_DIAGNOSTIC_ASSERT(!mTargetThread);
mTargetThread = NS_GetCurrentThread();
MOZ_DIAGNOSTIC_ASSERT(mTargetThread);
MOZ_DIAGNOSTIC_ASSERT(!mTarget);
mTarget = GetCurrentThreadSerialEventTarget();
MOZ_DIAGNOSTIC_ASSERT(mTarget);
// We should be pre-initialized to expect one async completion. This is
// the "manual" completion we call at the end of this method in all
@@ -694,7 +694,7 @@ private:
void
OnAsyncCopyComplete(nsresult aRv)
{
MOZ_ASSERT(mTargetThread == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(mConn);
MOZ_DIAGNOSTIC_ASSERT(mResolver);
MOZ_DIAGNOSTIC_ASSERT(mExpectedAsyncCopyCompletions > 0);
@@ -841,7 +841,7 @@ private:
StartStreamCopy(const QuotaInfo& aQuotaInfo, Entry& aEntry,
StreamId aStreamId, uint32_t* aCopyCountOut)
{
MOZ_ASSERT(mTargetThread == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(aCopyCountOut);
if (IsCanceled()) {
@@ -914,13 +914,13 @@ private:
nsCOMPtr<nsIRunnable> runnable = NewNonOwningRunnableMethod<nsresult>(
this, &CachePutAllAction::OnAsyncCopyComplete, aRv);
MOZ_ALWAYS_SUCCEEDS(
mTargetThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
void
DoResolve(nsresult aRv)
{
MOZ_ASSERT(mTargetThread == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
// DoResolve() must not be called until all async copying has completed.
#ifdef DEBUG
@@ -941,7 +941,7 @@ private:
// Drop our ref to the target thread as we are done with this thread.
// Also makes our thread assertions catch any incorrect method calls
// after resolve.
mTargetThread = nullptr;
mTarget = nullptr;
// Make sure to de-ref the resolver per the Action API contract.
RefPtr<Action::Resolver> resolver;
@@ -963,7 +963,7 @@ private:
RefPtr<Resolver> mResolver;
nsCOMPtr<nsIFile> mDBDir;
nsCOMPtr<mozIStorageConnection> mConn;
nsCOMPtr<nsIThread> mTargetThread;
nsCOMPtr<nsISerialEventTarget> mTarget;
nsresult mAsyncResult;
nsTArray<nsID> mBodyIdWrittenList;
@@ -1783,8 +1783,8 @@ Manager::Init(Manager* aOldManager)
// per Manager now, this lets us cleanly call Factory::Remove() once the
// Context goes away.
RefPtr<Action> setupAction = new SetupAction();
RefPtr<Context> ref = Context::Create(this, mIOThread, setupAction,
oldContext);
RefPtr<Context> ref = Context::Create(this, mIOThread->SerialEventTarget(), setupAction,
oldContext);
mContext = ref;
}

6
dom/cache/PrincipalVerifier.cpp vendored
View File

@@ -67,11 +67,11 @@ PrincipalVerifier::PrincipalVerifier(Listener* aListener,
const PrincipalInfo& aPrincipalInfo)
: mActor(BackgroundParent::GetContentParent(aActor))
, mPrincipalInfo(aPrincipalInfo)
, mInitiatingThread(NS_GetCurrentThread())
, mInitiatingEventTarget(GetCurrentThreadSerialEventTarget())
, mResult(NS_OK)
{
AssertIsOnBackgroundThread();
MOZ_DIAGNOSTIC_ASSERT(mInitiatingThread);
MOZ_DIAGNOSTIC_ASSERT(mInitiatingEventTarget);
MOZ_DIAGNOSTIC_ASSERT(aListener);
mListenerList.AppendElement(aListener);
@@ -203,7 +203,7 @@ PrincipalVerifier::DispatchToInitiatingThread(nsresult aRv)
// This will result in a new CacheStorage object delaying operations until
// shutdown completes and the browser goes away. This is as graceful as
// we can get here.
nsresult rv = mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL);
nsresult rv = mInitiatingEventTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL);
if (NS_FAILED(rv)) {
NS_WARNING("Cache unable to complete principal verification due to shutdown.");
}

2
dom/cache/PrincipalVerifier.h vendored
View File

@@ -64,7 +64,7 @@ private:
RefPtr<ContentParent> mActor;
const mozilla::ipc::PrincipalInfo mPrincipalInfo;
nsCOMPtr<nsIThread> mInitiatingThread;
nsCOMPtr<nsIEventTarget> mInitiatingEventTarget;
nsresult mResult;
RefPtr<ManagerId> mManagerId;

28
dom/cache/ReadStream.cpp vendored
View File

@@ -99,7 +99,7 @@ private:
StreamControl* mControl;
const nsID mId;
nsCOMPtr<nsIThread> mOwningThread;
nsCOMPtr<nsISerialEventTarget> mOwningEventTarget;
enum State
{
@@ -197,7 +197,7 @@ ReadStream::Inner::Inner(StreamControl* aControl, const nsID& aId,
nsIInputStream* aStream)
: mControl(aControl)
, mId(aId)
, mOwningThread(NS_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadSerialEventTarget())
, mState(Open)
, mHasEverBeenRead(false)
, mMutex("dom::cache::ReadStream")
@@ -214,7 +214,7 @@ ReadStream::Inner::Serialize(CacheReadStreamOrVoid* aReadStreamOut,
nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList,
ErrorResult& aRv)
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
*aReadStreamOut = CacheReadStream();
Serialize(&aReadStreamOut->get_CacheReadStream(), aStreamCleanupList, aRv);
@@ -225,7 +225,7 @@ ReadStream::Inner::Serialize(CacheReadStream* aReadStreamOut,
nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList,
ErrorResult& aRv)
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
if (mState != Open) {
@@ -254,28 +254,28 @@ ReadStream::Inner::Serialize(CacheReadStream* aReadStreamOut,
void
ReadStream::Inner::CloseStream()
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
Close();
}
void
ReadStream::Inner::CloseStreamWithoutReporting()
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
Forget();
}
bool
ReadStream::Inner::MatchId(const nsID& aId) const
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
return mId.Equals(aId);
}
bool
ReadStream::Inner::HasEverBeenRead() const
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
return mHasEverBeenRead;
}
@@ -388,14 +388,14 @@ ReadStream::Inner::NoteClosed()
return;
}
if (NS_GetCurrentThread() == mOwningThread) {
if (mOwningEventTarget->IsOnCurrentThread()) {
NoteClosedOnOwningThread();
return;
}
nsCOMPtr<nsIRunnable> runnable = new NoteClosedRunnable(this);
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
void
@@ -406,20 +406,20 @@ ReadStream::Inner::Forget()
return;
}
if (NS_GetCurrentThread() == mOwningThread) {
if (mOwningEventTarget->IsOnCurrentThread()) {
ForgetOnOwningThread();
return;
}
nsCOMPtr<nsIRunnable> runnable = new ForgetRunnable(this);
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
void
ReadStream::Inner::NoteClosedOnOwningThread()
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
// Mark closed and do nothing if we were already closed
if (!mState.compareExchange(Open, Closed)) {
@@ -434,7 +434,7 @@ ReadStream::Inner::NoteClosedOnOwningThread()
void
ReadStream::Inner::ForgetOnOwningThread()
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
// Mark closed and do nothing if we were already closed
if (!mState.compareExchange(Open, Closed)) {

6
dom/canvas/OffscreenCanvas.cpp
View File

@@ -86,10 +86,10 @@ OffscreenCanvas::ClearResources()
mCanvasClient->Clear();
if (mCanvasRenderer) {
nsCOMPtr<nsIThread> activeThread = mCanvasRenderer->GetActiveThread();
MOZ_RELEASE_ASSERT(activeThread, "GFX: failed to get active thread.");
nsCOMPtr<nsISerialEventTarget> activeTarget = mCanvasRenderer->GetActiveThread();
MOZ_RELEASE_ASSERT(activeTarget, "GFX: failed to get active event target.");
bool current;
activeThread->IsOnCurrentThread(&current);
activeTarget->IsOnCurrentThread(&current);
MOZ_RELEASE_ASSERT(current, "GFX: active thread is not current thread.");
mCanvasRenderer->SetCanvasClient(nullptr);
mCanvasRenderer->mContext = nullptr;

13
dom/canvas/WebGLContextLossHandler.cpp
View File

@@ -45,17 +45,16 @@ WebGLContextLossHandler::WebGLContextLossHandler(WebGLContext* webgl)
, mTimerPending(false)
, mShouldRunTimerAgain(false)
#ifdef DEBUG
, mThread(NS_GetCurrentThread())
, mEventTarget(GetCurrentThreadSerialEventTarget())
#endif
{
MOZ_ASSERT(mThread);
MOZ_ASSERT(mEventTarget);
}
WebGLContextLossHandler::~WebGLContextLossHandler()
{
// NS_GetCurrentThread() returns null during shutdown.
const DebugOnly<nsIThread*> callingThread = NS_GetCurrentThread();
MOZ_ASSERT(callingThread == mThread || !callingThread);
const DebugOnly<nsISerialEventTarget*> callingThread = GetCurrentThreadSerialEventTarget();
MOZ_ASSERT(!callingThread || mEventTarget->IsOnCurrentThread());
}
////////////////////
@@ -63,7 +62,7 @@ WebGLContextLossHandler::~WebGLContextLossHandler()
void
WebGLContextLossHandler::RunTimer()
{
MOZ_ASSERT(NS_GetCurrentThread() == mThread);
MOZ_ASSERT(mEventTarget->IsOnCurrentThread());
// If the timer was already running, don't restart it here. Instead,
// wait until the previous call is done, then fire it one more time.
@@ -86,7 +85,7 @@ WebGLContextLossHandler::RunTimer()
void
WebGLContextLossHandler::TimerCallback()
{
MOZ_ASSERT(NS_GetCurrentThread() == mThread);
MOZ_ASSERT(mEventTarget->IsOnCurrentThread());
mTimerPending = false;

2
dom/canvas/WebGLContextLossHandler.h
View File

@@ -22,7 +22,7 @@ class WebGLContextLossHandler final : public SupportsWeakPtr<WebGLContextLossHan
bool mTimerPending; // that it's been discarded, and be canceled 'for our
bool mShouldRunTimerAgain; // convenience'.
#ifdef DEBUG
nsIThread* const mThread;
nsISerialEventTarget* const mEventTarget;
#endif
friend class WatchdogTimerEvent;

8
dom/crypto/WebCryptoTask.cpp
View File

@@ -384,7 +384,7 @@ WebCryptoTask::DispatchWithPromise(Promise* aResultPromise)
}
// Store calling thread
mOriginalThread = NS_GetCurrentThread();
mOriginalEventTarget = GetCurrentThreadSerialEventTarget();
// If we are running on a worker thread we must hold the worker
// alive while we work on the thread pool. Otherwise the worker
@@ -419,7 +419,7 @@ WebCryptoTask::Run()
}
// Back to the original thread, i.e. continue below.
mOriginalThread->Dispatch(this, NS_DISPATCH_NORMAL);
mOriginalEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
return NS_OK;
}
@@ -3729,7 +3729,7 @@ WebCryptoTask::WebCryptoTask()
: CancelableRunnable("WebCryptoTask")
, mEarlyRv(NS_OK)
, mEarlyComplete(false)
, mOriginalThread(nullptr)
, mOriginalEventTarget(nullptr)
, mReleasedNSSResources(false)
, mRv(NS_ERROR_NOT_INITIALIZED)
{
@@ -3745,7 +3745,7 @@ WebCryptoTask::~WebCryptoTask()
}
if (mWorkerHolder) {
NS_ProxyRelease(mOriginalThread, mWorkerHolder.forget());
NS_ProxyRelease(mOriginalEventTarget, mWorkerHolder.forget());
}
}

4
dom/crypto/WebCryptoTask.h
View File

@@ -174,7 +174,7 @@ protected:
virtual ~WebCryptoTask();
bool IsOnOriginalThread() {
return !mOriginalThread || NS_GetCurrentThread() == mOriginalThread;
return !mOriginalEventTarget || mOriginalEventTarget->IsOnCurrentThread();
}
// For things that need to happen on the main thread
@@ -212,7 +212,7 @@ private:
class InternalWorkerHolder;
nsCOMPtr<nsIThread> mOriginalThread;
nsCOMPtr<nsISerialEventTarget> mOriginalEventTarget;
RefPtr<InternalWorkerHolder> mWorkerHolder;
bool mReleasedNSSResources;
nsresult mRv;

2
dom/file/FileReader.cpp
View File

@@ -120,7 +120,7 @@ FileReader::FileReader(nsIGlobalObject* aGlobal,
if (NS_IsMainThread()) {
mTarget = aGlobal->EventTargetFor(TaskCategory::Other);
} else {
mTarget = do_GetCurrentThread();
mTarget = GetCurrentThreadSerialEventTarget();
}
SetDOMStringToNull(mResult);

2
dom/file/MutableBlobStorage.cpp
View File

@@ -371,7 +371,7 @@ MutableBlobStorage::MutableBlobStorage(MutableBlobStorageType aType,
MOZ_ASSERT(NS_IsMainThread());
if (!mEventTarget) {
mEventTarget = do_GetMainThread();
mEventTarget = GetMainThreadEventTarget();
}
MOZ_ASSERT(mEventTarget);

2
dom/file/MutableBlobStreamListener.cpp
View File

@@ -24,7 +24,7 @@ MutableBlobStreamListener::MutableBlobStreamListener(MutableBlobStorage::Mutable
MOZ_ASSERT(aCallback);
if (!mEventTarget) {
mEventTarget = do_GetMainThread();
mEventTarget = GetMainThreadEventTarget();
}
MOZ_ASSERT(mEventTarget);

2
dom/file/ipc/IPCBlobInputStream.cpp
View File

@@ -303,7 +303,7 @@ IPCBlobInputStream::MaybeExecuteCallback(nsIInputStreamCallback* aCallback,
return NS_OK;
}
nsCOMPtr<nsIEventTarget> target = NS_GetCurrentThread();
RefPtr<nsIEventTarget> target = GetCurrentThreadEventTarget();
return asyncStream->AsyncWait(this, 0, 0, target);
}

18
dom/file/ipc/IPCBlobInputStreamChild.cpp
View File

@@ -131,7 +131,7 @@ IPCBlobInputStreamChild::IPCBlobInputStreamChild(const nsID& aID,
, mID(aID)
, mSize(aSize)
, mState(eActive)
, mOwningThread(NS_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadSerialEventTarget())
{
// If we are running in a worker, we need to send a Close() to the parent side
// before the thread is released.
@@ -215,7 +215,7 @@ IPCBlobInputStreamChild::CreateStream()
// The stream is active but maybe it is not running in the DOM-File thread.
// We should migrate it there.
if (mState == eActive &&
!IPCBlobInputStreamThread::IsOnFileThread(mOwningThread)) {
!IPCBlobInputStreamThread::IsOnFileEventTarget(mOwningEventTarget)) {
MOZ_ASSERT(mStreams.IsEmpty());
shouldMigrate = true;
mState = eActiveMigrating;
@@ -249,13 +249,13 @@ IPCBlobInputStreamChild::ForgetStream(IPCBlobInputStream* aStream)
}
}
if (mOwningThread == NS_GetCurrentThread()) {
if (mOwningEventTarget->IsOnCurrentThread()) {
Shutdown();
return;
}
RefPtr<ShutdownRunnable> runnable = new ShutdownRunnable(this);
mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
mOwningEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL);
}
void
@@ -281,13 +281,13 @@ IPCBlobInputStreamChild::StreamNeeded(IPCBlobInputStream* aStream,
MOZ_ASSERT(mState == eActive);
if (mOwningThread == NS_GetCurrentThread()) {
if (mOwningEventTarget->IsOnCurrentThread()) {
SendStreamNeeded();
return;
}
RefPtr<StreamNeededRunnable> runnable = new StreamNeededRunnable(this);
mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
mOwningEventTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
}
mozilla::ipc::IPCResult
@@ -325,11 +325,11 @@ IPCBlobInputStreamChild::Migrated()
if (mWorkerHolder) {
RefPtr<ReleaseWorkerHolderRunnable> runnable =
new ReleaseWorkerHolderRunnable(Move(mWorkerHolder));
mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
mOwningEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL);
}
mOwningThread = NS_GetCurrentThread();
MOZ_ASSERT(IPCBlobInputStreamThread::IsOnFileThread(mOwningThread));
mOwningEventTarget = GetCurrentThreadSerialEventTarget();
MOZ_ASSERT(IPCBlobInputStreamThread::IsOnFileEventTarget(mOwningEventTarget));
// Maybe we have no reasons to keep this actor alive.
if (mStreams.IsEmpty()) {

2
dom/file/ipc/IPCBlobInputStreamChild.h
View File

@@ -108,7 +108,7 @@ private:
};
nsTArray<PendingOperation> mPendingOperations;
nsCOMPtr<nsIThread> mOwningThread;
nsCOMPtr<nsISerialEventTarget> mOwningEventTarget;
UniquePtr<workers::WorkerHolder> mWorkerHolder;
};

6
dom/file/ipc/IPCBlobInputStreamThread.cpp
View File

@@ -91,12 +91,12 @@ NS_IMPL_ISUPPORTS_INHERITED(MigrateActorRunnable, Runnable,
NS_IMPL_ISUPPORTS(IPCBlobInputStreamThread, nsIObserver)
/* static */ bool
IPCBlobInputStreamThread::IsOnFileThread(nsIThread* aThread)
IPCBlobInputStreamThread::IsOnFileEventTarget(nsIEventTarget* aEventTarget)
{
MOZ_ASSERT(aThread);
MOZ_ASSERT(aEventTarget);
mozilla::StaticMutexAutoLock lock(gIPCBlobThreadMutex);
return gIPCBlobThread && aThread == gIPCBlobThread->mThread;
return gIPCBlobThread && aEventTarget == gIPCBlobThread->mThread;
}
/* static */ IPCBlobInputStreamThread*

2
dom/file/ipc/IPCBlobInputStreamThread.h
View File

@@ -23,7 +23,7 @@ public:
NS_DECL_NSIOBSERVER
static bool
IsOnFileThread(nsIThread* aThread);
IsOnFileEventTarget(nsIEventTarget* aEventTarget);
static IPCBlobInputStreamThread*
GetOrCreate();

20
dom/filehandle/ActorsParent.cpp
View File

@@ -371,7 +371,7 @@ private:
class FileHandleOp
{
protected:
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
RefPtr<FileHandle> mFileHandle;
public:
@@ -381,16 +381,16 @@ public:
AssertIsOnOwningThread() const
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
DebugOnly<bool> current;
MOZ_ASSERT(NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)));
MOZ_ASSERT(NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)));
MOZ_ASSERT(current);
}
nsIEventTarget*
OwningThread() const
{
return mOwningThread;
return mOwningEventTarget;
}
void
@@ -411,7 +411,7 @@ public:
protected:
FileHandleOp(FileHandle* aFileHandle)
: mOwningThread(NS_GetCurrentThread())
: mOwningEventTarget(GetCurrentThreadSerialEventTarget())
, mFileHandle(aFileHandle)
{
AssertIsOnOwningThread();
@@ -786,12 +786,12 @@ GetFileHandleThreadPoolFor(FileHandleStorage aStorage)
******************************************************************************/
FileHandleThreadPool::FileHandleThreadPool()
: mOwningThread(NS_GetCurrentThread())
: mOwningEventTarget(GetCurrentThreadSerialEventTarget())
, mShutdownRequested(false)
, mShutdownComplete(false)
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
AssertIsOnOwningThread();
}
@@ -826,10 +826,10 @@ FileHandleThreadPool::Create()
void
FileHandleThreadPool::AssertIsOnOwningThread() const
{
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
bool current;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->IsOnCurrentThread(&current));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->IsOnCurrentThread(&current));
MOZ_ASSERT(current);
}
@@ -2252,7 +2252,7 @@ CopyFileHandleOp::DoFileWork(FileHandle* aFileHandle)
nsCOMPtr<nsIRunnable> runnable =
new ProgressRunnable(this, mOffset, mSize);
mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
mOwningEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL);
} while (true);
MOZ_ASSERT(mOffset == mSize);

2
dom/filehandle/ActorsParent.h
View File

@@ -43,7 +43,7 @@ class FileHandleThreadPool final
struct StoragesCompleteCallback;
nsCOMPtr<nsIThreadPool> mThreadPool;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
nsClassHashtable<nsCStringHashKey, DirectoryInfo> mDirectoryInfos;

2
dom/filesystem/FileSystemRequestParent.cpp
View File

@@ -86,7 +86,7 @@ public:
, mActor(aActor)
, mTask(aTask)
, mPath(aPath)
, mBackgroundEventTarget(NS_GetCurrentThread())
, mBackgroundEventTarget(GetCurrentThreadEventTarget())
{
AssertIsInMainProcess();
AssertIsOnBackgroundThread();

2
dom/filesystem/FileSystemTaskBase.cpp
View File

@@ -237,7 +237,7 @@ FileSystemTaskParentBase::FileSystemTaskParentBase(FileSystemBase* aFileSystem,
: mErrorValue(NS_OK)
, mFileSystem(aFileSystem)
, mRequestParent(aParent)
, mBackgroundEventTarget(NS_GetCurrentThread())
, mBackgroundEventTarget(GetCurrentThreadEventTarget())
{
MOZ_ASSERT(XRE_IsParentProcess(),
"Only call from parent process!");

10
dom/flyweb/HttpServer.cpp
View File

@@ -327,7 +327,7 @@ HttpServer::Connection::Connection(nsISocketTransport* aTransport,
if (mServer->mHttps) {
SetSecurityObserver(true);
} else {
mInput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
mInput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
}
}
@@ -340,7 +340,7 @@ HttpServer::Connection::OnHandshakeDone(nsITLSServerSocket* aServer,
// XXX Verify connection security
SetSecurityObserver(false);
mInput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
mInput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
return NS_OK;
}
@@ -391,7 +391,7 @@ HttpServer::Connection::OnInputStreamReady(nsIAsyncInputStream* aStream)
&numRead);
NS_ENSURE_SUCCESS(rv, rv);
rv = mInput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
rv = mInput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
@@ -862,7 +862,7 @@ HttpServer::Connection::HandleWebSocketResponse(InternalResponse* aResponse)
mState = eRequestLine;
mPendingWebSocketRequest = nullptr;
mInput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
mInput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
QueueResponse(aResponse);
}
@@ -1233,7 +1233,7 @@ HttpServer::Connection::OnOutputStreamReady(nsIAsyncOutputStream* aStream)
buffer.Cut(0, written);
if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
return mOutput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
return mOutput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
}
if (NS_FAILED(rv)) {

7
dom/gamepad/ipc/GamepadEventChannelParent.cpp
View File

@@ -45,7 +45,8 @@ GamepadEventChannelParent::GamepadEventChannelParent()
RefPtr<GamepadPlatformService> service =
GamepadPlatformService::GetParentService();
MOZ_ASSERT(service);
mBackgroundThread = NS_GetCurrentThread();
mBackgroundEventTarget = GetCurrentThreadEventTarget();
service->AddChannelParent(this);
}
@@ -116,8 +117,8 @@ GamepadEventChannelParent::ActorDestroy(ActorDestroyReason aWhy)
void
GamepadEventChannelParent::DispatchUpdateEvent(const GamepadChangeEvent& aEvent)
{
mBackgroundThread->Dispatch(new SendGamepadUpdateRunnable(this, aEvent),
NS_DISPATCH_NORMAL);
mBackgroundEventTarget->Dispatch(new SendGamepadUpdateRunnable(this, aEvent),
NS_DISPATCH_NORMAL);
}
} // namespace dom

10
dom/gamepad/ipc/GamepadEventChannelParent.h
View File

@@ -6,8 +6,8 @@
#ifndef mozilla_dom_GamepadEventChannelParent_h_
#define mozilla_dom_GamepadEventChannelParent_h_
namespace mozilla{
namespace dom{
namespace mozilla {
namespace dom {
class GamepadEventChannelParent final : public PGamepadEventChannelParent
{
@@ -29,10 +29,10 @@ class GamepadEventChannelParent final : public PGamepadEventChannelParent
private:
~GamepadEventChannelParent() {}
bool mHasGamepadListener;
nsCOMPtr<nsIThread> mBackgroundThread;
nsCOMPtr<nsIEventTarget> mBackgroundEventTarget;
};
}// namespace dom
}// namespace mozilla
} // namespace dom
} // namespace mozilla
#endif

12
dom/html/HTMLCanvasElement.cpp
View File

@@ -1375,9 +1375,9 @@ HTMLCanvasElement::OnVisibilityChange()
};
RefPtr<nsIRunnable> runnable = new Runnable(mAsyncCanvasRenderer);
nsCOMPtr<nsIThread> activeThread = mAsyncCanvasRenderer->GetActiveThread();
if (activeThread) {
activeThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL);
nsCOMPtr<nsIEventTarget> activeTarget = mAsyncCanvasRenderer->GetActiveThread();
if (activeTarget) {
activeTarget->Dispatch(runnable, nsIThread::DISPATCH_NORMAL);
}
return;
}
@@ -1417,9 +1417,9 @@ HTMLCanvasElement::OnMemoryPressure()
};
RefPtr<nsIRunnable> runnable = new Runnable(mAsyncCanvasRenderer);
nsCOMPtr<nsIThread> activeThread = mAsyncCanvasRenderer->GetActiveThread();
if (activeThread) {
activeThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL);
nsCOMPtr<nsIEventTarget> activeTarget = mAsyncCanvasRenderer->GetActiveThread();
if (activeTarget) {
activeTarget->Dispatch(runnable, nsIThread::DISPATCH_NORMAL);
}
return;
}

12
dom/indexedDB/ActorsChild.cpp
View File

@@ -1491,7 +1491,7 @@ class BackgroundRequestChild::PreprocessHelper final
typedef std::pair<nsCOMPtr<nsIInputStream>,
nsCOMPtr<nsIInputStream>> StreamPair;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
nsTArray<StreamPair> mStreamPairs;
nsTArray<RefPtr<JS::WasmModule>> mModuleSet;
BackgroundRequestChild* mActor;
@@ -1509,7 +1509,7 @@ class BackgroundRequestChild::PreprocessHelper final
public:
PreprocessHelper(uint32_t aModuleSetIndex, BackgroundRequestChild* aActor)
: CancelableRunnable("indexedDB::BackgroundRequestChild::PreprocessHelper")
, mOwningThread(aActor->GetActorEventTarget())
, mOwningEventTarget(aActor->GetActorEventTarget())
, mActor(aActor)
, mCurrentBytecodeFileDesc(nullptr)
, mCurrentCompiledFileDesc(nullptr)
@@ -1524,10 +1524,10 @@ public:
bool
IsOnOwningThread() const
{
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
bool current;
return NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)) && current;
return NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)) && current;
}
void
@@ -3569,11 +3569,11 @@ PreprocessHelper::ContinueWithStatus(nsresult aStatus)
MOZ_ASSERT(mResultCode == NS_OK);
mResultCode = aStatus;
eventTarget = mOwningThread;
eventTarget = mOwningEventTarget;
} else if (mStreamPairs.IsEmpty()) {
// If all the streams have been processed, we can go back to the owning
// thread.
eventTarget = mOwningThread;
eventTarget = mOwningEventTarget;
} else {
// Continue the processing.
eventTarget = mTaskQueueEventTarget;

54
dom/indexedDB/ActorsParent.cpp
View File

@@ -5570,7 +5570,7 @@ class ConnectionPool::ConnectionRunnable
{
protected:
DatabaseInfo* mDatabaseInfo;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
explicit
ConnectionRunnable(DatabaseInfo* aDatabaseInfo);
@@ -5713,7 +5713,7 @@ class ConnectionPool::FinishCallbackWrapper final
{
RefPtr<ConnectionPool> mConnectionPool;
RefPtr<FinishCallback> mCallback;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
uint64_t mTransactionId;
bool mHasRunOnce;
@@ -5911,7 +5911,7 @@ protected:
typedef nsDataHashtable<nsUint64HashKey, bool> UniqueIndexTable;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
const nsID mBackgroundChildLoggingId;
const uint64_t mLoggingSerialNumber;
nsresult mResultCode;
@@ -5926,10 +5926,10 @@ public:
bool
IsOnOwningThread() const
{
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
bool current;
return NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)) && current;
return NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)) && current;
}
void
@@ -5994,7 +5994,7 @@ public:
protected:
DatabaseOperationBase(const nsID& aBackgroundChildLoggingId,
uint64_t aLoggingSerialNumber)
: mOwningThread(NS_GetCurrentThread())
: mOwningEventTarget(GetCurrentThreadEventTarget())
, mBackgroundChildLoggingId(aBackgroundChildLoggingId)
, mLoggingSerialNumber(aLoggingSerialNumber)
, mResultCode(NS_OK)
@@ -13184,13 +13184,13 @@ ConnectionPool::CloseDatabaseWhenIdleInternal(const nsACString& aDatabaseId)
ConnectionPool::
ConnectionRunnable::ConnectionRunnable(DatabaseInfo* aDatabaseInfo)
: mDatabaseInfo(aDatabaseInfo)
, mOwningThread(do_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadEventTarget())
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(aDatabaseInfo);
MOZ_ASSERT(aDatabaseInfo->mConnectionPool);
aDatabaseInfo->mConnectionPool->AssertIsOnOwningThread();
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
}
NS_IMPL_ISUPPORTS_INHERITED0(ConnectionPool::IdleConnectionRunnable,
@@ -13204,7 +13204,7 @@ IdleConnectionRunnable::Run()
MOZ_ASSERT(!mDatabaseInfo->mIdle);
nsCOMPtr<nsIEventTarget> owningThread;
mOwningThread.swap(owningThread);
mOwningEventTarget.swap(owningThread);
if (owningThread) {
mDatabaseInfo->AssertIsOnConnectionThread();
@@ -13250,11 +13250,11 @@ CloseConnectionRunnable::Run()
"ConnectionPool::CloseConnectionRunnable::Run",
js::ProfileEntry::Category::STORAGE);
if (mOwningThread) {
if (mOwningEventTarget) {
MOZ_ASSERT(mDatabaseInfo->mClosing);
nsCOMPtr<nsIEventTarget> owningThread;
mOwningThread.swap(owningThread);
mOwningEventTarget.swap(owningThread);
// The connection could be null if EnsureConnection() didn't run or was not
// successful in TransactionDatabaseOperationBase::RunOnConnectionThread().
@@ -13351,14 +13351,14 @@ FinishCallbackWrapper::FinishCallbackWrapper(ConnectionPool* aConnectionPool,
FinishCallback* aCallback)
: mConnectionPool(aConnectionPool)
, mCallback(aCallback)
, mOwningThread(do_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadEventTarget())
, mTransactionId(aTransactionId)
, mHasRunOnce(false)
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(aConnectionPool);
MOZ_ASSERT(aCallback);
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
}
ConnectionPool::
@@ -13376,7 +13376,7 @@ FinishCallbackWrapper::Run()
{
MOZ_ASSERT(mConnectionPool);
MOZ_ASSERT(mCallback);
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
PROFILER_LABEL("IndexedDB",
"ConnectionPool::FinishCallbackWrapper::Run",
@@ -13390,7 +13390,7 @@ FinishCallbackWrapper::Run()
Unused << mCallback->Run();
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@@ -18122,7 +18122,7 @@ QuotaClient::StartIdleMaintenance()
AssertIsOnBackgroundThread();
MOZ_ASSERT(!mShutdownRequested);
mBackgroundThread = do_GetCurrentThread();
mBackgroundThread = GetCurrentThreadEventTarget();
RefPtr<Maintenance> maintenance = new Maintenance(this);
@@ -21014,14 +21014,14 @@ FactoryOp::Open()
if (permission == PermissionRequestBase::kPermissionPrompt) {
mState = State::PermissionChallenge;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
MOZ_ASSERT(permission == PermissionRequestBase::kPermissionAllowed);
mState = State::FinishOpen;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@@ -21078,7 +21078,7 @@ FactoryOp::RetryCheckPermission()
MOZ_ASSERT(permission == PermissionRequestBase::kPermissionAllowed);
mState = State::FinishOpen;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@@ -21626,7 +21626,7 @@ FactoryOp::Run()
if (IsOnOwningThread()) {
SendResults();
} else {
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
}
@@ -21913,7 +21913,7 @@ OpenDatabaseOp::DoDatabaseWork()
State::SendingResults :
State::BeginVersionChange;
rv = mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL);
rv = mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
@@ -23198,7 +23198,7 @@ DeleteDatabaseOp::DoDatabaseWork()
mState = State::SendingResults;
}
rv = mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL);
rv = mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
@@ -23582,7 +23582,7 @@ VersionChangeOp::RunOnIOThread()
mDeleteDatabaseOp->mOrigin,
databaseName);
rv = mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL);
rv = mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
@@ -23675,7 +23675,7 @@ VersionChangeOp::Run()
mResultCode = rv;
}
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
return NS_OK;
@@ -23837,7 +23837,7 @@ TransactionDatabaseOperationBase::RunOnConnectionThread()
mInternalState = InternalState::SendingResults;
}
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
bool
@@ -24359,7 +24359,7 @@ DatabaseOp::Run()
// thread.
mState = State::SendingResults;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
return NS_OK;
@@ -24480,7 +24480,7 @@ CreateFileOp::DoDatabaseWork()
// thread.
mState = State::SendingResults;
rv = mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL);
rv = mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}

2
dom/indexedDB/IDBFactory.cpp
View File

@@ -301,7 +301,7 @@ IDBFactory::CreateForJSInternal(JSContext* aCx,
factory->mOwningObject = aOwningObject;
mozilla::HoldJSObjects(factory.get());
factory->mEventTarget = NS_IsMainThread() ?
SystemGroup::EventTargetFor(TaskCategory::Other) : NS_GetCurrentThread();
SystemGroup::EventTargetFor(TaskCategory::Other) : GetCurrentThreadEventTarget();
factory->mInnerWindowID = aInnerWindowID;
factory.forget(aFactory);

11
dom/network/TCPSocket.cpp
View File

@@ -200,10 +200,8 @@ TCPSocket::CreateStream()
nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(mSocketInputStream);
NS_ENSURE_TRUE(asyncStream, NS_ERROR_NOT_AVAILABLE);
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
rv = asyncStream->AsyncWait(this, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0, mainThread);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
rv = asyncStream->AsyncWait(this, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0, mainTarget);
NS_ENSURE_SUCCESS(rv, rv);
if (mUseArrayBuffers) {
@@ -248,9 +246,8 @@ TCPSocket::InitWithUnconnectedTransport(nsISocketTransport* aTransport)
MOZ_ASSERT(XRE_GetProcessType() != GeckoProcessType_Content);
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
mTransport->SetEventSink(this, mainThread);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
mTransport->SetEventSink(this, mainTarget);
nsresult rv = CreateStream();
NS_ENSURE_SUCCESS(rv, rv);

4
dom/network/UDPSocketParent.cpp
View File

@@ -241,13 +241,13 @@ static void CheckSTSThread()
mozilla::ipc::IPCResult
UDPSocketParent::RecvConnect(const UDPAddressInfo& aAddressInfo)
{
nsCOMPtr<nsIEventTarget> thread(NS_GetCurrentThread());
nsCOMPtr<nsIEventTarget> target = GetCurrentThreadEventTarget();
Unused <<
NS_WARN_IF(NS_FAILED(GetSTSThread()->Dispatch(WrapRunnable(
RefPtr<UDPSocketParent>(this),
&UDPSocketParent::DoConnect,
mSocket,
thread,
target,
aAddressInfo),
NS_DISPATCH_NORMAL)));
return IPC_OK();

6
dom/notification/Notification.cpp
View File

@@ -2724,9 +2724,9 @@ Notification::DispatchToMainThread(already_AddRefed<nsIRunnable>&& aRunnable)
return target->Dispatch(Move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
}
}
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
MOZ_ASSERT(mainThread);
return mainThread->Dispatch(Move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
MOZ_ASSERT(mainTarget);
return mainTarget->Dispatch(Move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
}
} // namespace dom

12
dom/presentation/PresentationTCPSessionTransport.cpp
View File

@@ -180,10 +180,8 @@ PresentationTCPSessionTransport::BuildTCPReceiverTransport(nsIPresentationChanne
return rv;
}
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
mTransport->SetEventSink(this, mainThread);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
mTransport->SetEventSink(this, mainTarget);
rv = CreateStream();
if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -220,10 +218,8 @@ PresentationTCPSessionTransport::CreateStream()
return NS_ERROR_NOT_AVAILABLE;
}
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
rv = asyncStream->AsyncWait(this, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0, mainThread);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
rv = asyncStream->AsyncWait(this, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0, mainTarget);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}

2
dom/quota/ActorsChild.cpp
View File

@@ -22,7 +22,7 @@ namespace quota {
QuotaChild::QuotaChild(QuotaManagerService* aService)
: mService(aService)
#ifdef DEBUG
, mOwningThread(NS_GetCurrentThread())
, mOwningThread(GetCurrentThreadEventTarget())
#endif
{
AssertIsOnOwningThread();

6
dom/quota/ActorsParent.cpp
View File

@@ -789,7 +789,7 @@ public:
protected:
explicit OriginOperationBase(
nsIEventTarget* aOwningThread = NS_GetCurrentThread())
nsIEventTarget* aOwningThread = GetCurrentThreadEventTarget())
: BackgroundThreadObject(aOwningThread)
, mResultCode(NS_OK)
, mState(State_Initial)
@@ -1452,7 +1452,7 @@ IsTempMetadata(const nsAString& aFileName)
} // namespace
BackgroundThreadObject::BackgroundThreadObject()
: mOwningThread(NS_GetCurrentThread())
: mOwningThread(GetCurrentThreadEventTarget())
{
AssertIsOnOwningThread();
}
@@ -2734,7 +2734,7 @@ CreateRunnable::GetNextState(nsCOMPtr<nsIEventTarget>& aThread) -> State
aThread = mOwningThread;
return State::CreatingManager;
case State::CreatingManager:
aThread = do_GetMainThread();
aThread = GetMainThreadEventTarget();
return State::RegisteringObserver;
case State::RegisteringObserver:
aThread = mOwningThread;

6
dom/workers/RuntimeService.cpp
View File

@@ -2959,12 +2959,12 @@ WorkerThreadPrimaryRunnable::Run()
mWorkerPrivate = nullptr;
// Now recycle this thread.
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
MOZ_ASSERT(mainThread);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
MOZ_ASSERT(mainTarget);
RefPtr<FinishedRunnable> finishedRunnable =
new FinishedRunnable(mThread.forget());
MOZ_ALWAYS_SUCCEEDS(mainThread->Dispatch(finishedRunnable,
MOZ_ALWAYS_SUCCEEDS(mainTarget->Dispatch(finishedRunnable,
NS_DISPATCH_NORMAL));
profiler_unregister_thread();

8
dom/workers/ServiceWorkerManagerParent.cpp
View File

@@ -125,14 +125,14 @@ public:
: mContentParent(aParent)
, mPrincipalInfo(aPrincipalInfo)
, mCallback(aCallback)
, mBackgroundThread(NS_GetCurrentThread())
, mBackgroundEventTarget(GetCurrentThreadEventTarget())
{
AssertIsInMainProcess();
AssertIsOnBackgroundThread();
MOZ_ASSERT(mContentParent);
MOZ_ASSERT(mCallback);
MOZ_ASSERT(mBackgroundThread);
MOZ_ASSERT(mBackgroundEventTarget);
}
NS_IMETHOD Run() override
@@ -140,7 +140,7 @@ public:
if (NS_IsMainThread()) {
mContentParent = nullptr;
mBackgroundThread->Dispatch(this, NS_DISPATCH_NORMAL);
mBackgroundEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
return NS_OK;
}
@@ -155,7 +155,7 @@ private:
RefPtr<ContentParent> mContentParent;
PrincipalInfo mPrincipalInfo;
RefPtr<Runnable> mCallback;
nsCOMPtr<nsIThread> mBackgroundThread;
nsCOMPtr<nsIEventTarget> mBackgroundEventTarget;
};
} // namespace

6
dom/workers/ServiceWorkerRegistrar.cpp
View File

@@ -707,7 +707,7 @@ class ServiceWorkerRegistrarSaveDataRunnable final : public Runnable
{
public:
ServiceWorkerRegistrarSaveDataRunnable()
: mThread(do_GetCurrentThread())
: mEventTarget(GetCurrentThreadEventTarget())
{
AssertIsOnBackgroundThread();
}
@@ -722,7 +722,7 @@ public:
RefPtr<Runnable> runnable =
NewRunnableMethod(service, &ServiceWorkerRegistrar::DataSaved);
nsresult rv = mThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
nsresult rv = mEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
@@ -731,7 +731,7 @@ public:
}
private:
nsCOMPtr<nsIThread> mThread;
nsCOMPtr<nsIEventTarget> mEventTarget;
};
void

8
dom/workers/WorkerPrivate.cpp
View File

@@ -4442,7 +4442,7 @@ WorkerPrivate::WorkerPrivate(WorkerPrivate* aParent,
, mPRThread(nullptr)
, mNumHoldersPreventingShutdownStart(0)
, mDebuggerEventLoopLevel(0)
, mMainThreadEventTarget(do_GetMainThread())
, mMainThreadEventTarget(GetMainThreadEventTarget())
, mWorkerControlEventTarget(new WorkerControlEventTarget(this))
, mErrorHandlerRecursionCount(0)
, mNextTimeoutId(1)
@@ -4485,10 +4485,8 @@ WorkerPrivate::WorkerPrivate(WorkerPrivate* aParent,
target = GetWindow() ? GetWindow()->EventTargetFor(TaskCategory::Worker) : nullptr;
if (!target) {
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
MOZ_DIAGNOSTIC_ASSERT(mainThread);
target = mainThread;
target = GetMainThreadEventTarget();
MOZ_DIAGNOSTIC_ASSERT(target);
}
// Throttle events to the main thread using a ThrottledEventQueue specific to