Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-25 20:01:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1875800 - Add name support to WorkerRunnable. r=dom-worker-reviewers,asuth,smaug

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D199228
This commit is contained in:
Jens Stutte 2024-01-24 16:00:26 +00:00
parent 11f1ad9e30
commit a2709c2f0e
23 changed files with 182 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dom/base/EventSource.cpp
View File

@ -1825,7 +1825,7 @@ class WorkerRunnableDispatcher final : public WorkerRunnable {
WorkerRunnableDispatcher(RefPtr<EventSourceImpl>&& aImpl,
WorkerPrivate* aWorkerPrivate,
already_AddRefed<nsIRunnable> aEvent)
: WorkerRunnable(aWorkerPrivate, WorkerThread),
: WorkerRunnable(aWorkerPrivate, "WorkerRunnableDispatcher"),
mEventSourceImpl(std::move(aImpl)),
mEvent(std::move(aEvent)) {}

3
dom/broadcastchannel/BroadcastChannel.cpp
View File

@ -96,7 +96,8 @@ class TeardownRunnableOnWorker final : public WorkerControlRunnable,
public:
TeardownRunnableOnWorker(WorkerPrivate* aWorkerPrivate,
BroadcastChannelChild* aActor)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "TeardownRunnableOnWorker",
WorkerThread),
TeardownRunnable(aActor) {}
bool WorkerRun(JSContext*, WorkerPrivate*) override {

7
dom/canvas/ImageBitmap.cpp
View File

@ -1578,7 +1578,8 @@ class FulfillImageBitmapPromiseWorkerTask final
public:
FulfillImageBitmapPromiseWorkerTask(Promise* aPromise,
ImageBitmap* aImageBitmap)
: WorkerSameThreadRunnable(GetCurrentThreadWorkerPrivate()),
: WorkerSameThreadRunnable(GetCurrentThreadWorkerPrivate(),
"FulfillImageBitmapPromiseWorkerTask"),
FulfillImageBitmapPromise(aPromise, aImageBitmap) {}
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
@ -1699,13 +1700,13 @@ class CreateImageBitmapFromBlob final : public DiscardableRunnable,
NS_IMPL_ISUPPORTS_INHERITED(CreateImageBitmapFromBlob, DiscardableRunnable,
imgIContainerCallback, nsIInputStreamCallback)
class CreateImageBitmapFromBlobRunnable : public WorkerRunnable {
class CreateImageBitmapFromBlobRunnable final : public WorkerRunnable {
public:
explicit CreateImageBitmapFromBlobRunnable(WorkerPrivate* aWorkerPrivate,
CreateImageBitmapFromBlob* aTask,
layers::Image* aImage,
nsresult aStatus)
: WorkerRunnable(aWorkerPrivate),
: WorkerRunnable(aWorkerPrivate, "CreateImageBitmapFromBlobRunnable"),
mTask(aTask),
mImage(aImage),
mStatus(aStatus) {}

3
dom/canvas/OffscreenCanvasDisplayHelper.cpp
View File

@ -105,7 +105,8 @@ void OffscreenCanvasDisplayHelper::FlushForDisplay() {
public:
FlushWorkerRunnable(WorkerPrivate* aWorkerPrivate,
OffscreenCanvasDisplayHelper* aDisplayHelper)
: WorkerRunnable(aWorkerPrivate), mDisplayHelper(aDisplayHelper) {}
: WorkerRunnable(aWorkerPrivate, "FlushWorkerRunnable"),
mDisplayHelper(aDisplayHelper) {}
bool WorkerRun(JSContext*, WorkerPrivate*) override {
// The OffscreenCanvas can only be freed on the worker thread, so we

4
dom/network/ConnectionWorker.cpp
View File

@ -109,7 +109,7 @@ class ShutdownRunnable : public WorkerMainThreadRunnable {
}
};
class NotifyRunnable : public WorkerRunnable {
class NotifyRunnable final : public WorkerRunnable {
private:
RefPtr<ConnectionProxy> mProxy;
@ -120,7 +120,7 @@ class NotifyRunnable : public WorkerRunnable {
public:
NotifyRunnable(WorkerPrivate* aWorkerPrivate, ConnectionProxy* aProxy,
ConnectionType aType, bool aIsWifi, uint32_t aDHCPGateway)
: WorkerRunnable(aWorkerPrivate),
: WorkerRunnable(aWorkerPrivate, "NotifyRunnable"),
mProxy(aProxy),
mConnectionType(aType),
mIsWifi(aIsWifi),

3
dom/performance/PerformanceStorageWorker.cpp
View File

@ -39,7 +39,8 @@ class PerformanceEntryAdder final : public WorkerControlRunnable {
PerformanceEntryAdder(WorkerPrivate* aWorkerPrivate,
PerformanceStorageWorker* aStorage,
UniquePtr<PerformanceProxyData>&& aData)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "PerformanceEntryAdder",
WorkerThread),
mStorage(aStorage),
mData(std::move(aData)) {}

5
dom/promise/Promise.cpp
View File

@ -772,11 +772,12 @@ void Promise::MaybeRejectWithClone(JSContext* aCx,
// A WorkerRunnable to resolve/reject the Promise on the worker thread.
// Calling thread MUST hold PromiseWorkerProxy's mutex before creating this.
class PromiseWorkerProxyRunnable : public WorkerRunnable {
class PromiseWorkerProxyRunnable final : public WorkerRunnable {
public:
PromiseWorkerProxyRunnable(PromiseWorkerProxy* aPromiseWorkerProxy,
PromiseWorkerProxy::RunCallbackFunc aFunc)
: WorkerRunnable(aPromiseWorkerProxy->GetWorkerPrivate(), WorkerThread),
: WorkerRunnable(aPromiseWorkerProxy->GetWorkerPrivate(),
"PromiseWorkerProxyRunnable", WorkerThread),
mPromiseWorkerProxy(aPromiseWorkerProxy),
mFunc(aFunc) {
MOZ_ASSERT(NS_IsMainThread());

4
dom/push/PushManager.cpp
View File

@ -102,7 +102,7 @@ class GetSubscriptionResultRunnable final : public WorkerRunnable {
nsTArray<uint8_t>&& aRawP256dhKey,
nsTArray<uint8_t>&& aAuthSecret,
nsTArray<uint8_t>&& aAppServerKey)
: WorkerRunnable(aWorkerPrivate),
: WorkerRunnable(aWorkerPrivate, "GetSubscriptionResultRunnable"),
mProxy(std::move(aProxy)),
mStatus(aStatus),
mEndpoint(aEndpoint),
@ -298,7 +298,7 @@ class PermissionResultRunnable final : public WorkerRunnable {
public:
PermissionResultRunnable(PromiseWorkerProxy* aProxy, nsresult aStatus,
PermissionState aState)
: WorkerRunnable(aProxy->GetWorkerPrivate()),
: WorkerRunnable(aProxy->GetWorkerPrivate(), "PermissionResultRunnable"),
mProxy(aProxy),
mStatus(aStatus),
mState(aState) {

2
dom/push/PushSubscription.cpp
View File

@ -59,7 +59,7 @@ class UnsubscribeResultRunnable final : public WorkerRunnable {
UnsubscribeResultRunnable(WorkerPrivate* aWorkerPrivate,
RefPtr<PromiseWorkerProxy>&& aProxy,
nsresult aStatus, bool aSuccess)
: WorkerRunnable(aWorkerPrivate),
: WorkerRunnable(aWorkerPrivate, "UnsubscribeResultRunnable"),
mProxy(std::move(aProxy)),
mStatus(aStatus),
mSuccess(aSuccess) {

3
dom/quota/StorageManager.cpp
View File

@ -124,7 +124,8 @@ class RequestResolver::FinishWorkerRunnable final : public WorkerRunnable {
public:
explicit FinishWorkerRunnable(RequestResolver* aResolver)
: WorkerRunnable(aResolver->mProxy->GetWorkerPrivate()),
: WorkerRunnable(aResolver->mProxy->GetWorkerPrivate(),
"RequestResolver::FinishWorkerRunnable"),
mResolver(aResolver) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aResolver);

2
dom/webscheduling/WebTaskSchedulerWorker.cpp
View File

@ -12,7 +12,7 @@ namespace mozilla::dom {
WebTaskWorkerRunnable::WebTaskWorkerRunnable(
WorkerPrivate* aWorkerPrivate, WebTaskSchedulerWorker* aSchedulerWorker)
: WorkerSameThreadRunnable(aWorkerPrivate),
: WorkerSameThreadRunnable(aWorkerPrivate, "WebTaskWorkerRunnable"),
mSchedulerWorker(aSchedulerWorker) {
MOZ_ASSERT(mSchedulerWorker);
}

2
dom/webscheduling/WebTaskSchedulerWorker.h
View File

@ -17,7 +17,7 @@
namespace mozilla::dom {
class WebTaskWorkerRunnable : public WorkerSameThreadRunnable {
class WebTaskWorkerRunnable final : public WorkerSameThreadRunnable {
public:
WebTaskWorkerRunnable(WorkerPrivate* aWorkerPrivate,
WebTaskSchedulerWorker* aSchedulerWorker);

3
dom/websocket/WebSocket.cpp
View File

@ -2781,7 +2781,8 @@ class WorkerRunnableDispatcher final : public WorkerRunnable {
WorkerRunnableDispatcher(WebSocketImpl* aImpl,
ThreadSafeWorkerRef* aWorkerRef,
already_AddRefed<nsIRunnable> aEvent)
: WorkerRunnable(aWorkerRef->Private(), WorkerThread),
: WorkerRunnable(aWorkerRef->Private(), "WorkerRunnableDispatcher",
WorkerThread),
mWebSocketImpl(aImpl),
mEvent(std::move(aEvent)) {}

8
dom/workers/RuntimeService.cpp
View File

@ -602,7 +602,8 @@ class JSDispatchableRunnable final : public WorkerRunnable {
public:
JSDispatchableRunnable(WorkerPrivate* aWorkerPrivate,
JS::Dispatchable* aDispatchable)
: WorkerRunnable(aWorkerPrivate, WorkerRunnable::WorkerThread),
: WorkerRunnable(aWorkerPrivate, "JSDispatchableRunnable",
WorkerRunnable::WorkerThread),
mDispatchable(aDispatchable) {
MOZ_ASSERT(mDispatchable);
}
@ -1457,10 +1458,11 @@ void RuntimeService::Shutdown() {
namespace {
class DumpCrashInfoRunnable : public WorkerControlRunnable {
class DumpCrashInfoRunnable final : public WorkerControlRunnable {
public:
explicit DumpCrashInfoRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "DumpCrashInfoRunnable",
WorkerThread),
mMonitor("DumpCrashInfoRunnable::mMonitor") {}
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {

3
dom/workers/WorkerDocumentListener.cpp
View File

@ -55,7 +55,8 @@ void WorkerDocumentListener::OnVisible(bool aVisible) {
class VisibleRunnable final : public WorkerRunnable {
public:
VisibleRunnable(WorkerPrivate* aWorkerPrivate, bool aVisible)
: WorkerRunnable(aWorkerPrivate), mVisible(aVisible) {}
: WorkerRunnable(aWorkerPrivate, "VisibleRunnable"),
mVisible(aVisible) {}
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) {
WorkerGlobalScope* scope = aWorkerPrivate->GlobalScope();

3
dom/workers/WorkerEventTarget.cpp
View File

@ -34,7 +34,8 @@ class WrappedControlRunnable final : public WorkerControlRunnable {
public:
WrappedControlRunnable(WorkerPrivate* aWorkerPrivate,
nsCOMPtr<nsIRunnable>&& aInner)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "WrappedControlRunnable",
WorkerThread),
mInner(std::move(aInner)) {}
virtual bool PreDispatch(WorkerPrivate* aWorkerPrivate) override {

104
dom/workers/WorkerPrivate.cpp
View File

@ -186,7 +186,7 @@ class ExternalRunnableWrapper final : public WorkerRunnable {
public:
ExternalRunnableWrapper(WorkerPrivate* aWorkerPrivate,
nsIRunnable* aWrappedRunnable)
: WorkerRunnable(aWorkerPrivate, WorkerThread),
: WorkerRunnable(aWorkerPrivate, "ExternalRunnableWrapper", WorkerThread),
mWrappedRunnable(aWrappedRunnable) {
MOZ_ASSERT(aWorkerPrivate);
MOZ_ASSERT(aWrappedRunnable);
@ -249,7 +249,8 @@ class WorkerFinishedRunnable final : public WorkerControlRunnable {
public:
WorkerFinishedRunnable(WorkerPrivate* aWorkerPrivate,
WorkerPrivate* aFinishedWorker)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "WorkerFinishedRunnable",
WorkerThread),
mFinishedWorker(aFinishedWorker) {
aFinishedWorker->IncreaseWorkerFinishedRunnableCount();
}
@ -443,7 +444,8 @@ class NotifyRunnable final : public WorkerControlRunnable {
public:
NotifyRunnable(WorkerPrivate* aWorkerPrivate, WorkerStatus aStatus)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread), mStatus(aStatus) {
: WorkerControlRunnable(aWorkerPrivate, "NotifyRunnable", WorkerThread),
mStatus(aStatus) {
MOZ_ASSERT(aStatus == Closing || aStatus == Canceling ||
aStatus == Killing);
}
@ -471,7 +473,7 @@ class NotifyRunnable final : public WorkerControlRunnable {
class FreezeRunnable final : public WorkerControlRunnable {
public:
explicit FreezeRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread) {}
: WorkerControlRunnable(aWorkerPrivate, "FreezeRunnable", WorkerThread) {}
private:
virtual bool WorkerRun(JSContext* aCx,
@ -483,7 +485,7 @@ class FreezeRunnable final : public WorkerControlRunnable {
class ThawRunnable final : public WorkerControlRunnable {
public:
explicit ThawRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread) {}
: WorkerControlRunnable(aWorkerPrivate, "ThawRunnable", WorkerThread) {}
private:
virtual bool WorkerRun(JSContext* aCx,
@ -497,7 +499,9 @@ class PropagateStorageAccessPermissionGrantedRunnable final
public:
explicit PropagateStorageAccessPermissionGrantedRunnable(
WorkerPrivate* aWorkerPrivate)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread) {}
: WorkerControlRunnable(aWorkerPrivate,
"PropagateStorageAccessPermissionGrantedRunnable",
WorkerThread) {}
private:
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
@ -538,7 +542,8 @@ class ReportErrorToConsoleRunnable final : public WorkerRunnable {
ReportErrorToConsoleRunnable(WorkerPrivate* aWorkerPrivate,
const char* aMessage,
const nsTArray<nsString>& aParams)
: WorkerRunnable(aWorkerPrivate, ParentThread),
: WorkerRunnable(aWorkerPrivate, "ReportErrorToConsoleRunnable",
ParentThread),
mMessage(aMessage),
mParams(aParams.Clone()) {}
@ -559,17 +564,17 @@ class ReportErrorToConsoleRunnable final : public WorkerRunnable {
}
};
class TimerRunnable final : public WorkerRunnable,
public nsITimerCallback,
public nsINamed {
class RunExpiredTimoutsRunnable final : public WorkerRunnable,
public nsITimerCallback {
public:
NS_DECL_ISUPPORTS_INHERITED
explicit TimerRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerRunnable(aWorkerPrivate, WorkerThread) {}
explicit RunExpiredTimoutsRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerRunnable(aWorkerPrivate, "RunExpiredTimoutsRunnable",
WorkerThread) {}
private:
~TimerRunnable() = default;
~RunExpiredTimoutsRunnable() = default;
virtual bool PreDispatch(WorkerPrivate* aWorkerPrivate) override {
// Silence bad assertions.
@ -591,24 +596,20 @@ class TimerRunnable final : public WorkerRunnable,
NS_IMETHOD
Notify(nsITimer* aTimer) override { return Run(); }
NS_IMETHOD
GetName(nsACString& aName) override {
aName.AssignLiteral("TimerRunnable");
return NS_OK;
}
};
NS_IMPL_ISUPPORTS_INHERITED(TimerRunnable, WorkerRunnable, nsITimerCallback,
nsINamed)
NS_IMPL_ISUPPORTS_INHERITED(RunExpiredTimoutsRunnable, WorkerRunnable,
nsITimerCallback)
class DebuggerImmediateRunnable : public WorkerRunnable {
class DebuggerImmediateRunnable final : public WorkerRunnable {
RefPtr<dom::Function> mHandler;
public:
explicit DebuggerImmediateRunnable(WorkerPrivate* aWorkerPrivate,
dom::Function& aHandler)
: WorkerRunnable(aWorkerPrivate, WorkerThread), mHandler(&aHandler) {}
: WorkerRunnable(aWorkerPrivate, "DebuggerImmediateRunnable",
WorkerThread),
mHandler(&aHandler) {}
private:
virtual bool IsDebuggerRunnable() const override { return true; }
@ -668,7 +669,8 @@ class UpdateContextOptionsRunnable final : public WorkerControlRunnable {
public:
UpdateContextOptionsRunnable(WorkerPrivate* aWorkerPrivate,
const JS::ContextOptions& aContextOptions)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "UpdateContextOptionsRunnable",
WorkerThread),
mContextOptions(aContextOptions) {}
private:
@ -685,7 +687,8 @@ class UpdateLanguagesRunnable final : public WorkerRunnable {
public:
UpdateLanguagesRunnable(WorkerPrivate* aWorkerPrivate,
const nsTArray<nsString>& aLanguages)
: WorkerRunnable(aWorkerPrivate), mLanguages(aLanguages.Clone()) {}
: WorkerRunnable(aWorkerPrivate, "UpdateLanguagesRunnable"),
mLanguages(aLanguages.Clone()) {}
virtual bool WorkerRun(JSContext* aCx,
WorkerPrivate* aWorkerPrivate) override {
@ -703,7 +706,9 @@ class UpdateJSWorkerMemoryParameterRunnable final
UpdateJSWorkerMemoryParameterRunnable(WorkerPrivate* aWorkerPrivate,
JSGCParamKey aKey,
Maybe<uint32_t> aValue)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate,
"UpdateJSWorkerMemoryParameterRunnable",
WorkerThread),
mValue(aValue),
mKey(aKey) {}
@ -723,7 +728,8 @@ class UpdateGCZealRunnable final : public WorkerControlRunnable {
public:
UpdateGCZealRunnable(WorkerPrivate* aWorkerPrivate, uint8_t aGCZeal,
uint32_t aFrequency)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "UpdateGCZealRunnable",
WorkerThread),
mGCZeal(aGCZeal),
mFrequency(aFrequency) {}
@ -741,7 +747,9 @@ class SetLowMemoryStateRunnable final : public WorkerControlRunnable {
public:
SetLowMemoryStateRunnable(WorkerPrivate* aWorkerPrivate, bool aState)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread), mState(aState) {}
: WorkerControlRunnable(aWorkerPrivate, "SetLowMemoryStateRunnable",
WorkerThread),
mState(aState) {}
private:
virtual bool WorkerRun(JSContext* aCx,
@ -758,7 +766,8 @@ class GarbageCollectRunnable final : public WorkerControlRunnable {
public:
GarbageCollectRunnable(WorkerPrivate* aWorkerPrivate, bool aShrinking,
bool aCollectChildren)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "GarbageCollectRunnable",
WorkerThread),
mShrinking(aShrinking),
mCollectChildren(aCollectChildren) {}
@ -787,12 +796,13 @@ class GarbageCollectRunnable final : public WorkerControlRunnable {
}
};
class CycleCollectRunnable : public WorkerControlRunnable {
class CycleCollectRunnable final : public WorkerControlRunnable {
bool mCollectChildren;
public:
CycleCollectRunnable(WorkerPrivate* aWorkerPrivate, bool aCollectChildren)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "CycleCollectRunnable",
WorkerThread),
mCollectChildren(aCollectChildren) {}
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
@ -801,10 +811,11 @@ class CycleCollectRunnable : public WorkerControlRunnable {
}
};
class OfflineStatusChangeRunnable : public WorkerRunnable {
class OfflineStatusChangeRunnable final : public WorkerRunnable {
public:
OfflineStatusChangeRunnable(WorkerPrivate* aWorkerPrivate, bool aIsOffline)
: WorkerRunnable(aWorkerPrivate), mIsOffline(aIsOffline) {}
: WorkerRunnable(aWorkerPrivate, "OfflineStatusChangeRunnable"),
mIsOffline(aIsOffline) {}
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
aWorkerPrivate->OfflineStatusChangeEventInternal(mIsOffline);
@ -815,10 +826,11 @@ class OfflineStatusChangeRunnable : public WorkerRunnable {
bool mIsOffline;
};
class MemoryPressureRunnable : public WorkerControlRunnable {
class MemoryPressureRunnable final : public WorkerControlRunnable {
public:
explicit MemoryPressureRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread) {}
: WorkerControlRunnable(aWorkerPrivate, "MemoryPressureRunnable",
WorkerThread) {}
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
aWorkerPrivate->MemoryPressureInternal();
@ -862,7 +874,9 @@ class CancelingWithTimeoutOnParentRunnable final
: public WorkerControlRunnable {
public:
explicit CancelingWithTimeoutOnParentRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerControlRunnable(aWorkerPrivate, ParentThread) {}
: WorkerControlRunnable(aWorkerPrivate,
"CancelingWithTimeoutOnParentRunnable",
ParentThread) {}
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
aWorkerPrivate->AssertIsOnParentThread();
@ -3344,8 +3358,11 @@ void WorkerPrivate::DoRunLoop(JSContext* aCx) {
debuggerRunnablesPending = !mDebuggerQueue.IsEmpty();
}
MOZ_ASSERT(runnable);
static_cast<nsIRunnable*>(runnable)->Run();
{
MOZ_ASSERT(runnable);
AUTO_PROFILE_FOLLOWING_RUNNABLE(runnable);
static_cast<nsIRunnable*>(runnable)->Run();
}
runnable->Release();
CycleCollectedJSContext* ccjs = CycleCollectedJSContext::Get();
@ -3989,9 +4006,12 @@ WorkerPrivate::ProcessAllControlRunnablesLocked() {
MutexAutoUnlock unlock(mMutex);
MOZ_ASSERT(event);
if (NS_FAILED(static_cast<nsIRunnable*>(event)->Run())) {
result = ProcessAllControlRunnablesResult::Abort;
{
MOZ_ASSERT(event);
AUTO_PROFILE_FOLLOWING_RUNNABLE(event);
if (NS_FAILED(static_cast<nsIRunnable*>(event)->Run())) {
result = ProcessAllControlRunnablesResult::Abort;
}
}
if (result == ProcessAllControlRunnablesResult::Nothing) {
@ -5198,7 +5218,7 @@ int32_t WorkerPrivate::SetTimeout(JSContext* aCx, TimeoutHandler* aHandler,
return 0;
}
data->mTimerRunnable = new TimerRunnable(this);
data->mTimerRunnable = new RunExpiredTimoutsRunnable(this);
}
if (!data->mTimerRunning) {

3
dom/workers/WorkerRef.cpp
View File

@ -20,7 +20,8 @@ class ReleaseRefControlRunnable final : public WorkerControlRunnable {
public:
ReleaseRefControlRunnable(WorkerPrivate* aWorkerPrivate,
already_AddRefed<StrongWorkerRef> aRef)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread),
: WorkerControlRunnable(aWorkerPrivate, "ReleaseRefControlRunnable",
WorkerThread),
mRef(std::move(aRef)) {
MOZ_ASSERT(mRef);
}

35
dom/workers/WorkerRunnable.cpp
View File

@ -53,9 +53,13 @@ const nsIID kWorkerRunnableIID = {
} // namespace
#ifdef DEBUG
WorkerRunnable::WorkerRunnable(WorkerPrivate* aWorkerPrivate, Target aTarget)
WorkerRunnable::WorkerRunnable(WorkerPrivate* aWorkerPrivate, const char* aName,
Target aTarget)
: mWorkerPrivate(aWorkerPrivate),
mTarget(aTarget),
# ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
mName(aName),
# endif
mCallingCancelWithinRun(false) {
LOG(("WorkerRunnable::WorkerRunnable [%p]", this));
MOZ_ASSERT(aWorkerPrivate);
@ -191,8 +195,23 @@ WorkerRunnable* WorkerRunnable::FromRunnable(nsIRunnable* aRunnable) {
NS_IMPL_ADDREF(WorkerRunnable)
NS_IMPL_RELEASE(WorkerRunnable)
#ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
NS_IMETHODIMP
WorkerRunnable::GetName(nsACString& aName) {
if (mName) {
aName.AssignASCII(mName);
} else {
aName.Truncate();
}
return NS_OK;
}
#endif
NS_INTERFACE_MAP_BEGIN(WorkerRunnable)
NS_INTERFACE_MAP_ENTRY(nsIRunnable)
#ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
NS_INTERFACE_MAP_ENTRY(nsINamed)
#endif
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIRunnable)
// kWorkerRunnableIID is special in that it does not AddRef its result.
if (aIID.Equals(kWorkerRunnableIID)) {
@ -378,8 +397,9 @@ void WorkerDebuggerRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate,
bool aDispatchResult) {}
WorkerSyncRunnable::WorkerSyncRunnable(WorkerPrivate* aWorkerPrivate,
nsIEventTarget* aSyncLoopTarget)
: WorkerRunnable(aWorkerPrivate, WorkerThread),
nsIEventTarget* aSyncLoopTarget,
const char* aName)
: WorkerRunnable(aWorkerPrivate, aName, WorkerThread),
mSyncLoopTarget(aSyncLoopTarget) {
#ifdef DEBUG
if (mSyncLoopTarget) {
@ -389,8 +409,9 @@ WorkerSyncRunnable::WorkerSyncRunnable(WorkerPrivate* aWorkerPrivate,
}
WorkerSyncRunnable::WorkerSyncRunnable(
WorkerPrivate* aWorkerPrivate, nsCOMPtr<nsIEventTarget>&& aSyncLoopTarget)
: WorkerRunnable(aWorkerPrivate, WorkerThread),
WorkerPrivate* aWorkerPrivate, nsCOMPtr<nsIEventTarget>&& aSyncLoopTarget,
const char* aName)
: WorkerRunnable(aWorkerPrivate, aName, WorkerThread),
mSyncLoopTarget(std::move(aSyncLoopTarget)) {
#ifdef DEBUG
if (mSyncLoopTarget) {
@ -461,8 +482,8 @@ void MainThreadStopSyncLoopRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate,
#ifdef DEBUG
WorkerControlRunnable::WorkerControlRunnable(WorkerPrivate* aWorkerPrivate,
Target aTarget)
: WorkerRunnable(aWorkerPrivate, aTarget) {
const char* aName, Target aTarget)
: WorkerRunnable(aWorkerPrivate, aName, aTarget) {
MOZ_ASSERT(aWorkerPrivate);
}
#endif

72
dom/workers/WorkerRunnable.h
View File

@ -34,7 +34,12 @@ namespace dom {
class WorkerPrivate;
// Use this runnable to communicate from the worker to its parent or vice-versa.
class WorkerRunnable : public nsIRunnable {
class WorkerRunnable : public nsIRunnable
#ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
,
public nsINamed
#endif
{
public:
enum Target {
// Target the main thread for top-level workers, otherwise target the
@ -52,6 +57,10 @@ class WorkerRunnable : public nsIRunnable {
// See above.
Target mTarget;
#ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
const char* mName = nullptr;
#endif
private:
// Whether or not Cancel() is currently being called from inside the Run()
// method. Avoids infinite recursion when a subclass calls Run() from inside
@ -60,6 +69,9 @@ class WorkerRunnable : public nsIRunnable {
public:
NS_DECL_THREADSAFE_ISUPPORTS
#ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
NS_DECL_NSINAMED
#endif
virtual nsresult Cancel();
@ -81,12 +93,17 @@ class WorkerRunnable : public nsIRunnable {
static WorkerRunnable* FromRunnable(nsIRunnable* aRunnable);
protected:
WorkerRunnable(WorkerPrivate* aWorkerPrivate, Target aTarget = WorkerThread)
WorkerRunnable(WorkerPrivate* aWorkerPrivate,
const char* aName = "WorkerRunnable",
Target aTarget = WorkerThread)
#ifdef DEBUG
;
#else
: mWorkerPrivate(aWorkerPrivate),
mTarget(aTarget),
# ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
mName(aName),
# endif
mCallingCancelWithinRun(false) {
}
#endif
@ -161,8 +178,9 @@ class WorkerRunnable : public nsIRunnable {
// This runnable is used to send a message to a worker debugger.
class WorkerDebuggerRunnable : public WorkerRunnable {
protected:
explicit WorkerDebuggerRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerRunnable(aWorkerPrivate, WorkerThread) {}
explicit WorkerDebuggerRunnable(WorkerPrivate* aWorkerPrivate,
const char* aName = "WorkerDebuggerRunnable")
: WorkerRunnable(aWorkerPrivate, aName, WorkerThread) {}
virtual ~WorkerDebuggerRunnable() = default;
@ -187,10 +205,12 @@ class WorkerSyncRunnable : public WorkerRunnable {
// Passing null for aSyncLoopTarget is allowed and will result in the behavior
// of a normal WorkerRunnable.
WorkerSyncRunnable(WorkerPrivate* aWorkerPrivate,
nsIEventTarget* aSyncLoopTarget);
nsIEventTarget* aSyncLoopTarget,
const char* aName = "WorkerSyncRunnable");
WorkerSyncRunnable(WorkerPrivate* aWorkerPrivate,
nsCOMPtr<nsIEventTarget>&& aSyncLoopTarget);
nsCOMPtr<nsIEventTarget>&& aSyncLoopTarget,
const char* aName = "WorkerSyncRunnable");
virtual ~WorkerSyncRunnable();
@ -204,15 +224,17 @@ class MainThreadWorkerSyncRunnable : public WorkerSyncRunnable {
protected:
// Passing null for aSyncLoopTarget is allowed and will result in the behavior
// of a normal WorkerRunnable.
MainThreadWorkerSyncRunnable(WorkerPrivate* aWorkerPrivate,
nsIEventTarget* aSyncLoopTarget)
: WorkerSyncRunnable(aWorkerPrivate, aSyncLoopTarget) {
MainThreadWorkerSyncRunnable(
WorkerPrivate* aWorkerPrivate, nsIEventTarget* aSyncLoopTarget,
const char* aName = "MainThreadWorkerSyncRunnable")
: WorkerSyncRunnable(aWorkerPrivate, aSyncLoopTarget, aName) {
AssertIsOnMainThread();
}
MainThreadWorkerSyncRunnable(WorkerPrivate* aWorkerPrivate,
nsCOMPtr<nsIEventTarget>&& aSyncLoopTarget)
: WorkerSyncRunnable(aWorkerPrivate, std::move(aSyncLoopTarget)) {
MainThreadWorkerSyncRunnable(
WorkerPrivate* aWorkerPrivate, nsCOMPtr<nsIEventTarget>&& aSyncLoopTarget,
const char* aName = "MainThreadWorkerSyncRunnable")
: WorkerSyncRunnable(aWorkerPrivate, std::move(aSyncLoopTarget), aName) {
AssertIsOnMainThread();
}
@ -236,11 +258,13 @@ class WorkerControlRunnable : public WorkerRunnable {
friend class WorkerPrivate;
protected:
WorkerControlRunnable(WorkerPrivate* aWorkerPrivate, Target aTarget)
WorkerControlRunnable(WorkerPrivate* aWorkerPrivate,
const char* aName = "WorkerControlRunnable",
Target aTarget = WorkerThread)
#ifdef DEBUG
;
#else
: WorkerRunnable(aWorkerPrivate, aTarget) {
: WorkerRunnable(aWorkerPrivate, aName, aTarget) {
}
#endif
@ -262,8 +286,10 @@ class WorkerControlRunnable : public WorkerRunnable {
// thread.
class MainThreadWorkerRunnable : public WorkerRunnable {
protected:
explicit MainThreadWorkerRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerRunnable(aWorkerPrivate, WorkerThread) {
explicit MainThreadWorkerRunnable(
WorkerPrivate* aWorkerPrivate,
const char* aName = "MainThreadWorkerRunnable")
: WorkerRunnable(aWorkerPrivate, aName, WorkerThread) {
AssertIsOnMainThread();
}
@ -284,8 +310,10 @@ class MainThreadWorkerRunnable : public WorkerRunnable {
// thread.
class MainThreadWorkerControlRunnable : public WorkerControlRunnable {
protected:
explicit MainThreadWorkerControlRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerControlRunnable(aWorkerPrivate, WorkerThread) {}
explicit MainThreadWorkerControlRunnable(
WorkerPrivate* aWorkerPrivate,
const char* aName = "MainThreadWorkerControlRunnable")
: WorkerControlRunnable(aWorkerPrivate, aName, WorkerThread) {}
virtual ~MainThreadWorkerControlRunnable() = default;
@ -307,8 +335,10 @@ class MainThreadWorkerControlRunnable : public WorkerControlRunnable {
// a WorkerSameThreadRunnable keeps the Worker from being GCed.
class WorkerSameThreadRunnable : public WorkerRunnable {
protected:
explicit WorkerSameThreadRunnable(WorkerPrivate* aWorkerPrivate)
: WorkerRunnable(aWorkerPrivate, WorkerThread) {}
explicit WorkerSameThreadRunnable(
WorkerPrivate* aWorkerPrivate,
const char* aName = "WorkerSameThreadRunnable")
: WorkerRunnable(aWorkerPrivate, aName, WorkerThread) {}
virtual ~WorkerSameThreadRunnable() = default;
@ -444,7 +474,7 @@ class WorkerDebuggeeRunnable : public WorkerRunnable {
protected:
WorkerDebuggeeRunnable(WorkerPrivate* aWorkerPrivate,
Target aTarget = ParentThread)
: WorkerRunnable(aWorkerPrivate, aTarget) {}
: WorkerRunnable(aWorkerPrivate, "WorkerDebuggeeRunnable", aTarget) {}
bool PreDispatch(WorkerPrivate* aWorkerPrivate) override;

2
dom/workers/remoteworkers/RemoteWorkerChild.cpp
View File

@ -111,7 +111,7 @@ class MessagePortIdentifierRunnable final : public WorkerRunnable {
MessagePortIdentifierRunnable(WorkerPrivate* aWorkerPrivate,
RemoteWorkerChild* aActor,
const MessagePortIdentifier& aPortIdentifier)
: WorkerRunnable(aWorkerPrivate),
: WorkerRunnable(aWorkerPrivate, "MessagePortIdentifierRunnable"),
mActor(aActor),
mPortIdentifier(aPortIdentifier) {}

3
layout/style/FontFaceSetWorkerImpl.cpp
View File

@ -181,7 +181,8 @@ void FontFaceSetWorkerImpl::DispatchToOwningThread(
public:
FontFaceSetWorkerRunnable(WorkerPrivate* aWorkerPrivate,
std::function<void()>&& aFunc)
: WorkerRunnable(aWorkerPrivate), mFunc(std::move(aFunc)) {}
: WorkerRunnable(aWorkerPrivate, "FontFaceSetWorkerRunnable"),
mFunc(std::move(aFunc)) {}
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
mFunc();

4
toolkit/components/extensions/webidl-api/ExtensionEventListener.h
View File

@ -120,7 +120,7 @@ class ExtensionEventListener final : public mozIExtensionEventListener {
// A WorkerRunnable subclass used to call an ExtensionEventListener
// in the thread that owns the dom::Function wrapped by the
// ExtensionEventListener class.
class ExtensionListenerCallWorkerRunnable : public dom::WorkerRunnable {
class ExtensionListenerCallWorkerRunnable final : public dom::WorkerRunnable {
friend class ExtensionListenerCallPromiseResultHandler;
public:
@ -134,7 +134,7 @@ class ExtensionListenerCallWorkerRunnable : public dom::WorkerRunnable {
ListenerCallOptions* aCallOptions,
RefPtr<dom::Promise> aPromiseRetval = nullptr)
: WorkerRunnable(aExtensionEventListener->GetWorkerPrivate(),
WorkerThread),
"ExtensionListenerCallWorkerRunnable", WorkerThread),
mListener(aExtensionEventListener),
mArgsHolder(std::move(aArgsHolder)),
mPromiseResult(std::move(aPromiseRetval)),