☠☠ backed out by 4472d2623ece ☠ ☠ | |
author | Bill McCloskey <billm@mozilla.com> |
Mon, 12 Jun 2017 12:34:10 -0700 | |
changeset 416384 | 4f6302a98ae41ff2d57c768996d1edbb0afda73a |
parent 416383 | ce7c27a7a91e7e6a0ecea5e29c3b485fbfac4a84 |
child 416385 | 328c356c0bcd1c53b4270cd84db5ac7a27d49fea |
push id | 1517 |
push user | jlorenzo@mozilla.com |
push date | Thu, 14 Sep 2017 16:50:54 +0000 |
treeherder | mozilla-release@3b41fd564418 [default view] [failures only] |
perfherder | [talos] [build metrics] [platform microbench] (compared to previous push) |
reviewers | froydnj |
bugs | 1372405 |
milestone | 56.0a1 |
first release with | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
last release without | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
--- a/accessible/generic/Accessible.cpp +++ b/accessible/generic/Accessible.cpp @@ -1794,18 +1794,23 @@ Accessible::GetNativeInterface(void** aN } void Accessible::DoCommand(nsIContent *aContent, uint32_t aActionIndex) { class Runnable final : public mozilla::Runnable { public: - Runnable(Accessible* aAcc, nsIContent* aContent, uint32_t aIdx) : - mAcc(aAcc), mContent(aContent), mIdx(aIdx) { } + Runnable(Accessible* aAcc, nsIContent* aContent, uint32_t aIdx) + : mozilla::Runnable("Runnable") + , mAcc(aAcc) + , mContent(aContent) + , mIdx(aIdx) + { + } NS_IMETHOD Run() override { if (mAcc) mAcc->DispatchClickEvent(mContent, mIdx); return NS_OK; }
--- a/accessible/generic/DocAccessible.cpp +++ b/accessible/generic/DocAccessible.cpp @@ -644,19 +644,22 @@ DocAccessible::ScrollPositionDidChange(n const uint32_t kScrollPosCheckWait = 50; if (mScrollWatchTimer) { mScrollWatchTimer->SetDelay(kScrollPosCheckWait); // Create new timer, to avoid leaks } else { mScrollWatchTimer = do_CreateInstance("@mozilla.org/timer;1"); if (mScrollWatchTimer) { NS_ADDREF_THIS(); // Kung fu death grip - mScrollWatchTimer->InitWithFuncCallback(ScrollTimerCallback, this, - kScrollPosCheckWait, - nsITimer::TYPE_REPEATING_SLACK); + mScrollWatchTimer->InitWithNamedFuncCallback( + ScrollTimerCallback, + this, + kScrollPosCheckWait, + nsITimer::TYPE_REPEATING_SLACK, + "a11y::DocAccessible::ScrollPositionDidChange"); } } mScrollPositionChangedTicks = 1; } //////////////////////////////////////////////////////////////////////////////// // nsIObserver
--- a/accessible/ipc/win/HandlerProvider.cpp +++ b/accessible/ipc/win/HandlerProvider.cpp @@ -90,17 +90,18 @@ HandlerProvider::GetAndSerializePayload( MOZ_ASSERT(mscom::IsCurrentThreadMTA()); if (mSerializer) { return; } IA2Payload payload{}; - if (!mscom::InvokeOnMainThread(this, &HandlerProvider::BuildIA2Data, + if (!mscom::InvokeOnMainThread("HandlerProvider::BuildIA2Data", + this, &HandlerProvider::BuildIA2Data, &payload.mData) || !payload.mData.mUniqueId) { return; } // But we set mGeckoBackChannel on the current thread which resides in the // MTA. This is important to ensure that COM always invokes // IGeckoBackChannel methods in an MTA background thread. @@ -231,31 +232,33 @@ HandlerProvider::put_HandlerControl(long MOZ_ASSERT(mscom::IsCurrentThreadMTA()); if (!aCtrl) { return E_INVALIDARG; } auto ptrProxy = mscom::ToProxyUniquePtr(aCtrl); - if (!mscom::InvokeOnMainThread(this, + if (!mscom::InvokeOnMainThread("HandlerProvider::SetHandlerControlOnMainThread", + this, &HandlerProvider::SetHandlerControlOnMainThread, static_cast<DWORD>(aPid), Move(ptrProxy))) { return E_FAIL; } return S_OK; } HRESULT HandlerProvider::Refresh(IA2Data* aOutData) { MOZ_ASSERT(mscom::IsCurrentThreadMTA()); - if (!mscom::InvokeOnMainThread(this, &HandlerProvider::BuildIA2Data, + if (!mscom::InvokeOnMainThread("HandlerProvider::BuildIA2Data", + this, &HandlerProvider::BuildIA2Data, aOutData)) { return E_FAIL; } return S_OK; } } // namespace a11y
--- a/accessible/windows/msaa/AccessibleWrap.cpp +++ b/accessible/windows/msaa/AccessibleWrap.cpp @@ -836,17 +836,18 @@ AccessibleWrap::accSelect( if (flagsSelect & SELFLAG_TAKEFOCUS) { if (XRE_IsContentProcess()) { // In this case we might have been invoked while the IPC MessageChannel is // waiting on a sync reply. We cannot dispatch additional IPC while that // is happening, so we dispatch TakeFocus from the main thread to // guarantee that we are outside any IPC. nsCOMPtr<nsIRunnable> runnable = - mozilla::NewRunnableMethod(this, &Accessible::TakeFocus); + mozilla::NewRunnableMethod("Accessible::TakeFocus", + this, &Accessible::TakeFocus); NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL); return S_OK; } TakeFocus(); return S_OK; } if (flagsSelect & SELFLAG_TAKESELECTION) {
--- a/accessible/windows/msaa/LazyInstantiator.cpp +++ b/accessible/windows/msaa/LazyInstantiator.cpp @@ -246,17 +246,18 @@ LazyInstantiator::ShouldInstantiate(cons } */ #if defined(MOZ_TELEMETRY_REPORTING) if (!mTelemetryThread) { // Call GatherTelemetry on a background thread because it does I/O on // the executable file to retrieve version information. nsCOMPtr<nsIRunnable> runnable( - NewRunnableMethod<nsCOMPtr<nsIFile>>(this, + NewRunnableMethod<nsCOMPtr<nsIFile>>("LazyInstantiator::GatherTelemetry", + this, &LazyInstantiator::GatherTelemetry, clientExe)); NS_NewThread(getter_AddRefs(mTelemetryThread), runnable); } #endif // defined(MOZ_TELEMETRY_REPORTING) return true; } @@ -322,17 +323,19 @@ LazyInstantiator::GatherTelemetry(nsIFil nsAutoString value; nsresult rv = aClientExe->GetLeafName(value); if (NS_SUCCEEDED(rv)) { AppendVersionInfo(aClientExe, value); } // Now that we've (possibly) obtained version info, send the resulting // string back to the main thread to accumulate in telemetry. - NS_DispatchToMainThread(NewNonOwningRunnableMethod<nsString>(this, + NS_DispatchToMainThread(NewNonOwningRunnableMethod<nsString>( + "LazyInstantiator::AccumulateTelemetry", + this, &LazyInstantiator::AccumulateTelemetry, value)); } void LazyInstantiator::AccumulateTelemetry(const nsString& aValue) { MOZ_ASSERT(NS_IsMainThread());
--- a/accessible/xpcom/xpcAccessibilityService.cpp +++ b/accessible/xpcom/xpcAccessibilityService.cpp @@ -74,18 +74,22 @@ xpcAccessibilityService::Release(void) // When ref count goes down to 1 (held internally as a static reference), // it means that there are no more external references to the // xpcAccessibilityService and we can attempt to shut down acceessiblity // service. if (count == 1 && !mShutdownTimer) { mShutdownTimer = do_CreateInstance(NS_TIMER_CONTRACTID); if (mShutdownTimer) { - mShutdownTimer->InitWithFuncCallback(ShutdownCallback, this, 100, - nsITimer::TYPE_ONE_SHOT); + mShutdownTimer->InitWithNamedFuncCallback( + ShutdownCallback, + this, + 100, + nsITimer::TYPE_ONE_SHOT, + "xpcAccessibilityService::Release"); } } return count; } NS_IMPL_QUERY_INTERFACE(xpcAccessibilityService, nsIAccessibilityService, nsIAccessibleRetrieval)
--- a/docshell/base/nsDocShell.cpp +++ b/docshell/base/nsDocShell.cpp @@ -449,19 +449,22 @@ nsresult nsPingListener::StartTimeout(DocGroup* aDocGroup) { NS_ENSURE_ARG(aDocGroup); nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID); timer->SetTarget(aDocGroup->EventTargetFor(TaskCategory::Network)); if (timer) { - nsresult rv = timer->InitWithFuncCallback(OnPingTimeout, mLoadGroup, - PING_TIMEOUT, - nsITimer::TYPE_ONE_SHOT); + nsresult rv = + timer->InitWithNamedFuncCallback(OnPingTimeout, + mLoadGroup, + PING_TIMEOUT, + nsITimer::TYPE_ONE_SHOT, + "nsPingListener::StartTimeout"); if (NS_SUCCEEDED(rv)) { mTimer = timer; return NS_OK; } } return NS_ERROR_OUT_OF_MEMORY; } @@ -1762,20 +1765,22 @@ nsDocShell::DispatchToTabGroup(const cha RefPtr<mozilla::dom::TabGroup> tabGroup = win->TabGroup(); return tabGroup->Dispatch(aName, aCategory, runnable.forget()); } NS_IMETHODIMP nsDocShell::DispatchLocationChangeEvent() { - return DispatchToTabGroup("nsDocShell::FireDummyOnLocationChange", - TaskCategory::Other, - NewRunnableMethod(this, - &nsDocShell::FireDummyOnLocationChange)); + return DispatchToTabGroup( + "nsDocShell::FireDummyOnLocationChange", + TaskCategory::Other, + NewRunnableMethod("nsDocShell::FireDummyOnLocationChange", + this, + &nsDocShell::FireDummyOnLocationChange)); } bool nsDocShell::MaybeInitTiming() { if (mTiming && !mBlankTiming) { return false; } @@ -9639,23 +9644,30 @@ class InternalLoadEvent : public Runnabl public: InternalLoadEvent(nsDocShell* aDocShell, nsIURI* aURI, nsIURI* aOriginalURI, Maybe<nsCOMPtr<nsIURI>> const& aResultPrincipalURI, bool aLoadReplace, nsIURI* aReferrer, uint32_t aReferrerPolicy, nsIPrincipal* aTriggeringPrincipal, - nsIPrincipal* aPrincipalToInherit, uint32_t aFlags, - const char* aTypeHint, nsIInputStream* aPostData, - nsIInputStream* aHeadersData, uint32_t aLoadType, - nsISHEntry* aSHEntry, bool aFirstParty, - const nsAString& aSrcdoc, nsIDocShell* aSourceDocShell, - nsIURI* aBaseURI, bool aCheckForPrerender) - : mSrcdoc(aSrcdoc) + nsIPrincipal* aPrincipalToInherit, + uint32_t aFlags, + const char* aTypeHint, + nsIInputStream* aPostData, + nsIInputStream* aHeadersData, + uint32_t aLoadType, + nsISHEntry* aSHEntry, + bool aFirstParty, + const nsAString& aSrcdoc, + nsIDocShell* aSourceDocShell, + nsIURI* aBaseURI, + bool aCheckForPrerender) + : mozilla::Runnable("InternalLoadEvent") + , mSrcdoc(aSrcdoc) , mDocShell(aDocShell) , mURI(aURI) , mOriginalURI(aOriginalURI) , mResultPrincipalURI(aResultPrincipalURI) , mLoadReplace(aLoadReplace) , mReferrer(aReferrer) , mReferrerPolicy(aReferrerPolicy) , mTriggeringPrincipal(aTriggeringPrincipal) @@ -14035,17 +14047,18 @@ OnLinkClickEvent::OnLinkClickEvent(nsDoc nsIURI* aURI, const char16_t* aTargetSpec, const nsAString& aFileName, nsIInputStream* aPostDataStream, nsIInputStream* aHeadersDataStream, bool aNoOpenerImplied, bool aIsTrusted, nsIPrincipal* aTriggeringPrincipal) - : mHandler(aHandler) + : mozilla::Runnable("OnLinkClickEvent") + , mHandler(aHandler) , mURI(aURI) , mTargetSpec(aTargetSpec) , mFileName(aFileName) , mPostDataStream(aPostDataStream) , mHeadersDataStream(aHeadersDataStream) , mContent(aContent) , mPopupState(mHandler->mScriptGlobal->GetPopupControlState()) , mNoOpenerImplied(aNoOpenerImplied)
--- a/docshell/base/nsDocShell.h +++ b/docshell/base/nsDocShell.h @@ -772,17 +772,21 @@ protected: } public: // Event type dispatched by RestorePresentation class RestorePresentationEvent : public mozilla::Runnable { public: NS_DECL_NSIRUNNABLE - explicit RestorePresentationEvent(nsDocShell* aDs) : mDocShell(aDs) {} + explicit RestorePresentationEvent(nsDocShell* aDs) + : mozilla::Runnable("nsDocShell::RestorePresentationEvent") + , mDocShell(aDs) + { + } void Revoke() { mDocShell = nullptr; } private: RefPtr<nsDocShell> mDocShell; }; protected: bool JustStartedNetworkLoad();
--- a/docshell/base/nsDocShellTreeOwner.cpp +++ b/docshell/base/nsDocShellTreeOwner.cpp @@ -1255,20 +1255,22 @@ ChromeTooltipListener::MouseMove(nsIDOME if (eventTarget) { mPossibleTooltipNode = do_QueryInterface(eventTarget); nsCOMPtr<nsIGlobalObject> global(eventTarget->GetOwnerGlobal()); if (global) { mTooltipTimer->SetTarget(global->EventTargetFor(TaskCategory::UI)); } } if (mPossibleTooltipNode) { - nsresult rv = mTooltipTimer->InitWithFuncCallback( - sTooltipCallback, this, + nsresult rv = mTooltipTimer->InitWithNamedFuncCallback( + sTooltipCallback, + this, LookAndFeel::GetInt(LookAndFeel::eIntID_TooltipDelay, 500), - nsITimer::TYPE_ONE_SHOT); + nsITimer::TYPE_ONE_SHOT, + "ChromeTooltipListener::MouseMove"); if (NS_FAILED(rv)) { mPossibleTooltipNode = nullptr; } } } else { NS_WARNING("Could not create a timer for tooltip tracking"); } } else {
--- a/docshell/shistory/nsSHEntryShared.cpp +++ b/docshell/shistory/nsSHEntryShared.cpp @@ -180,17 +180,18 @@ nsSHEntryShared::RemoveFromBFCacheSync() return NS_OK; } class DestroyViewerEvent : public mozilla::Runnable { public: DestroyViewerEvent(nsIContentViewer* aViewer, nsIDocument* aDocument) - : mViewer(aViewer) + : mozilla::Runnable("DestroyViewerEvent") + , mViewer(aViewer) , mDocument(aDocument) { } NS_IMETHOD Run() override { if (mViewer) { mViewer->Destroy();
--- a/dom/animation/Animation.cpp +++ b/dom/animation/Animation.cpp @@ -1448,17 +1448,19 @@ void Animation::DoFinishNotification(SyncNotifyFlag aSyncNotifyFlag) { CycleCollectedJSContext* context = CycleCollectedJSContext::Get(); if (aSyncNotifyFlag == SyncNotifyFlag::Sync) { DoFinishNotificationImmediately(); } else if (!mFinishNotificationTask.IsPending()) { RefPtr<nsRunnableMethod<Animation>> runnable = - NewRunnableMethod(this, &Animation::DoFinishNotificationImmediately); + NewRunnableMethod("dom::Animation::DoFinishNotificationImmediately", + this, + &Animation::DoFinishNotificationImmediately); context->DispatchToMicroTask(do_AddRef(runnable)); mFinishNotificationTask = runnable.forget(); } } void Animation::ResetFinishedPromise() {
--- a/dom/asmjscache/AsmJSCache.cpp +++ b/dom/asmjscache/AsmJSCache.cpp @@ -237,21 +237,22 @@ EvictEntries(nsIFile* aDirectory, const // FileDescriptorHolder owns a file descriptor and its memory mapping. // FileDescriptorHolder is derived by two runnable classes (that is, // (Parent|Child)Runnable. class FileDescriptorHolder : public Runnable { public: FileDescriptorHolder() - : mQuotaObject(nullptr), - mFileSize(INT64_MIN), - mFileDesc(nullptr), - mFileMap(nullptr), - mMappedMemory(nullptr) + : Runnable("dom::asmjscache::FileDescriptorHolder") + , mQuotaObject(nullptr) + , mFileSize(INT64_MIN) + , mFileDesc(nullptr) + , mFileMap(nullptr) + , mMappedMemory(nullptr) { } ~FileDescriptorHolder() override { // These resources should have already been released by Finish(). MOZ_ASSERT(!mQuotaObject); MOZ_ASSERT(!mMappedMemory); MOZ_ASSERT(!mFileMap);
--- a/dom/audiochannel/AudioChannelService.cpp +++ b/dom/audiochannel/AudioChannelService.cpp @@ -80,19 +80,21 @@ public: private: const uint64_t mWindowID; const bool mActive; }; class AudioPlaybackRunnable final : public Runnable { public: - AudioPlaybackRunnable(nsPIDOMWindowOuter* aWindow, bool aActive, + AudioPlaybackRunnable(nsPIDOMWindowOuter* aWindow, + bool aActive, AudioChannelService::AudibleChangedReasons aReason) - : mWindow(aWindow) + : mozilla::Runnable("AudioPlaybackRunnable") + , mWindow(aWindow) , mActive(aActive) , mReason(aReason) {} NS_IMETHOD Run() override { nsCOMPtr<nsIObserverService> observerService = services::GetObserverService(); @@ -869,28 +871,29 @@ AudioChannelService::AudioChannelWindow: } void AudioChannelService::AudioChannelWindow::NotifyMediaBlockStop(nsPIDOMWindowOuter* aWindow) { mShouldSendBlockStopEvent = false; // Can't use raw pointer for lamba variable capturing, use smart ptr. nsCOMPtr<nsPIDOMWindowOuter> window = aWindow; - NS_DispatchToCurrentThread(NS_NewRunnableFunction([window] () -> void { + NS_DispatchToCurrentThread(NS_NewRunnableFunction( + "dom::AudioChannelService::AudioChannelWindow::NotifyMediaBlockStop", + [window]() -> void { nsCOMPtr<nsIObserverService> observerService = services::GetObserverService(); if (NS_WARN_IF(!observerService)) { return; } observerService->NotifyObservers(ToSupports(window), "audio-playback", u"blockStop"); - }) - ); + })); } void AudioChannelService::AudioChannelWindow::AppendAgentAndIncreaseAgentsNum(AudioChannelAgent* aAgent) { MOZ_ASSERT(aAgent); MOZ_ASSERT(!mAgents.Contains(aAgent)); @@ -1044,26 +1047,27 @@ AudioChannelService::AudioChannelWindow: if (window->GetMediaSuspend() != nsISuspendedTypes::SUSPENDED_BLOCK || !doc->Hidden()) { return; } if (!mShouldSendBlockStopEvent) { mShouldSendBlockStopEvent = true; - NS_DispatchToCurrentThread(NS_NewRunnableFunction([window] () -> void { - nsCOMPtr<nsIObserverService> observerService = - services::GetObserverService(); - if (NS_WARN_IF(!observerService)) { - return; - } + NS_DispatchToCurrentThread(NS_NewRunnableFunction( + "dom::AudioChannelService::AudioChannelWindow::" + "MaybeNotifyMediaBlockStart", + [window]() -> void { + nsCOMPtr<nsIObserverService> observerService = + services::GetObserverService(); + if (NS_WARN_IF(!observerService)) { + return; + } - observerService->NotifyObservers(ToSupports(window), - "audio-playback", - u"blockStart"); - }) - ); + observerService->NotifyObservers( + ToSupports(window), "audio-playback", u"blockStart"); + })); } } } // namespace dom } // namespace mozilla
--- a/dom/base/CustomElementRegistry.cpp +++ b/dom/base/CustomElementRegistry.cpp @@ -449,18 +449,19 @@ CustomElementRegistry::EnqueueLifecycleC // Add a script runner to pop and process the element queue at // the top of the processing stack. if (shouldPushElementQueue) { // Lifecycle callbacks enqueued by user agent implementation // should be invoked prior to returning control back to script. // Create a script runner to process the top of the processing // stack as soon as it is safe to run script. - nsCOMPtr<nsIRunnable> runnable = - NS_NewRunnableFunction(&CustomElementRegistry::ProcessTopElementQueue); + nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction( + "dom::CustomElementRegistry::EnqueueLifecycleCallback", + &CustomElementRegistry::ProcessTopElementQueue); nsContentUtils::AddScriptRunner(runnable); } } } void CustomElementRegistry::GetCustomPrototype(nsIAtom* aAtom, JS::MutableHandle<JSObject*> aPrototype)
--- a/dom/base/CustomElementRegistry.h +++ b/dom/base/CustomElementRegistry.h @@ -238,18 +238,21 @@ private: */ void InvokeReactions(ElementQueue& aElementQueue); void Enqueue(Element* aElement, CustomElementReaction* aReaction); private: class ProcessBackupQueueRunnable : public mozilla::Runnable { public: - explicit ProcessBackupQueueRunnable(CustomElementReactionsStack* aReactionStack) - : mReactionStack(aReactionStack) + explicit ProcessBackupQueueRunnable( + CustomElementReactionsStack* aReactionStack) + : Runnable( + "dom::CustomElementReactionsStack::ProcessBackupQueueRunnable") + , mReactionStack(aReactionStack) { MOZ_ASSERT(!mReactionStack->mIsBackupQueueProcessing, "mIsBackupQueueProcessing should be initially false"); mReactionStack->mIsBackupQueueProcessing = true; } NS_IMETHOD Run() override {
--- a/dom/base/DOMRequest.cpp +++ b/dom/base/DOMRequest.cpp @@ -294,20 +294,20 @@ DOMRequestService::FireDetailedError(nsI static_cast<DOMRequest*>(aRequest)->FireDetailedError(err); return NS_OK; } class FireSuccessAsyncTask : public mozilla::Runnable { - FireSuccessAsyncTask(DOMRequest* aRequest, - const JS::Value& aResult) : - mReq(aRequest), - mResult(RootingCx(), aResult) + FireSuccessAsyncTask(DOMRequest* aRequest, const JS::Value& aResult) + : mozilla::Runnable("FireSuccessAsyncTask") + , mReq(aRequest) + , mResult(RootingCx(), aResult) { } public: // Due to the fact that initialization can fail during shutdown (since we // can't fetch a js context), set up an initiatization function to make sure // we can return the failure appropriately @@ -331,20 +331,20 @@ public: private: RefPtr<DOMRequest> mReq; JS::PersistentRooted<JS::Value> mResult; }; class FireErrorAsyncTask : public mozilla::Runnable { public: - FireErrorAsyncTask(DOMRequest* aRequest, - const nsAString& aError) : - mReq(aRequest), - mError(aError) + FireErrorAsyncTask(DOMRequest* aRequest, const nsAString& aError) + : mozilla::Runnable("FireErrorAsyncTask") + , mReq(aRequest) + , mError(aError) { } NS_IMETHOD Run() override { mReq->FireError(mError); return NS_OK;
--- a/dom/base/Element.cpp +++ b/dom/base/Element.cpp @@ -608,17 +608,19 @@ Element::WrapObject(JSContext *aCx, JS:: xblService->LoadBindings(this, uri, principal, getter_AddRefs(binding), &dummy); if (binding) { if (nsContentUtils::IsSafeToRunScript()) { binding->ExecuteAttachedHandler(); } else { nsContentUtils::AddScriptRunner( - NewRunnableMethod(binding, &nsXBLBinding::ExecuteAttachedHandler)); + NewRunnableMethod("nsXBLBinding::ExecuteAttachedHandler", + binding, + &nsXBLBinding::ExecuteAttachedHandler)); } } } } return obj; } @@ -1783,20 +1785,24 @@ Element::BindToTree(nsIDocument* aDocume NS_POSTCONDITION(aDocument == GetUncomposedDoc(), "Bound to wrong document"); NS_POSTCONDITION(aParent == GetParent(), "Bound to wrong parent"); NS_POSTCONDITION(aBindingParent == GetBindingParent(), "Bound to wrong binding parent"); return NS_OK; } -RemoveFromBindingManagerRunnable::RemoveFromBindingManagerRunnable(nsBindingManager* aManager, - nsIContent* aContent, - nsIDocument* aDoc): - mManager(aManager), mContent(aContent), mDoc(aDoc) +RemoveFromBindingManagerRunnable::RemoveFromBindingManagerRunnable( + nsBindingManager* aManager, + nsIContent* aContent, + nsIDocument* aDoc) + : mozilla::Runnable("dom::RemoveFromBindingManagerRunnable") + , mManager(aManager) + , mContent(aContent) + , mDoc(aDoc) {} RemoveFromBindingManagerRunnable::~RemoveFromBindingManagerRunnable() {} NS_IMETHODIMP RemoveFromBindingManagerRunnable::Run() { // It may be the case that the element was removed from the
--- a/dom/base/EventSource.cpp +++ b/dom/base/EventSource.cpp @@ -386,17 +386,19 @@ EventSourceImpl::Close() { if (IsClosed()) { return; } SetReadyState(CLOSED); // Asynchronously call CloseInternal to prevent EventSourceImpl from being // synchronously destoryed while dispatching DOM event. DebugOnly<nsresult> rv = - Dispatch(NewRunnableMethod(this, &EventSourceImpl::CloseInternal), + Dispatch(NewRunnableMethod("dom::EventSourceImpl::CloseInternal", + this, + &EventSourceImpl::CloseInternal), NS_DISPATCH_NORMAL); MOZ_ASSERT(NS_SUCCEEDED(rv)); } void EventSourceImpl::CloseInternal() { AssertIsOnTargetThread(); @@ -678,17 +680,19 @@ EventSourceImpl::OnStartRequest(nsIReque nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(httpChannel); if (rr) { rv = rr->RetargetDeliveryTo(this); if (NS_WARN_IF(NS_FAILED(rv))) { NS_WARNING("Retargeting failed"); } } } - rv = Dispatch(NewRunnableMethod(this, &EventSourceImpl::AnnounceConnection), + rv = Dispatch(NewRunnableMethod("dom::EventSourceImpl::AnnounceConnection", + this, + &EventSourceImpl::AnnounceConnection), NS_DISPATCH_NORMAL); NS_ENSURE_SUCCESS(rv, rv); mStatus = PARSE_STATE_BEGIN_OF_STREAM; return NS_OK; } // this method parses the characters as they become available instead of // buffering them. @@ -747,17 +751,18 @@ class DataAvailableRunnable final : publ private: RefPtr<EventSourceImpl> mEventSourceImpl; UniquePtr<char[]> mData; uint32_t mLength; public: DataAvailableRunnable(EventSourceImpl* aEventSourceImpl, UniquePtr<char[]> aData, uint32_t aLength) - : mEventSourceImpl(aEventSourceImpl) + : Runnable("dom::DataAvailableRunnable") + , mEventSourceImpl(aEventSourceImpl) , mData(Move(aData)) , mLength(aLength) { } NS_IMETHOD Run() override { mEventSourceImpl->ParseSegment(mData.get(), mLength); @@ -835,19 +840,20 @@ EventSourceImpl::OnStopRequest(nsIReques aStatusCode != NS_ERROR_DNS_LOOKUP_QUEUE_FULL) { DispatchFailConnection(); return NS_ERROR_ABORT; } nsresult rv = CheckHealthOfRequestCallback(aRequest); NS_ENSURE_SUCCESS(rv, rv); - rv = Dispatch( - NewRunnableMethod(this, &EventSourceImpl::ReestablishConnection), - NS_DISPATCH_NORMAL); + rv = Dispatch(NewRunnableMethod("dom::EventSourceImpl::ReestablishConnection", + this, + &EventSourceImpl::ReestablishConnection), + NS_DISPATCH_NORMAL); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } //----------------------------------------------------------------------------- // EventSourceImpl::nsIChannelEventSink //----------------------------------------------------------------------------- @@ -1240,19 +1246,22 @@ EventSourceImpl::SetReconnectionTimeout( } // the timer will be used whenever the requests are going finished. if (!mTimer) { mTimer = do_CreateInstance("@mozilla.org/timer;1"); NS_ENSURE_STATE(mTimer); } - nsresult rv = mTimer->InitWithFuncCallback(TimerCallback, this, - mReconnectionTime, - nsITimer::TYPE_ONE_SHOT); + nsresult rv = mTimer->InitWithNamedFuncCallback( + TimerCallback, + this, + mReconnectionTime, + nsITimer::TYPE_ONE_SHOT, + "dom::EventSourceImpl::SetReconnectionTimeout"); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } nsresult EventSourceImpl::PrintErrorOnConsole(const char* aBundleURI, const char16_t* aError, @@ -1336,17 +1345,19 @@ EventSourceImpl::DispatchFailConnection( AssertIsOnMainThread(); if (IsClosed()) { return; } nsresult rv = ConsoleError(); if (NS_FAILED(rv)) { NS_WARNING("Failed to print to the console error"); } - rv = Dispatch(NewRunnableMethod(this, &EventSourceImpl::FailConnection), + rv = Dispatch(NewRunnableMethod("dom::EventSourceImpl::FailConnection", + this, + &EventSourceImpl::FailConnection), NS_DISPATCH_NORMAL); MOZ_ASSERT(NS_SUCCEEDED(rv)); } void EventSourceImpl::FailConnection() { AssertIsOnTargetThread(); @@ -1402,17 +1413,19 @@ EventSourceImpl::Thaw() } MOZ_ASSERT(!mHttpChannel, "the connection hasn't been closed!!!"); SetFrozen(false); nsresult rv; if (!mGoingToDispatchAllMessages && mMessagesToDispatch.GetSize() > 0) { nsCOMPtr<nsIRunnable> event = - NewRunnableMethod(this, &EventSourceImpl::DispatchAllMessageEvents); + NewRunnableMethod("dom::EventSourceImpl::DispatchAllMessageEvents", + this, + &EventSourceImpl::DispatchAllMessageEvents); NS_ENSURE_STATE(event); mGoingToDispatchAllMessages = true; rv = Dispatch(event.forget(), NS_DISPATCH_NORMAL); NS_ENSURE_SUCCESS(rv, rv); } @@ -1463,17 +1476,19 @@ EventSourceImpl::DispatchCurrentMessageE size_t sizeBefore = mMessagesToDispatch.GetSize(); mMessagesToDispatch.Push(message.release()); NS_ENSURE_TRUE(mMessagesToDispatch.GetSize() == sizeBefore + 1, NS_ERROR_OUT_OF_MEMORY); if (!mGoingToDispatchAllMessages) { nsCOMPtr<nsIRunnable> event = - NewRunnableMethod(this, &EventSourceImpl::DispatchAllMessageEvents); + NewRunnableMethod("dom::EventSourceImpl::DispatchAllMessageEvents", + this, + &EventSourceImpl::DispatchAllMessageEvents); NS_ENSURE_STATE(event); mGoingToDispatchAllMessages = true; return Dispatch(event.forget(), NS_DISPATCH_NORMAL); } return NS_OK;
--- a/dom/base/ImageEncoder.cpp +++ b/dom/base/ImageEncoder.cpp @@ -547,19 +547,19 @@ RegisterEncoderThreadPoolTerminatorObser nsresult ImageEncoder::EnsureThreadPool() { if (!sThreadPool) { nsCOMPtr<nsIThreadPool> threadPool = do_CreateInstance(NS_THREADPOOL_CONTRACTID); sThreadPool = threadPool; if (!NS_IsMainThread()) { - NS_DispatchToMainThread(NS_NewRunnableFunction([]() -> void { - RegisterEncoderThreadPoolTerminatorObserver(); - })); + NS_DispatchToMainThread(NS_NewRunnableFunction( + "dom::ImageEncoder::EnsureThreadPool", + []() -> void { RegisterEncoderThreadPoolTerminatorObserver(); })); } else { RegisterEncoderThreadPoolTerminatorObserver(); } const uint32_t kThreadLimit = 2; const uint32_t kIdleThreadLimit = 1; const uint32_t kIdleThreadTimeoutMs = 30000;
--- a/dom/base/PostMessageEvent.cpp +++ b/dom/base/PostMessageEvent.cpp @@ -30,24 +30,26 @@ namespace mozilla { namespace dom { PostMessageEvent::PostMessageEvent(nsGlobalWindow* aSource, const nsAString& aCallerOrigin, nsGlobalWindow* aTargetWindow, nsIPrincipal* aProvidedPrincipal, nsIDocument* aSourceDocument, bool aTrustedCaller) -: StructuredCloneHolder(CloningSupported, TransferringSupported, - StructuredCloneScope::SameProcessSameThread), - mSource(aSource), - mCallerOrigin(aCallerOrigin), - mTargetWindow(aTargetWindow), - mProvidedPrincipal(aProvidedPrincipal), - mSourceDocument(aSourceDocument), - mTrustedCaller(aTrustedCaller) + : Runnable("dom::PostMessageEvent") + , StructuredCloneHolder(CloningSupported, + TransferringSupported, + StructuredCloneScope::SameProcessSameThread) + , mSource(aSource) + , mCallerOrigin(aCallerOrigin) + , mTargetWindow(aTargetWindow) + , mProvidedPrincipal(aProvidedPrincipal) + , mSourceDocument(aSourceDocument) + , mTrustedCaller(aTrustedCaller) { } PostMessageEvent::~PostMessageEvent() { } NS_IMETHODIMP
--- a/dom/base/ScreenOrientation.cpp +++ b/dom/base/ScreenOrientation.cpp @@ -548,18 +548,20 @@ ScreenOrientation::Notify(const hal::Scr doc->SetCurrentOrientation(mType, mAngle); Promise* pendingPromise = doc->GetOrientationPendingPromise(); if (pendingPromise) { pendingPromise->MaybeResolveWithUndefined(); doc->SetOrientationPendingPromise(nullptr); } - nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod(this, - &ScreenOrientation::DispatchChangeEvent); + nsCOMPtr<nsIRunnable> runnable = + NewRunnableMethod("dom::ScreenOrientation::DispatchChangeEvent", + this, + &ScreenOrientation::DispatchChangeEvent); rv = NS_DispatchToMainThread(runnable); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed"); } } void ScreenOrientation::UpdateActiveOrientationLock(ScreenOrientationInternal aOrientation) { @@ -635,18 +637,20 @@ ScreenOrientation::VisibleEventListener: orientation->DeviceAngle(CallerType::System)); Promise* pendingPromise = doc->GetOrientationPendingPromise(); if (pendingPromise) { pendingPromise->MaybeResolveWithUndefined(); doc->SetOrientationPendingPromise(nullptr); } - nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod(orientation, - &ScreenOrientation::DispatchChangeEvent); + nsCOMPtr<nsIRunnable> runnable = + NewRunnableMethod("dom::ScreenOrientation::DispatchChangeEvent", + orientation, + &ScreenOrientation::DispatchChangeEvent); rv = NS_DispatchToMainThread(runnable); if (NS_WARN_IF(rv.Failed())) { return rv.StealNSResult(); } } return NS_OK; }
--- a/dom/base/Selection.h +++ b/dom/base/Selection.h @@ -318,21 +318,23 @@ private: class ScrollSelectionIntoViewEvent : public Runnable { public: NS_DECL_NSIRUNNABLE ScrollSelectionIntoViewEvent(Selection* aSelection, SelectionRegion aRegion, nsIPresShell::ScrollAxis aVertical, nsIPresShell::ScrollAxis aHorizontal, int32_t aFlags) - : mSelection(aSelection), - mRegion(aRegion), - mVerticalScroll(aVertical), - mHorizontalScroll(aHorizontal), - mFlags(aFlags) { + : Runnable("dom::Selection::ScrollSelectionIntoViewEvent") + , mSelection(aSelection) + , mRegion(aRegion) + , mVerticalScroll(aVertical) + , mHorizontalScroll(aHorizontal) + , mFlags(aFlags) + { NS_ASSERTION(aSelection, "null parameter"); } void Revoke() { mSelection = nullptr; } private: Selection *mSelection; SelectionRegion mRegion; nsIPresShell::ScrollAxis mVerticalScroll; nsIPresShell::ScrollAxis mHorizontalScroll;
--- a/dom/base/WebSocket.cpp +++ b/dom/base/WebSocket.cpp @@ -263,17 +263,18 @@ NS_IMPL_ISUPPORTS(WebSocketImpl, nsISupportsWeakReference, nsIRequest, nsIEventTarget) class CallDispatchConnectionCloseEvents final : public CancelableRunnable { public: explicit CallDispatchConnectionCloseEvents(WebSocketImpl* aWebSocketImpl) - : mWebSocketImpl(aWebSocketImpl) + : CancelableRunnable("dom::CallDispatchConnectionCloseEvents") + , mWebSocketImpl(aWebSocketImpl) { aWebSocketImpl->AssertIsOnTargetThread(); } NS_IMETHOD Run() override { mWebSocketImpl->AssertIsOnTargetThread(); mWebSocketImpl->DispatchConnectionCloseEvents(); @@ -399,19 +400,21 @@ WebSocketImpl::PrintErrorOnConsole(const NS_ENSURE_SUCCESS_VOID(rv); } namespace { class CancelWebSocketRunnable final : public Runnable { public: - CancelWebSocketRunnable(nsIWebSocketChannel* aChannel, uint16_t aReasonCode, + CancelWebSocketRunnable(nsIWebSocketChannel* aChannel, + uint16_t aReasonCode, const nsACString& aReasonString) - : mChannel(aChannel) + : Runnable("dom::CancelWebSocketRunnable") + , mChannel(aChannel) , mReasonCode(aReasonCode) , mReasonString(aReasonString) {} NS_IMETHOD Run() override { nsresult rv = mChannel->Close(mReasonCode, mReasonString); if (NS_FAILED(rv)) { @@ -453,17 +456,18 @@ private: }; class CloseConnectionRunnable final : public Runnable { public: CloseConnectionRunnable(WebSocketImpl* aImpl, uint16_t aReasonCode, const nsACString& aReasonString) - : mImpl(aImpl) + : Runnable("dom::CloseConnectionRunnable") + , mImpl(aImpl) , mReasonCode(aReasonCode) , mReasonString(aReasonString) {} NS_IMETHOD Run() override { return mImpl->CloseConnection(mReasonCode, mReasonString); }
--- a/dom/base/nsContentSink.cpp +++ b/dom/base/nsContentSink.cpp @@ -280,18 +280,19 @@ nsContentSink::ProcessHTTPHeaders(nsICha if (NS_SUCCEEDED(rv) && !linkHeader.IsEmpty()) { mDocument->SetHeaderData(nsGkAtoms::link, NS_ConvertASCIItoUTF16(linkHeader)); NS_ASSERTION(!mProcessLinkHeaderEvent.get(), "Already dispatched an event?"); mProcessLinkHeaderEvent = - NewNonOwningRunnableMethod(this, - &nsContentSink::DoProcessLinkHeader); + NewNonOwningRunnableMethod("nsContentSink::DoProcessLinkHeader", + this, + &nsContentSink::DoProcessLinkHeader); rv = NS_DispatchToCurrentThread(mProcessLinkHeaderEvent.get()); if (NS_FAILED(rv)) { mProcessLinkHeaderEvent.Forget(); } } return NS_OK; }
--- a/dom/base/nsContentUtils.cpp +++ b/dom/base/nsContentUtils.cpp @@ -5317,22 +5317,26 @@ nsContentUtils::IsInSameAnonymousTree(co aContent->GetContainingShadow(); } return nodeAsContent->GetBindingParent() == aContent->GetBindingParent(); } class AnonymousContentDestroyer : public Runnable { public: - explicit AnonymousContentDestroyer(nsCOMPtr<nsIContent>* aContent) { + explicit AnonymousContentDestroyer(nsCOMPtr<nsIContent>* aContent) + : mozilla::Runnable("AnonymousContentDestroyer") + { mContent.swap(*aContent); mParent = mContent->GetParent(); mDoc = mContent->OwnerDoc(); } - explicit AnonymousContentDestroyer(nsCOMPtr<Element>* aElement) { + explicit AnonymousContentDestroyer(nsCOMPtr<Element>* aElement) + : mozilla::Runnable("AnonymousContentDestroyer") + { mContent = aElement->forget(); mParent = mContent->GetParent(); mDoc = mContent->OwnerDoc(); } NS_IMETHOD Run() override { mContent->UnbindFromTree(); return NS_OK; } @@ -10555,19 +10559,19 @@ nsContentUtils::UserInteractionObserver: nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); obs->AddObserver(this, kUserInteractionInactive, false); obs->AddObserver(this, kUserInteractionActive, false); // We can't register ourselves as an annotator yet, as the HangMonitor hasn't // started yet. It will have started by the time we have the chance to spin // the event loop. RefPtr<UserInteractionObserver> self = this; - NS_DispatchToMainThread(NS_NewRunnableFunction([=] () { - HangMonitor::RegisterAnnotator(*self); - })); + NS_DispatchToMainThread( + NS_NewRunnableFunction("nsContentUtils::UserInteractionObserver::Init", + [=]() { HangMonitor::RegisterAnnotator(*self); })); } void nsContentUtils::UserInteractionObserver::Shutdown() { nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); if (obs) { obs->RemoveObserver(this, kUserInteractionInactive);
--- a/dom/base/nsDOMMutationObserver.cpp +++ b/dom/base/nsDOMMutationObserver.cpp @@ -862,16 +862,17 @@ nsDOMMutationObserver::HandleMutation() ClearPendingRecords(); mCallback->Call(this, mutations, *this); } class AsyncMutationHandler : public mozilla::Runnable { public: + AsyncMutationHandler() : mozilla::Runnable("AsyncMutationHandler") {} NS_IMETHOD Run() override { nsDOMMutationObserver::HandleMutations(); return NS_OK; } }; void
--- a/dom/base/nsDOMWindowUtils.cpp +++ b/dom/base/nsDOMWindowUtils.cpp @@ -1104,59 +1104,76 @@ nsDOMWindowUtils::SendNativeKeyEvent(int const nsAString& aUnmodifiedCharacters, nsIObserver* aObserver) { // get the widget to send the event to nsCOMPtr<nsIWidget> widget = GetWidget(); if (!widget) return NS_ERROR_FAILURE; - NS_DispatchToMainThread(NewRunnableMethod - <int32_t, int32_t, uint32_t, nsString, nsString, nsIObserver*> - (widget, &nsIWidget::SynthesizeNativeKeyEvent, aNativeKeyboardLayout, - aNativeKeyCode, aModifiers, aCharacters, aUnmodifiedCharacters, aObserver)); + NS_DispatchToMainThread( + NewRunnableMethod<int32_t, + int32_t, + uint32_t, + nsString, + nsString, + nsIObserver*>("nsIWidget::SynthesizeNativeKeyEvent", + widget, + &nsIWidget::SynthesizeNativeKeyEvent, + aNativeKeyboardLayout, + aNativeKeyCode, + aModifiers, + aCharacters, + aUnmodifiedCharacters, + aObserver)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeMouseEvent(int32_t aScreenX, int32_t aScreenY, int32_t aNativeMessage, int32_t aModifierFlags, nsIDOMElement* aElement, nsIObserver* aObserver) { // get the widget to send the event to nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement); if (!widget) return NS_ERROR_FAILURE; - NS_DispatchToMainThread(NewRunnableMethod - <LayoutDeviceIntPoint, int32_t, int32_t, nsIObserver*> - (widget, &nsIWidget::SynthesizeNativeMouseEvent, - LayoutDeviceIntPoint(aScreenX, aScreenY), aNativeMessage, aModifierFlags, - aObserver)); + NS_DispatchToMainThread( + NewRunnableMethod<LayoutDeviceIntPoint, int32_t, int32_t, nsIObserver*>( + "nsIWidget::SynthesizeNativeMouseEvent", + widget, + &nsIWidget::SynthesizeNativeMouseEvent, + LayoutDeviceIntPoint(aScreenX, aScreenY), + aNativeMessage, + aModifierFlags, + aObserver)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeMouseMove(int32_t aScreenX, int32_t aScreenY, nsIDOMElement* aElement, nsIObserver* aObserver) { // get the widget to send the event to nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement); if (!widget) return NS_ERROR_FAILURE; - NS_DispatchToMainThread(NewRunnableMethod - <LayoutDeviceIntPoint, nsIObserver*> - (widget, &nsIWidget::SynthesizeNativeMouseMove, - LayoutDeviceIntPoint(aScreenX, aScreenY), aObserver)); + NS_DispatchToMainThread(NewRunnableMethod<LayoutDeviceIntPoint, nsIObserver*>( + "nsIWidget::SynthesizeNativeMouseMove", + widget, + &nsIWidget::SynthesizeNativeMouseMove, + LayoutDeviceIntPoint(aScreenX, aScreenY), + aObserver)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeMouseScrollEvent(int32_t aScreenX, int32_t aScreenY, uint32_t aNativeMessage, double aDeltaX, @@ -1168,21 +1185,35 @@ nsDOMWindowUtils::SendNativeMouseScrollE nsIObserver* aObserver) { // get the widget to send the event to nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement); if (!widget) { return NS_ERROR_FAILURE; } - NS_DispatchToMainThread(NewRunnableMethod - <mozilla::LayoutDeviceIntPoint, uint32_t, double, double, double, uint32_t, uint32_t, nsIObserver*> - (widget, &nsIWidget::SynthesizeNativeMouseScrollEvent, - LayoutDeviceIntPoint(aScreenX, aScreenY), aNativeMessage, aDeltaX, aDeltaY, - aDeltaZ, aModifierFlags, aAdditionalFlags, aObserver)); + NS_DispatchToMainThread(NewRunnableMethod<mozilla::LayoutDeviceIntPoint, + uint32_t, + double, + double, + double, + uint32_t, + uint32_t, + nsIObserver*>( + "nsIWidget::SynthesizeNativeMouseScrollEvent", + widget, + &nsIWidget::SynthesizeNativeMouseScrollEvent, + LayoutDeviceIntPoint(aScreenX, aScreenY), + aNativeMessage, + aDeltaX, + aDeltaY, + aDeltaZ, + aModifierFlags, + aAdditionalFlags, + aObserver)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeTouchPoint(uint32_t aPointerId, uint32_t aTouchState, int32_t aScreenX, int32_t aScreenY, @@ -1194,53 +1225,69 @@ nsDOMWindowUtils::SendNativeTouchPoint(u if (!widget) { return NS_ERROR_FAILURE; } if (aPressure < 0 || aPressure > 1 || aOrientation > 359) { return NS_ERROR_INVALID_ARG; } - NS_DispatchToMainThread(NewRunnableMethod - <uint32_t, nsIWidget::TouchPointerState, LayoutDeviceIntPoint, double, uint32_t, nsIObserver*> - (widget, &nsIWidget::SynthesizeNativeTouchPoint, aPointerId, - (nsIWidget::TouchPointerState)aTouchState, - LayoutDeviceIntPoint(aScreenX, aScreenY), - aPressure, aOrientation, aObserver)); + NS_DispatchToMainThread( + NewRunnableMethod<uint32_t, + nsIWidget::TouchPointerState, + LayoutDeviceIntPoint, + double, + uint32_t, + nsIObserver*>("nsIWidget::SynthesizeNativeTouchPoint", + widget, + &nsIWidget::SynthesizeNativeTouchPoint, + aPointerId, + (nsIWidget::TouchPointerState)aTouchState, + LayoutDeviceIntPoint(aScreenX, aScreenY), + aPressure, + aOrientation, + aObserver)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::SendNativeTouchTap(int32_t aScreenX, int32_t aScreenY, bool aLongTap, nsIObserver* aObserver) { nsCOMPtr<nsIWidget> widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } - NS_DispatchToMainThread(NewRunnableMethod - <LayoutDeviceIntPoint, bool, nsIObserver*> - (widget, &nsIWidget::SynthesizeNativeTouchTap, - LayoutDeviceIntPoint(aScreenX, aScreenY), aLongTap, aObserver)); + NS_DispatchToMainThread( + NewRunnableMethod<LayoutDeviceIntPoint, bool, nsIObserver*>( + "nsIWidget::SynthesizeNativeTouchTap", + widget, + &nsIWidget::SynthesizeNativeTouchTap, + LayoutDeviceIntPoint(aScreenX, aScreenY), + aLongTap, + aObserver)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::ClearNativeTouchSequence(nsIObserver* aObserver) { nsCOMPtr<nsIWidget> widget = GetWidget(); if (!widget) { return NS_ERROR_FAILURE; } - NS_DispatchToMainThread(NewRunnableMethod<nsIObserver*> - (widget, &nsIWidget::ClearNativeTouchSequence, aObserver)); + NS_DispatchToMainThread( + NewRunnableMethod<nsIObserver*>("nsIWidget::ClearNativeTouchSequence", + widget, + &nsIWidget::ClearNativeTouchSequence, + aObserver)); return NS_OK; } NS_IMETHODIMP nsDOMWindowUtils::ActivateNativeMenuItemAt(const nsAString& indexString) { // get the widget to send the event to nsCOMPtr<nsIWidget> widget = GetWidget();
--- a/dom/base/nsDocElementCreatedNotificationRunner.h +++ b/dom/base/nsDocElementCreatedNotificationRunner.h @@ -13,17 +13,18 @@ #include "nsContentSink.h" #include "nsCOMPtr.h" #include "nsIDocument.h" class nsDocElementCreatedNotificationRunner : public mozilla::Runnable { public: explicit nsDocElementCreatedNotificationRunner(nsIDocument* aDoc) - : mDoc(aDoc) + : mozilla::Runnable("nsDocElementCreatedNotificationRunner") + , mDoc(aDoc) { } NS_IMETHOD Run() override { nsContentSink::NotifyDocElementCreated(mDoc); return NS_OK; }
--- a/dom/base/nsDocument.cpp +++ b/dom/base/nsDocument.cpp @@ -4429,18 +4429,20 @@ nsDocument::SetStyleSheetApplicableState DO_STYLESHEET_NOTIFICATION(StyleSheetApplicableStateChangeEvent, "StyleSheetApplicableStateChanged", mApplicable, aApplicable); } if (!mSSApplicableStateNotificationPending) { MOZ_RELEASE_ASSERT(NS_IsMainThread()); - nsCOMPtr<nsIRunnable> notification = NewRunnableMethod(this, - &nsDocument::NotifyStyleSheetApplicableStateChanged); + nsCOMPtr<nsIRunnable> notification = + NewRunnableMethod("nsDocument::NotifyStyleSheetApplicableStateChanged", + this, + &nsDocument::NotifyStyleSheetApplicableStateChanged); mSSApplicableStateNotificationPending = NS_SUCCEEDED( Dispatch("nsDocument::NotifyStyleSheetApplicableStateChanged", TaskCategory::Other, notification.forget())); } } void @@ -5045,17 +5047,19 @@ nsDocument::MaybeEndOutermostXBLUpdate() // we're not in an update and it is safe to run scripts. if (mUpdateNestLevel == 0 && mInXBLUpdate) { if (nsContentUtils::IsSafeToRunScript()) { mInXBLUpdate = false; BindingManager()->EndOutermostUpdate(); } else if (!mInDestructor) { if (!mMaybeEndOutermostXBLUpdateRunner) { mMaybeEndOutermostXBLUpdateRunner = - NewRunnableMethod(this, &nsDocument::MaybeEndOutermostXBLUpdate); + NewRunnableMethod("nsDocument::MaybeEndOutermostXBLUpdate", + this, + &nsDocument::MaybeEndOutermostXBLUpdate); } nsContentUtils::AddScriptRunner(mMaybeEndOutermostXBLUpdateRunner); } } } void nsDocument::BeginUpdate(nsUpdateType aUpdateType) @@ -5376,17 +5380,19 @@ nsDocument::UnblockDOMContentLoaded() return; } mDidFireDOMContentLoaded = true; MOZ_ASSERT(mReadyState == READYSTATE_INTERACTIVE); if (!mSynchronousDOMContentLoaded) { MOZ_RELEASE_ASSERT(NS_IsMainThread()); nsCOMPtr<nsIRunnable> ev = - NewRunnableMethod(this, &nsDocument::DispatchContentLoadedEvents); + NewRunnableMethod("nsDocument::DispatchContentLoadedEvents", + this, + &nsDocument::DispatchContentLoadedEvents); Dispatch("nsDocument::DispatchContentLoadedEvents", TaskCategory::Other, ev.forget()); } else { DispatchContentLoadedEvents(); } } void nsDocument::ContentStateChanged(nsIContent* aContent, EventStates aStateMask) @@ -7014,17 +7020,19 @@ nsDocument::NotifyPossibleTitleChange(bo if (aBoundTitleElement) { mMayHaveTitleElement = true; } if (mPendingTitleChangeEvent.IsPending()) return; MOZ_RELEASE_ASSERT(NS_IsMainThread()); RefPtr<nsRunnableMethod<nsDocument, void, false>> event = - NewNonOwningRunnableMethod(this, &nsDocument::DoNotifyPossibleTitleChange); + NewNonOwningRunnableMethod("nsDocument::DoNotifyPossibleTitleChange", + this, + &nsDocument::DoNotifyPossibleTitleChange); nsresult rv = Dispatch("nsDocument::DoNotifyPossibleTitleChange", TaskCategory::Other, do_AddRef(event)); if (NS_SUCCEEDED(rv)) { mPendingTitleChangeEvent = event; } } void @@ -7164,17 +7172,19 @@ nsDocument::InitializeFrameLoader(nsFram NS_WARNING("Trying to initialize a frame loader while" "document is being deleted"); return NS_ERROR_FAILURE; } mInitializableFrameLoaders.AppendElement(aLoader); if (!mFrameLoaderRunner) { mFrameLoaderRunner = - NewRunnableMethod(this, &nsDocument::MaybeInitializeFinalizeFrameLoaders); + NewRunnableMethod("nsDocument::MaybeInitializeFinalizeFrameLoaders", + this, + &nsDocument::MaybeInitializeFinalizeFrameLoaders); NS_ENSURE_TRUE(mFrameLoaderRunner, NS_ERROR_OUT_OF_MEMORY); nsContentUtils::AddScriptRunner(mFrameLoaderRunner); } return NS_OK; } nsresult nsDocument::FinalizeFrameLoader(nsFrameLoader* aLoader, nsIRunnable* aFinalizer) @@ -7182,17 +7192,19 @@ nsDocument::FinalizeFrameLoader(nsFrameL mInitializableFrameLoaders.RemoveElement(aLoader); if (mInDestructor) { return NS_ERROR_FAILURE; } mFrameLoaderFinalizers.AppendElement(aFinalizer); if (!mFrameLoaderRunner) { mFrameLoaderRunner = - NewRunnableMethod(this, &nsDocument::MaybeInitializeFinalizeFrameLoaders); + NewRunnableMethod("nsDocument::MaybeInitializeFinalizeFrameLoaders", + this, + &nsDocument::MaybeInitializeFinalizeFrameLoaders); NS_ENSURE_TRUE(mFrameLoaderRunner, NS_ERROR_OUT_OF_MEMORY); nsContentUtils::AddScriptRunner(mFrameLoaderRunner); } return NS_OK; } void nsDocument::MaybeInitializeFinalizeFrameLoaders() @@ -7206,17 +7218,19 @@ nsDocument::MaybeInitializeFinalizeFrame // We're not in an update, but it is not safe to run scripts, so // postpone frameloader initialization and finalization. if (!nsContentUtils::IsSafeToRunScript()) { if (!mInDestructor && !mFrameLoaderRunner && (mInitializableFrameLoaders.Length() || mFrameLoaderFinalizers.Length())) { mFrameLoaderRunner = - NewRunnableMethod(this, &nsDocument::MaybeInitializeFinalizeFrameLoaders); + NewRunnableMethod("nsDocument::MaybeInitializeFinalizeFrameLoaders", + this, + &nsDocument::MaybeInitializeFinalizeFrameLoaders); nsContentUtils::AddScriptRunner(mFrameLoaderRunner); } return; } mFrameLoaderRunner = nullptr; // Don't use a temporary array for mInitializableFrameLoaders, because // loading a frame may cause some other frameloader to be removed from the @@ -8783,18 +8797,18 @@ nsDocument::BlockOnload() // If mScriptGlobalObject is null, we shouldn't be messing with the loadgroup // -- it's not ours. if (mOnloadBlockCount == 0 && mScriptGlobalObject) { if (!nsContentUtils::IsSafeToRunScript()) { // Because AddRequest may lead to OnStateChange calls in chrome, // block onload only when there are no script blockers. ++mAsyncOnloadBlockCount; if (mAsyncOnloadBlockCount == 1) { - nsContentUtils::AddScriptRunner( - NewRunnableMethod(this, &nsDocument::AsyncBlockOnload)); + nsContentUtils::AddScriptRunner(NewRunnableMethod( + "nsDocument::AsyncBlockOnload", this, &nsDocument::AsyncBlockOnload)); } return; } nsCOMPtr<nsILoadGroup> loadGroup = GetDocumentLoadGroup(); if (loadGroup) { loadGroup->AddRequest(mOnloadBlocker, nullptr); } } @@ -8841,17 +8855,21 @@ nsDocument::UnblockOnload(bool aFireSync false); asyncDispatcher->PostDOMEvent(); } } } class nsUnblockOnloadEvent : public Runnable { public: - explicit nsUnblockOnloadEvent(nsDocument* aDoc) : mDoc(aDoc) {} + explicit nsUnblockOnloadEvent(nsDocument* aDoc) + : mozilla::Runnable("nsUnblockOnloadEvent") + , mDoc(aDoc) + { + } NS_IMETHOD Run() override { mDoc->DoUnblockOnload(); return NS_OK; } private: RefPtr<nsDocument> mDoc; }; @@ -9723,16 +9741,17 @@ nsDocument::LoadChromeSheetSync(nsIURI* : css::eAuthorSheetFeatures; return CSSLoader()->LoadSheetSync(uri, mode, isAgentSheet, aSheet); } class nsDelayedEventDispatcher : public Runnable { public: explicit nsDelayedEventDispatcher(nsTArray<nsCOMPtr<nsIDocument>>& aDocuments) + : mozilla::Runnable("nsDelayedEventDispatcher") { mDocuments.SwapElements(aDocuments); } virtual ~nsDelayedEventDispatcher() {} NS_IMETHOD Run() override { FireOrClearDelayedEvents(mDocuments, true); @@ -9969,17 +9988,19 @@ nsIDocument::RegisterPendingLinkUpdate(L if (aLink->HasPendingLinkUpdate()) { return; } aLink->SetHasPendingLinkUpdate(); if (!mHasLinksToUpdateRunnable) { nsCOMPtr<nsIRunnable> event = - NewRunnableMethod(this, &nsIDocument::FlushPendingLinkUpdatesFromRunnable); + NewRunnableMethod("nsIDocument::FlushPendingLinkUpdatesFromRunnable", + this, + &nsIDocument::FlushPendingLinkUpdatesFromRunnable); // Do this work in a second in the worst case. nsresult rv = NS_IdleDispatchToCurrentThread(event.forget(), 1000); if (NS_FAILED(rv)) { // If during shutdown posting a runnable doesn't succeed, we probably // don't need to update link states. return; } @@ -10891,17 +10912,20 @@ AskWindowToExitFullscreen(nsIDocument* a } } } class nsCallExitFullscreen : public Runnable { public: explicit nsCallExitFullscreen(nsIDocument* aDoc) - : mDoc(aDoc) {} + : mozilla::Runnable("nsCallExitFullscreen") + , mDoc(aDoc) + { + } NS_IMETHOD Run() override final { if (!mDoc) { FullscreenRoots::ForEach(&AskWindowToExitFullscreen); } else { AskWindowToExitFullscreen(mDoc); } @@ -10971,17 +10995,20 @@ ResetFullScreen(nsIDocument* aDocument, // Since nsIDocument::ExitFullscreenInDocTree() could be called from // Element::UnbindFromTree() where it is not safe to synchronously run // script. This runnable is the script part of that function. class ExitFullscreenScriptRunnable : public Runnable { public: explicit ExitFullscreenScriptRunnable(nsCOMArray<nsIDocument>&& aDocuments) - : mDocuments(Move(aDocuments)) { } + : mozilla::Runnable("ExitFullscreenScriptRunnable") + , mDocuments(Move(aDocuments)) + { + } NS_IMETHOD Run() override { // Dispatch MozDOMFullscreen:Exited to the last document in // the list since we want this event to follow the same path // MozDOMFullscreen:Entered dispatched. nsIDocument* lastDocument = mDocuments[mDocuments.Length() - 1]; nsContentUtils::DispatchEventOnlyToChrome( @@ -11165,17 +11192,20 @@ nsDocument::RestorePreviousFullScreenSta /* Bubbles */ true, /* ChromeOnly */ true); } } class nsCallRequestFullScreen : public Runnable { public: explicit nsCallRequestFullScreen(UniquePtr<FullscreenRequest>&& aRequest) - : mRequest(Move(aRequest)) { } + : mozilla::Runnable("nsCallRequestFullScreen") + , mRequest(Move(aRequest)) + { + } NS_IMETHOD Run() override { mRequest->GetDocument()->RequestFullScreen(Move(mRequest)); return NS_OK; } UniquePtr<FullscreenRequest> mRequest; @@ -11895,17 +11925,18 @@ DispatchPointerLockError(nsIDocument* aT nsContentUtils::eDOM_PROPERTIES, aMessage); } class PointerLockRequest final : public Runnable { public: PointerLockRequest(Element* aElement, bool aUserInputOrChromeCaller) - : mElement(do_GetWeakReference(aElement)) + : mozilla::Runnable("PointerLockRequest") + , mElement(do_GetWeakReference(aElement)) , mDocument(do_GetWeakReference(aElement->OwnerDoc())) , mUserInputOrChromeCaller(aUserInputOrChromeCaller) {} NS_IMETHOD Run() final; private: nsWeakPtr mElement; @@ -12246,17 +12277,19 @@ nsDocument::GetVisibilityState() const return dom::VisibilityState::Visible; } /* virtual */ void nsDocument::PostVisibilityUpdateEvent() { nsCOMPtr<nsIRunnable> event = - NewRunnableMethod(this, &nsDocument::UpdateVisibilityState); + NewRunnableMethod("nsDocument::UpdateVisibilityState", + this, + &nsDocument::UpdateVisibilityState); Dispatch("nsDocument::UpdateVisibilityState", TaskCategory::Other, event.forget()); } void nsDocument::MaybeActiveMediaComponents() { if (!mWindow) { return; @@ -12791,17 +12824,19 @@ nsDocument::UpdateIntersectionObservatio void nsDocument::ScheduleIntersectionObserverNotification() { if (mIntersectionObservers.IsEmpty()) { return; } MOZ_RELEASE_ASSERT(NS_IsMainThread()); nsCOMPtr<nsIRunnable> notification = - NewRunnableMethod(this, &nsDocument::NotifyIntersectionObservers); + NewRunnableMethod("nsDocument::NotifyIntersectionObservers", + this, + &nsDocument::NotifyIntersectionObservers); Dispatch("nsDocument::IntersectionObserverNotification", TaskCategory::Other, notification.forget()); } void nsDocument::NotifyIntersectionObservers() { nsTArray<RefPtr<DOMIntersectionObserver>> observers(mIntersectionObservers.Count()); @@ -13081,17 +13116,19 @@ nsIDocument::RebuildUserFontSet() // and lazily rebuilding it isn't sufficient, since it is only the act // of rebuilding it that will trigger the style change reflow that // calls GetUserFontSet. (This reflow causes rebuilding of text runs, // which starts font loads, whose completion causes another style // change reflow). if (!mPostedFlushUserFontSet) { MOZ_RELEASE_ASSERT(NS_IsMainThread()); nsCOMPtr<nsIRunnable> ev = - NewRunnableMethod(this, &nsIDocument::HandleRebuildUserFontSet); + NewRunnableMethod("nsIDocument::HandleRebuildUserFontSet", + this, + &nsIDocument::HandleRebuildUserFontSet); if (NS_SUCCEEDED(Dispatch("nsIDocument::HandleRebuildUserFontSet", TaskCategory::Other, ev.forget()))) { mPostedFlushUserFontSet = true; } } } FontFaceSet*
--- a/dom/base/nsFocusManager.cpp +++ b/dom/base/nsFocusManager.cpp @@ -2016,20 +2016,24 @@ nsFocusManager::Focus(nsPIDOMWindowOuter if (clearFirstFocusEvent) mFirstFocusEvent = nullptr; } class FocusBlurEvent : public Runnable { public: - FocusBlurEvent(nsISupports* aTarget, EventMessage aEventMessage, - nsPresContext* aContext, bool aWindowRaised, - bool aIsRefocus, EventTarget* aRelatedTarget) - : mTarget(aTarget) + FocusBlurEvent(nsISupports* aTarget, + EventMessage aEventMessage, + nsPresContext* aContext, + bool aWindowRaised, + bool aIsRefocus, + EventTarget* aRelatedTarget) + : mozilla::Runnable("FocusBlurEvent") + , mTarget(aTarget) , mContext(aContext) , mEventMessage(aEventMessage) , mWindowRaised(aWindowRaised) , mIsRefocus(aIsRefocus) , mRelatedTarget(aRelatedTarget) { } @@ -2050,22 +2054,24 @@ public: bool mWindowRaised; bool mIsRefocus; nsCOMPtr<EventTarget> mRelatedTarget; }; class FocusInOutEvent : public Runnable { public: - FocusInOutEvent(nsISupports* aTarget, EventMessage aEventMessage, - nsPresContext* aContext, - nsPIDOMWindowOuter* aOriginalFocusedWindow, - nsIContent* aOriginalFocusedContent, - EventTarget* aRelatedTarget) - : mTarget(aTarget) + FocusInOutEvent(nsISupports* aTarget, + EventMessage aEventMessage, + nsPresContext* aContext, + nsPIDOMWindowOuter* aOriginalFocusedWindow, + nsIContent* aOriginalFocusedContent, + EventTarget* aRelatedTarget) + : mozilla::Runnable("FocusInOutEvent") + , mTarget(aTarget) , mContext(aContext) , mEventMessage(aEventMessage) , mOriginalFocusedWindow(aOriginalFocusedWindow) , mOriginalFocusedContent(aOriginalFocusedContent) , mRelatedTarget(aRelatedTarget) { } @@ -2259,18 +2265,18 @@ nsFocusManager::RaiseWindow(nsPIDOMWindo if (sTestMode) { // In test mode, emulate the existing window being lowered and the new // window being raised. This happens in a separate runnable to avoid // touching multiple windows in the current runnable. nsCOMPtr<nsPIDOMWindowOuter> active(mActiveWindow); nsCOMPtr<nsPIDOMWindowOuter> window(aWindow); RefPtr<nsFocusManager> self(this); - NS_DispatchToCurrentThread( - NS_NewRunnableFunction([self, active, window] () -> void { + NS_DispatchToCurrentThread(NS_NewRunnableFunction( + "nsFocusManager::RaiseWindow", [self, active, window]() -> void { if (active) { self->WindowLowered(active); } self->WindowRaised(window); })); return; } @@ -3618,16 +3624,17 @@ nsFocusManager::GetFocusInSelection(nsPI } while (selectionNode && selectionNode != endSelectionNode); } class PointerUnlocker : public Runnable { public: PointerUnlocker() + : mozilla::Runnable("PointerUnlocker") { MOZ_ASSERT(!PointerUnlocker::sActiveUnlocker); PointerUnlocker::sActiveUnlocker = this; } ~PointerUnlocker() { if (PointerUnlocker::sActiveUnlocker == this) {
--- a/dom/base/nsFrameLoader.cpp +++ b/dom/base/nsFrameLoader.cpp @@ -1980,17 +1980,21 @@ class nsFrameLoaderDestroyRunnable : pub eDestroyComplete }; RefPtr<nsFrameLoader> mFrameLoader; DestroyPhase mPhase; public: explicit nsFrameLoaderDestroyRunnable(nsFrameLoader* aFrameLoader) - : mFrameLoader(aFrameLoader), mPhase(eDestroyDocShell) {} + : mozilla::Runnable("nsFrameLoaderDestroyRunnable") + , mFrameLoader(aFrameLoader) + , mPhase(eDestroyDocShell) + { + } NS_IMETHOD Run() override; }; void nsFrameLoader::StartDestroy() { // nsFrameLoader::StartDestroy is called just before the frameloader is @@ -2065,19 +2069,20 @@ nsFrameLoader::StartDestroy() } // Destroy the other frame loader owners now that we are being destroyed. if (mPartialSHistory && mPartialSHistory->GetActiveState() == nsIPartialSHistory::STATE_ACTIVE) { nsCOMPtr<nsIGroupedSHistory> groupedSHistory; GetGroupedSHistory(getter_AddRefs(groupedSHistory)); if (groupedSHistory) { - NS_DispatchToCurrentThread(NS_NewRunnableFunction([groupedSHistory] () { - groupedSHistory->CloseInactiveFrameLoaderOwners(); - })); + NS_DispatchToCurrentThread(NS_NewRunnableFunction( + "nsFrameLoader::StartDestroy", [groupedSHistory]() { + groupedSHistory->CloseInactiveFrameLoaderOwners(); + })); } } nsCOMPtr<nsIRunnable> destroyRunnable = new nsFrameLoaderDestroyRunnable(this); if (mNeedsAsyncDestroy || !doc || NS_FAILED(doc->FinalizeFrameLoader(this, destroyRunnable))) { NS_DispatchToCurrentThread(destroyRunnable); } @@ -3162,16 +3167,17 @@ nsFrameLoader::DoLoadMessageManagerScrip class nsAsyncMessageToChild : public nsSameProcessAsyncMessageBase, public Runnable { public: nsAsyncMessageToChild(JS::RootingContext* aRootingCx, JS::Handle<JSObject*> aCpows, nsFrameLoader* aFrameLoader) : nsSameProcessAsyncMessageBase(aRootingCx, aCpows) + , mozilla::Runnable("nsAsyncMessageToChild") , mFrameLoader(aFrameLoader) { } NS_IMETHOD Run() override { nsInProcessTabChildGlobal* tabChild = static_cast<nsInProcessTabChildGlobal*>(mFrameLoader->mChildMessageManager.get());
--- a/dom/base/nsFrameMessageManager.cpp +++ b/dom/base/nsFrameMessageManager.cpp @@ -1746,16 +1746,17 @@ nsFrameMessageManager* nsFrameMessageMan class nsAsyncMessageToSameProcessChild : public nsSameProcessAsyncMessageBase, public Runnable { public: nsAsyncMessageToSameProcessChild(JS::RootingContext* aRootingCx, JS::Handle<JSObject*> aCpows) : nsSameProcessAsyncMessageBase(aRootingCx, aCpows) + , mozilla::Runnable("nsAsyncMessageToSameProcessChild") { } NS_IMETHOD Run() override { nsFrameMessageManager* ppm = nsFrameMessageManager::GetChildProcessManager(); ReceiveMessage(static_cast<nsIContentFrameMessageManager*>(ppm), nullptr, ppm); return NS_OK; } };
--- a/dom/base/nsGlobalWindow.cpp +++ b/dom/base/nsGlobalWindow.cpp @@ -3029,18 +3029,18 @@ nsGlobalWindow::SetNewDocument(nsIDocume nsXBLService::AttachGlobalKeyHandler(mChromeEventHandler); } } /* No mDocShell means we're already been partially closed down. When that happens, setting status isn't a big requirement, so don't. (Doesn't happen under normal circumstances, but bug 49615 describes a case.) */ - nsContentUtils::AddScriptRunner( - NewRunnableMethod(this, &nsGlobalWindow::ClearStatus)); + nsContentUtils::AddScriptRunner(NewRunnableMethod( + "nsGlobalWindow::ClearStatus", this, &nsGlobalWindow::ClearStatus)); // Sometimes, WouldReuseInnerWindow() returns true even if there's no inner // window (see bug 776497). Be safe. bool reUseInnerWindow = (aForceReuseInnerWindow || wouldReuseInnerWindow) && GetCurrentInnerWindowInternal(); nsresult rv = NS_OK; @@ -3340,31 +3340,34 @@ nsGlobalWindow::SetNewDocument(nsIDocume } kungFuDeathGrip->DidInitializeContext(); // We wait to fire the debugger hook until the window is all set up and hooked // up with the outer. See bug 969156. if (createdInnerWindow) { nsContentUtils::AddScriptRunner( - NewRunnableMethod(newInnerWindow, + NewRunnableMethod("nsGlobalWindow::FireOnNewGlobalObject", + newInnerWindow, &nsGlobalWindow::FireOnNewGlobalObject)); } if (newInnerWindow && !newInnerWindow->mHasNotifiedGlobalCreated && mDoc) { // We should probably notify. However if this is the, arguably bad, // situation when we're creating a temporary non-chrome-about-blank // document in a chrome docshell, don't notify just yet. Instead wait // until we have a real chrome doc. if (!mDocShell || mDocShell->ItemType() != nsIDocShellTreeItem::typeChrome || nsContentUtils::IsSystemPrincipal(mDoc->NodePrincipal())) { newInnerWindow->mHasNotifiedGlobalCreated = true; nsContentUtils::AddScriptRunner( - NewRunnableMethod(this, &nsGlobalWindow::DispatchDOMWindowCreated)); + NewRunnableMethod("nsGlobalWindow::DispatchDOMWindowCreated", + this, + &nsGlobalWindow::DispatchDOMWindowCreated)); } } PreloadLocalStorage(); // If we have a recorded interesting Large-Allocation header status, report it // to the newly attached document. ReportLargeAllocStatus(); @@ -6865,20 +6868,23 @@ GetFullscreenTransitionDuration(bool aEn &aDuration->mFadeIn, &aDuration->mFadeOut); } } class FullscreenTransitionTask : public Runnable { public: FullscreenTransitionTask(const FullscreenTransitionDuration& aDuration, - nsGlobalWindow* aWindow, bool aFullscreen, - nsIWidget* aWidget, nsIScreen* aScreen, + nsGlobalWindow* aWindow, + bool aFullscreen, + nsIWidget* aWidget, + nsIScreen* aScreen, nsISupports* aTransitionData) - : mWindow(aWindow) + : mozilla::Runnable("FullscreenTransitionTask") + , mWindow(aWindow) , mWidget(aWidget) , mScreen(aScreen) , mTransitionData(aTransitionData) , mDuration(aDuration) , mStage(eBeforeToggle) , mFullscreen(aFullscreen) { } @@ -9204,18 +9210,19 @@ nsGlobalWindow::PostMessageMoz(JSContext aSubjectPrincipal, aRv); } class nsCloseEvent : public Runnable { RefPtr<nsGlobalWindow> mWindow; bool mIndirect; - nsCloseEvent(nsGlobalWindow *aWindow, bool aIndirect) - : mWindow(aWindow) + nsCloseEvent(nsGlobalWindow* aWindow, bool aIndirect) + : mozilla::Runnable("nsCloseEvent") + , mWindow(aWindow) , mIndirect(aIndirect) {} public: static nsresult PostCloseEvent(nsGlobalWindow* aWindow, bool aIndirect) { nsCOMPtr<nsIRunnable> ev = new nsCloseEvent(aWindow, aIndirect); @@ -9634,21 +9641,21 @@ struct BrowserCompartmentMatcher : publi return nsContentUtils::IsSystemOrExpandedPrincipal(pc); } }; class WindowDestroyedEvent final : public Runnable { public: - WindowDestroyedEvent(nsIDOMWindow* aWindow, uint64_t aID, - const char* aTopic) : - mID(aID), - mPhase(Phase::Destroying), - mTopic(aTopic) + WindowDestroyedEvent(nsIDOMWindow* aWindow, uint64_t aID, const char* aTopic) + : mozilla::Runnable("WindowDestroyedEvent") + , mID(aID) + , mPhase(Phase::Destroying) + , mTopic(aTopic) { mWindow = do_GetWeakReference(aWindow); } enum class Phase { Destroying, Nuking @@ -10128,17 +10135,22 @@ nsGlobalWindow::ShowModalDialog(JSContex } class ChildCommandDispatcher : public Runnable { public: ChildCommandDispatcher(nsGlobalWindow* aWindow, nsITabChild* aTabChild, const nsAString& aAction) - : mWindow(aWindow), mTabChild(aTabChild), mAction(aAction) {} + : mozilla::Runnable("ChildCommandDispatcher") + , mWindow(aWindow) + , mTabChild(aTabChild) + , mAction(aAction) + { + } NS_IMETHOD Run() override { nsCOMPtr<nsPIWindowRoot> root = mWindow->GetTopWindowRoot(); if (!root) { return NS_OK; } @@ -10157,17 +10169,21 @@ private: nsString mAction; }; class CommandDispatcher : public Runnable { public: CommandDispatcher(nsIDOMXULCommandDispatcher* aDispatcher, const nsAString& aAction) - : mDispatcher(aDispatcher), mAction(aAction) {} + : mozilla::Runnable("CommandDispatcher") + , mDispatcher(aDispatcher) + , mAction(aAction) + { + } NS_IMETHOD Run() override { return mDispatcher->UpdateCommands(mAction); } nsCOMPtr<nsIDOMXULCommandDispatcher> mDispatcher; nsString mAction; @@ -10949,20 +10965,21 @@ nsGlobalWindow::PageHidden() } mNeedsFocus = true; } class HashchangeCallback : public Runnable { public: - HashchangeCallback(const nsAString &aOldURL, - const nsAString &aNewURL, + HashchangeCallback(const nsAString& aOldURL, + const nsAString& aNewURL, nsGlobalWindow* aWindow) - : mWindow(aWindow) + : mozilla::Runnable("HashchangeCallback") + , mWindow(aWindow) { MOZ_ASSERT(mWindow); MOZ_ASSERT(mWindow->IsInnerWindow()); mOldURL.Assign(aOldURL); mNewURL.Assign(aNewURL); } NS_IMETHOD Run() override @@ -11565,18 +11582,21 @@ nsGlobalWindow::FireOfflineStatusEventIf class NotifyIdleObserverRunnable : public Runnable { public: NotifyIdleObserverRunnable(nsIIdleObserver* aIdleObserver, uint32_t aTimeInS, bool aCallOnidle, nsGlobalWindow* aIdleWindow) - : mIdleObserver(aIdleObserver), mTimeInS(aTimeInS), mIdleWindow(aIdleWindow), - mCallOnidle(aCallOnidle) + : mozilla::Runnable("NotifyIdleObserverRunnable") + , mIdleObserver(aIdleObserver) + , mTimeInS(aTimeInS) + , mIdleWindow(aIdleWindow) + , mCallOnidle(aCallOnidle) { } NS_IMETHOD Run() override { if (mIdleWindow->ContainsIdleObserver(mIdleObserver, mTimeInS)) { return mCallOnidle ? mIdleObserver->Onidle() : mIdleObserver->Onactive(); } return NS_OK; @@ -11674,20 +11694,22 @@ nsGlobalWindow::ScheduleNextIdleObserver NS_ENSURE_SUCCESS(rv, rv); uint32_t callbackTimeMS = 0; if (idleObserver.mTimeInS * 1000 + mIdleFuzzFactor > userIdleTimeMS) { callbackTimeMS = idleObserver.mTimeInS * 1000 - userIdleTimeMS + mIdleFuzzFactor; } mIdleTimer->Cancel(); - rv = mIdleTimer->InitWithFuncCallback(IdleObserverTimerCallback, - this, - callbackTimeMS, - nsITimer::TYPE_ONE_SHOT); + rv = mIdleTimer->InitWithNamedFuncCallback( + IdleObserverTimerCallback, + this, + callbackTimeMS, + nsITimer::TYPE_ONE_SHOT, + "nsGlobalWindow::ScheduleNextIdleObserverCallback"); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } uint32_t nsGlobalWindow::GetFuzzTimeMS() { @@ -11719,20 +11741,22 @@ nsGlobalWindow::ScheduleActiveTimerCallb if (!mAddActiveEventFuzzTime) { return HandleIdleActiveEvent(); } MOZ_ASSERT(mIdleTimer); mIdleTimer->Cancel(); uint32_t fuzzFactorInMS = GetFuzzTimeMS(); - nsresult rv = mIdleTimer->InitWithFuncCallback(IdleActiveTimerCallback, - this, - fuzzFactorInMS, - nsITimer::TYPE_ONE_SHOT); + nsresult rv = mIdleTimer->InitWithNamedFuncCallback( + IdleActiveTimerCallback, + this, + fuzzFactorInMS, + nsITimer::TYPE_ONE_SHOT, + "nsGlobalWindow::ScheduleActiveTimerCallback"); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } nsresult nsGlobalWindow::HandleIdleActiveEvent() { MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!"); @@ -12811,17 +12835,18 @@ public: : mWin(aWin) { MOZ_ASSERT(mWin); MOZ_ASSERT(mWin->IsOuterWindow()); } ~AutoUnblockScriptClosing() { void (nsGlobalWindow::*run)() = &nsGlobalWindow::UnblockScriptedClosing; - nsCOMPtr<nsIRunnable> caller = NewRunnableMethod(mWin, run); + nsCOMPtr<nsIRunnable> caller = NewRunnableMethod( + "AutoUnblockScriptClosing::~AutoUnblockScriptClosing", mWin, run); mWin->Dispatch("nsGlobalWindow::UnblockScriptedClosing", TaskCategory::Other, caller.forget()); } }; nsresult nsGlobalWindow::OpenInternal(const nsAString& aUrl, const nsAString& aName, const nsAString& aOptions, bool aDialog,
--- a/dom/base/nsIGlobalObject.cpp +++ b/dom/base/nsIGlobalObject.cpp @@ -38,16 +38,17 @@ nsIGlobalObject::UnregisterHostObjectURI } namespace { class UnlinkHostObjectURIsRunnable final : public mozilla::Runnable { public: explicit UnlinkHostObjectURIsRunnable(nsTArray<nsCString>& aURIs) + : mozilla::Runnable("UnlinkHostObjectURIsRunnable") { mURIs.SwapElements(aURIs); } NS_IMETHOD Run() override { MOZ_ASSERT(NS_IsMainThread());
--- a/dom/base/nsInProcessTabChildGlobal.cpp +++ b/dom/base/nsInProcessTabChildGlobal.cpp @@ -304,19 +304,25 @@ nsInProcessTabChildGlobal::InitTabChildG nsISupports* scopeSupports = NS_ISUPPORTS_CAST(EventTarget*, this); NS_ENSURE_STATE(InitChildGlobalInternal(scopeSupports, id)); return NS_OK; } class nsAsyncScriptLoad : public Runnable { public: - nsAsyncScriptLoad(nsInProcessTabChildGlobal* aTabChild, const nsAString& aURL, - bool aRunInGlobalScope) - : mTabChild(aTabChild), mURL(aURL), mRunInGlobalScope(aRunInGlobalScope) {} + nsAsyncScriptLoad(nsInProcessTabChildGlobal* aTabChild, + const nsAString& aURL, + bool aRunInGlobalScope) + : mozilla::Runnable("nsAsyncScriptLoad") + , mTabChild(aTabChild) + , mURL(aURL) + , mRunInGlobalScope(aRunInGlobalScope) + { + } NS_IMETHOD Run() override { mTabChild->LoadFrameScript(mURL, mRunInGlobalScope); return NS_OK; } RefPtr<nsInProcessTabChildGlobal> mTabChild; nsString mURL;
--- a/dom/base/nsJSEnvironment.cpp +++ b/dom/base/nsJSEnvironment.cpp @@ -431,17 +431,18 @@ NS_HandleScriptError(nsIScriptGlobalObje class ScriptErrorEvent : public Runnable { public: ScriptErrorEvent(nsPIDOMWindowInner* aWindow, JS::RootingContext* aRootingCx, xpc::ErrorReport* aReport, JS::Handle<JS::Value> aError) - : mWindow(aWindow) + : mozilla::Runnable("ScriptErrorEvent") + , mWindow(aWindow) , mReport(aReport) , mError(aRootingCx, aError) {} NS_IMETHOD Run() override { nsEventStatus status = nsEventStatus_eIgnore; nsPIDOMWindowInner* win = mWindow; @@ -2214,17 +2215,21 @@ nsJSContext::KillICCRunner() } } class NotifyGCEndRunnable : public Runnable { nsString mMessage; public: - explicit NotifyGCEndRunnable(const nsString& aMessage) : mMessage(aMessage) {} + explicit NotifyGCEndRunnable(const nsString& aMessage) + : mozilla::Runnable("NotifyGCEndRunnable") + , mMessage(aMessage) + { + } NS_DECL_NSIRUNNABLE }; NS_IMETHODIMP NotifyGCEndRunnable::Run() { MOZ_ASSERT(NS_IsMainThread()); @@ -2540,17 +2545,18 @@ class AsyncTaskRunnable final : public R { ~AsyncTaskRunnable() { MOZ_ASSERT(!mTask); } public: explicit AsyncTaskRunnable(JS::AsyncTask* aTask) - : mTask(aTask) + : mozilla::Runnable("AsyncTaskRunnable") + , mTask(aTask) { MOZ_ASSERT(mTask); } protected: NS_IMETHOD Run() override { MOZ_ASSERT(NS_IsMainThread());
--- a/dom/base/nsJSEnvironment.h +++ b/dom/base/nsJSEnvironment.h @@ -174,17 +174,18 @@ nsScriptNameSpaceManager* GetNameSpaceMa nsScriptNameSpaceManager* PeekNameSpaceManager(); // Runnable that's used to do async error reporting class AsyncErrorReporter final : public mozilla::Runnable { public: // aWindow may be null if this error report is not associated with a window explicit AsyncErrorReporter(xpc::ErrorReport* aReport) - : mReport(aReport) + : Runnable("dom::AsyncErrorReporter") + , mReport(aReport) {} NS_IMETHOD Run() override { mReport->LogToConsole(); return NS_OK; }
--- a/dom/base/nsObjectLoadingContent.cpp +++ b/dom/base/nsObjectLoadingContent.cpp @@ -274,27 +274,29 @@ public: , mTarget(aTarget) , mDocument(aTarget->GetComposedDoc()) , mEvent(aEvent) { MOZ_ASSERT(aTarget && mDocument); } nsSimplePluginEvent(nsIDocument* aTarget, const nsAString& aEvent) - : mTarget(aTarget) + : mozilla::Runnable("nsSimplePluginEvent") + , mTarget(aTarget) , mDocument(aTarget) , mEvent(aEvent) { MOZ_ASSERT(aTarget); } nsSimplePluginEvent(nsIContent* aTarget, nsIDocument* aDocument, const nsAString& aEvent) - : mTarget(aTarget) + : mozilla::Runnable("nsSimplePluginEvent") + , mTarget(aTarget) , mDocument(aDocument) , mEvent(aEvent) { MOZ_ASSERT(aTarget && aDocument); } ~nsSimplePluginEvent() override = default;
--- a/dom/base/nsReferencedElement.h +++ b/dom/base/nsReferencedElement.h @@ -124,18 +124,22 @@ private: nsReferencedElement* mTarget; }; class ChangeNotification : public mozilla::Runnable, public Notification { public: ChangeNotification(nsReferencedElement* aTarget, - Element* aFrom, Element* aTo) - : Notification(aTarget), mFrom(aFrom), mTo(aTo) + Element* aFrom, + Element* aTo) + : mozilla::Runnable("nsReferencedElement::ChangeNotification") + , Notification(aTarget) + , mFrom(aFrom) + , mTo(aTo) {} NS_DECL_ISUPPORTS_INHERITED NS_IMETHOD Run() override { if (mTarget) { mTarget->mPendingNotification = nullptr; mTarget->ElementChanged(mFrom, mTo); }
--- a/dom/base/nsTextNode.cpp +++ b/dom/base/nsTextNode.cpp @@ -268,17 +268,18 @@ nsAttributeTextNode::AttributeChanged(ns const nsAttrValue* aOldValue) { if (aNameSpaceID == mNameSpaceID && aAttribute == mAttrName && aElement == mGrandparent) { // Since UpdateText notifies, do it when it's safe to run script. Note // that if we get unbound while the event is up that's ok -- we'll just // have no grandparent when it fires, and will do nothing. void (nsAttributeTextNode::*update)() = &nsAttributeTextNode::UpdateText; - nsContentUtils::AddScriptRunner(NewRunnableMethod(this, update)); + nsContentUtils::AddScriptRunner( + NewRunnableMethod("nsAttributeTextNode::AttributeChanged", this, update)); } } void nsAttributeTextNode::NodeWillBeDestroyed(const nsINode* aNode) { NS_ASSERTION(aNode == static_cast<nsINode*>(mGrandparent), "Wrong node!"); mGrandparent = nullptr;
--- a/dom/cache/Context.cpp +++ b/dom/cache/Context.cpp @@ -731,34 +731,39 @@ Context::ThreadsafeHandle::AllowToClose( { if (mOwningEventTarget->IsOnCurrentThread()) { AllowToCloseOnOwningThread(); return; } // Dispatch is guaranteed to succeed here because we block shutdown until // all Contexts have been destroyed. - nsCOMPtr<nsIRunnable> runnable = - NewRunnableMethod(this, &ThreadsafeHandle::AllowToCloseOnOwningThread); + nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod( + "dom::cache::Context::ThreadsafeHandle::AllowToCloseOnOwningThread", + this, + &ThreadsafeHandle::AllowToCloseOnOwningThread); MOZ_ALWAYS_SUCCEEDS( mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL)); } void Context::ThreadsafeHandle::InvalidateAndAllowToClose() { if (mOwningEventTarget->IsOnCurrentThread()) { InvalidateAndAllowToCloseOnOwningThread(); return; } // Dispatch is guaranteed to succeed here because we block shutdown until // all Contexts have been destroyed. - nsCOMPtr<nsIRunnable> runnable = - NewRunnableMethod(this, &ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread); + nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod( + "dom::cache::Context::ThreadsafeHandle::" + "InvalidateAndAllowToCloseOnOwningThread", + this, + &ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread); MOZ_ALWAYS_SUCCEEDS( mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL)); } Context::ThreadsafeHandle::ThreadsafeHandle(Context* aContext) : mStrongRef(aContext) , mWeakRef(aContext) , mOwningEventTarget(GetCurrentThreadSerialEventTarget())
--- a/dom/cache/Manager.cpp +++ b/dom/cache/Manager.cpp @@ -907,17 +907,20 @@ private: void CallOnAsyncCopyCompleteOnTargetThread(nsresult aRv) { // May be on any thread, including STS event target. Non-owning runnable // here since we are guaranteed the Action will survive until // CompleteOnInitiatingThread is called. nsCOMPtr<nsIRunnable> runnable = NewNonOwningRunnableMethod<nsresult>( - this, &CachePutAllAction::OnAsyncCopyComplete, aRv); + "dom::cache::Manager::CachePutAllAction::OnAsyncCopyComplete", + this, + &CachePutAllAction::OnAsyncCopyComplete, + aRv); MOZ_ALWAYS_SUCCEEDS( mTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL)); } void DoResolve(nsresult aRv) { MOZ_ASSERT(mTarget->IsOnCurrentThread()); @@ -1761,17 +1764,18 @@ Manager::~Manager() MOZ_DIAGNOSTIC_ASSERT(mState == Closing); MOZ_DIAGNOSTIC_ASSERT(!mContext); nsCOMPtr<nsIThread> ioThread; mIOThread.swap(ioThread); // Don't spin the event loop in the destructor waiting for the thread to // shutdown. Defer this to the main thread, instead. - MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(NewRunnableMethod(ioThread, &nsIThread::Shutdown))); + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(NewRunnableMethod("nsIThread::Shutdown", + ioThread, &nsIThread::Shutdown))); } void Manager::Init(Manager* aOldManager) { NS_ASSERT_OWNINGTHREAD(Manager); RefPtr<Context> oldContext;
--- a/dom/cache/PrincipalVerifier.cpp +++ b/dom/cache/PrincipalVerifier.cpp @@ -60,17 +60,18 @@ PrincipalVerifier::RemoveListener(Listen AssertIsOnBackgroundThread(); MOZ_DIAGNOSTIC_ASSERT(aListener); MOZ_ALWAYS_TRUE(mListenerList.RemoveElement(aListener)); } PrincipalVerifier::PrincipalVerifier(Listener* aListener, PBackgroundParent* aActor, const PrincipalInfo& aPrincipalInfo) - : mActor(BackgroundParent::GetContentParent(aActor)) + : Runnable("dom::cache::PrincipalVerifier") + , mActor(BackgroundParent::GetContentParent(aActor)) , mPrincipalInfo(aPrincipalInfo) , mInitiatingEventTarget(GetCurrentThreadSerialEventTarget()) , mResult(NS_OK) { AssertIsOnBackgroundThread(); MOZ_DIAGNOSTIC_ASSERT(mInitiatingEventTarget); MOZ_DIAGNOSTIC_ASSERT(aListener);
--- a/dom/cache/ReadStream.cpp +++ b/dom/cache/ReadStream.cpp @@ -127,17 +127,18 @@ private: // Runnable to notify actors that the ReadStream has closed. This must // be done on the thread associated with the PBackground actor. Must be // cancelable to execute on Worker threads (which can occur when the // ReadStream is constructed on a child process Worker thread). class ReadStream::Inner::NoteClosedRunnable final : public CancelableRunnable { public: explicit NoteClosedRunnable(ReadStream::Inner* aStream) - : mStream(aStream) + : CancelableRunnable("dom::cache::ReadStream::Inner::NoteClosedRunnable") + , mStream(aStream) { } NS_IMETHOD Run() override { mStream->NoteClosedOnOwningThread(); mStream = nullptr; return NS_OK; } @@ -162,17 +163,18 @@ private: // closed. Since this can trigger actor destruction, we need to do // it on the thread associated with the PBackground actor. Must be // cancelable to execute on Worker threads (which can occur when the // ReadStream is constructed on a child process Worker thread). class ReadStream::Inner::ForgetRunnable final : public CancelableRunnable { public: explicit ForgetRunnable(ReadStream::Inner* aStream) - : mStream(aStream) + : CancelableRunnable("dom::cache::ReadStream::Inner::ForgetRunnable") + , mStream(aStream) { } NS_IMETHOD Run() override { mStream->ForgetOnOwningThread(); mStream = nullptr; return NS_OK; }
--- a/dom/canvas/CanvasRenderingContext2D.cpp +++ b/dom/canvas/CanvasRenderingContext2D.cpp @@ -1571,18 +1571,19 @@ void CanvasRenderingContext2D::ScheduleStableStateCallback() { if (mHasPendingStableStateCallback) { return; } mHasPendingStableStateCallback = true; nsContentUtils::RunInStableState( - NewRunnableMethod(this, &CanvasRenderingContext2D::OnStableState) - ); + NewRunnableMethod("dom::CanvasRenderingContext2D::OnStableState", + this, + &CanvasRenderingContext2D::OnStableState)); } void CanvasRenderingContext2D::OnStableState() { if (!mHasPendingStableStateCallback) { return; }
--- a/dom/canvas/ImageBitmap.cpp +++ b/dom/canvas/ImageBitmap.cpp @@ -1071,17 +1071,18 @@ private: RefPtr<ImageBitmap> mImageBitmap; }; class FulfillImageBitmapPromiseTask final : public Runnable, public FulfillImageBitmapPromise { public: FulfillImageBitmapPromiseTask(Promise* aPromise, ImageBitmap* aImageBitmap) - : FulfillImageBitmapPromise(aPromise, aImageBitmap) + : Runnable("dom::FulfillImageBitmapPromiseTask") + , FulfillImageBitmapPromise(aPromise, aImageBitmap) { } NS_IMETHOD Run() override { DoFulfillImageBitmapPromise(); return NS_OK; } @@ -1273,17 +1274,18 @@ protected: class CreateImageBitmapFromBlobTask final : public Runnable, public CreateImageBitmapFromBlob { public: CreateImageBitmapFromBlobTask(Promise* aPromise, nsIGlobalObject* aGlobal, Blob& aBlob, const Maybe<IntRect>& aCropRect) - :CreateImageBitmapFromBlob(aPromise, aGlobal, aBlob, aCropRect) + : Runnable("dom::CreateImageBitmapFromBlobTask") + , CreateImageBitmapFromBlob(aPromise, aGlobal, aBlob, aCropRect) { } NS_IMETHOD Run() override { DoCreateImageBitmapFromBlob(); return NS_OK; } @@ -1727,22 +1729,28 @@ protected: }; template<typename T> class MapDataIntoBufferSourceTask final : public Runnable, public MapDataIntoBufferSource<T> { public: MapDataIntoBufferSourceTask(JSContext* aCx, - Promise *aPromise, - ImageBitmap *aImageBitmap, + Promise* aPromise, + ImageBitmap* aImageBitmap, const T& aBuffer, int32_t aOffset, ImageBitmapFormat aFormat) - : MapDataIntoBufferSource<T>(aCx, aPromise, aImageBitmap, aBuffer, aOffset, aFormat) + : Runnable("dom::MapDataIntoBufferSourceTask") + , MapDataIntoBufferSource<T>(aCx, + aPromise, + aImageBitmap, + aBuffer, + aOffset, + aFormat) { } virtual ~MapDataIntoBufferSourceTask() = default; NS_IMETHOD Run() override { MapDataIntoBufferSource<T>::DoMapDataIntoBufferSource();
--- a/dom/canvas/WebGLContext.cpp +++ b/dom/canvas/WebGLContext.cpp @@ -1732,19 +1732,20 @@ WebGLContext::RunContextLossTimer() mContextLossHandler.RunTimer(); } class UpdateContextLossStatusTask : public CancelableRunnable { RefPtr<WebGLContext> mWebGL; public: - explicit UpdateContextLossStatusTask(WebGLContext* webgl) - : mWebGL(webgl) - { + explicit UpdateContextLossStatusTask(WebGLContext* webgl) + : CancelableRunnable("UpdateContextLossStatusTask") + , mWebGL(webgl) + { } NS_IMETHOD Run() override { if (mWebGL) mWebGL->UpdateContextLossStatus(); return NS_OK; }
--- a/dom/canvas/WebGLQuery.cpp +++ b/dom/canvas/WebGLQuery.cpp @@ -13,23 +13,26 @@ namespace mozilla { class AvailableRunnable final : public Runnable { const RefPtr<WebGLQuery> mQuery; public: - explicit AvailableRunnable(WebGLQuery* query) - : mQuery(query) - { } + explicit AvailableRunnable(WebGLQuery* query) + : Runnable("AvailableRunnable") + , mQuery(query) + { + } - NS_IMETHOD Run() override { - mQuery->mCanBeAvailable = true; - return NS_OK; + NS_IMETHOD Run() override + { + mQuery->mCanBeAvailable = true; + return NS_OK; } }; //// static GLuint GenQuery(gl::GLContext* gl) {
--- a/dom/events/AsyncEventDispatcher.cpp +++ b/dom/events/AsyncEventDispatcher.cpp @@ -17,18 +17,19 @@ namespace mozilla { using namespace dom; /****************************************************************************** * mozilla::AsyncEventDispatcher ******************************************************************************/ AsyncEventDispatcher::AsyncEventDispatcher(EventTarget* aTarget, WidgetEvent& aEvent) - : mTarget(aTarget), - mEventMessage(eUnidentifiedEvent) + : CancelableRunnable("AsyncEventDispatcher") + , mTarget(aTarget) + , mEventMessage(eUnidentifiedEvent) { MOZ_ASSERT(mTarget); RefPtr<Event> event = EventDispatcher::CreateEvent(aTarget, nullptr, &aEvent, EmptyString()); mEvent = event.forget(); mEventType.SetIsVoid(true); NS_ASSERTION(mEvent, "Should never fail to create an event"); mEvent->DuplicatePrivateData();
--- a/dom/events/AsyncEventDispatcher.h +++ b/dom/events/AsyncEventDispatcher.h @@ -29,66 +29,73 @@ class AsyncEventDispatcher : public Canc { public: /** * If aOnlyChromeDispatch is true, the event is dispatched to only * chrome node. In that case, if aTarget is already a chrome node, * the event is dispatched to it, otherwise the dispatch path starts * at the first chrome ancestor of that target. */ - AsyncEventDispatcher(nsINode* aTarget, const nsAString& aEventType, - bool aBubbles, bool aOnlyChromeDispatch) - : mTarget(aTarget) + AsyncEventDispatcher(nsINode* aTarget, + const nsAString& aEventType, + bool aBubbles, + bool aOnlyChromeDispatch) + : CancelableRunnable("AsyncEventDispatcher") + , mTarget(aTarget) , mEventType(aEventType) , mEventMessage(eUnidentifiedEvent) , mBubbles(aBubbles) , mOnlyChromeDispatch(aOnlyChromeDispatch) { } /** * If aOnlyChromeDispatch is true, the event is dispatched to only * chrome node. In that case, if aTarget is already a chrome node, * the event is dispatched to it, otherwise the dispatch path starts * at the first chrome ancestor of that target. */ AsyncEventDispatcher(nsINode* aTarget, mozilla::EventMessage aEventMessage, bool aBubbles, bool aOnlyChromeDispatch) - : mTarget(aTarget) + : CancelableRunnable("AsyncEventDispatcher") + , mTarget(aTarget) , mEventMessage(aEventMessage) , mBubbles(aBubbles) , mOnlyChromeDispatch(aOnlyChromeDispatch) { mEventType.SetIsVoid(true); MOZ_ASSERT(mEventMessage != eUnidentifiedEvent); } AsyncEventDispatcher(dom::EventTarget* aTarget, const nsAString& aEventType, bool aBubbles) - : mTarget(aTarget) + : CancelableRunnable("AsyncEventDispatcher") + , mTarget(aTarget) , mEventType(aEventType) , mEventMessage(eUnidentifiedEvent) , mBubbles(aBubbles) { } AsyncEventDispatcher(dom::EventTarget* aTarget, mozilla::EventMessage aEventMessage, bool aBubbles) - : mTarget(aTarget) + : CancelableRunnable("AsyncEventDispatcher") + , mTarget(aTarget) , mEventMessage(aEventMessage) , mBubbles(aBubbles) { mEventType.SetIsVoid(true); MOZ_ASSERT(mEventMessage != eUnidentifiedEvent); } AsyncEventDispatcher(dom::EventTarget* aTarget, nsIDOMEvent* aEvent) - : mTarget(aTarget) + : CancelableRunnable("AsyncEventDispatcher") + , mTarget(aTarget) , mEvent(aEvent) , mEventMessage(eUnidentifiedEvent) { } AsyncEventDispatcher(dom::EventTarget* aTarget, WidgetEvent& aEvent); NS_IMETHOD Run() override;
--- a/dom/events/DataTransferItem.cpp +++ b/dom/events/DataTransferItem.cpp @@ -441,19 +441,20 @@ DataTransferItem::GetAsString(FunctionSt if (NS_WARN_IF(NS_FAILED(rv))) { return; } // Dispatch the callback to the main thread class GASRunnable final : public Runnable { public: - GASRunnable(FunctionStringCallback* aCallback, - const nsAString& aStringData) - : mCallback(aCallback), mStringData(aStringData) + GASRunnable(FunctionStringCallback* aCallback, const nsAString& aStringData) + : mozilla::Runnable("GASRunnable") + , mCallback(aCallback) + , mStringData(aStringData) {} NS_IMETHOD Run() override { ErrorResult rv; mCallback->Call(mStringData, rv); NS_WARNING_ASSERTION(!rv.Failed(), "callback failed"); return rv.StealNSResult();
--- a/dom/events/EventStateManager.cpp +++ b/dom/events/EventStateManager.cpp @@ -1407,19 +1407,22 @@ EventStateManager::CreateClickHoldTimer( return; } mClickHoldTimer = do_CreateInstance("@mozilla.org/timer;1"); if (mClickHoldTimer) { int32_t clickHoldDelay = Preferences::GetInt("ui.click_hold_context_menus.delay", 500); mClickHoldTimer->SetTarget(SystemGroup::EventTargetFor(TaskCategory::Other)); - mClickHoldTimer->InitWithFuncCallback(sClickHoldCallback, this, - clickHoldDelay, - nsITimer::TYPE_ONE_SHOT); + mClickHoldTimer->InitWithNamedFuncCallback( + sClickHoldCallback, + this, + clickHoldDelay, + nsITimer::TYPE_ONE_SHOT, + "EventStateManager::CreateClickHoldTimer"); } } // CreateClickHoldTimer // // KillClickHoldTimer // // Stop the timer that would show the context menu dead in its tracks //
--- a/dom/events/TextComposition.cpp +++ b/dom/events/TextComposition.cpp @@ -707,22 +707,23 @@ TextComposition::HasEditor() const return !!editor; } /****************************************************************************** * TextComposition::CompositionEventDispatcher ******************************************************************************/ TextComposition::CompositionEventDispatcher::CompositionEventDispatcher( - TextComposition* aComposition, - nsINode* aEventTarget, - EventMessage aEventMessage, - const nsAString& aData, - bool aIsSynthesizedEvent) - : mTextComposition(aComposition) + TextComposition* aComposition, + nsINode* aEventTarget, + EventMessage aEventMessage, + const nsAString& aData, + bool aIsSynthesizedEvent) + : Runnable("TextComposition::CompositionEventDispatcher") + , mTextComposition(aComposition) , mEventTarget(aEventTarget) , mData(aData) , mEventMessage(aEventMessage) , mIsSynthesizedEvent(aIsSynthesizedEvent) { } NS_IMETHODIMP
--- a/dom/events/TextComposition.h +++ b/dom/events/TextComposition.h @@ -428,17 +428,19 @@ private: private: RefPtr<TextComposition> mTextComposition; nsCOMPtr<nsINode> mEventTarget; nsString mData; EventMessage mEventMessage; bool mIsSynthesizedEvent; - CompositionEventDispatcher() : mIsSynthesizedEvent(false) {}; + CompositionEventDispatcher() + : Runnable("TextComposition::CompositionEventDispatcher") + , mIsSynthesizedEvent(false){}; }; /** * DispatchCompositionEventRunnable() dispatches a composition event to the * content. Be aware, if you use this method, nsPresShellEventCB isn't used. * That means that nsIFrame::HandleEvent() is never called. * WARNING: The instance which is managed by IMEStateManager may be * destroyed by this method call.
--- a/dom/events/WheelHandlingHelper.cpp +++ b/dom/events/WheelHandlingHelper.cpp @@ -327,18 +327,21 @@ WheelTransaction::SetTimeout() nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID); if (!timer) { return; } timer.swap(sTimer); } sTimer->Cancel(); DebugOnly<nsresult> rv = - sTimer->InitWithFuncCallback(OnTimeout, nullptr, GetTimeoutTime(), - nsITimer::TYPE_ONE_SHOT); + sTimer->InitWithNamedFuncCallback(OnTimeout, + nullptr, + GetTimeoutTime(), + nsITimer::TYPE_ONE_SHOT, + "WheelTransaction::SetTimeout"); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "nsITimer::InitWithFuncCallback failed"); } /* static */ LayoutDeviceIntPoint WheelTransaction::GetScreenPoint(WidgetGUIEvent* aEvent) { NS_ASSERTION(aEvent, "aEvent is null");
--- a/dom/fetch/Fetch.cpp +++ b/dom/fetch/Fetch.cpp @@ -70,17 +70,18 @@ class FetchSignalProxy final : public Fe // This runnable propagates changes from the FetchSignal on workers to the // FetchSignal on main-thread. class FetchSignalProxyRunnable final : public Runnable { RefPtr<FetchSignalProxy> mProxy; public: explicit FetchSignalProxyRunnable(FetchSignalProxy* aProxy) - : mProxy(aProxy) + : Runnable("dom::FetchSignalProxy::FetchSignalProxyRunnable") + , mProxy(aProxy) {} NS_IMETHOD Run() override { MOZ_ASSERT(NS_IsMainThread()); FetchSignal* signal = mProxy->GetOrCreateSignalForMainThread(); signal->Abort(); @@ -259,17 +260,18 @@ private: class MainThreadFetchRunnable : public Runnable { RefPtr<WorkerFetchResolver> mResolver; RefPtr<InternalRequest> mRequest; public: MainThreadFetchRunnable(WorkerFetchResolver* aResolver, InternalRequest* aRequest) - : mResolver(aResolver) + : Runnable("dom::MainThreadFetchRunnable") + , mResolver(aResolver) , mRequest(aRequest) { MOZ_ASSERT(mResolver); } NS_IMETHOD Run() override {
--- a/dom/fetch/FetchConsumer.cpp +++ b/dom/fetch/FetchConsumer.cpp @@ -53,17 +53,18 @@ public: template <class Derived> class BeginConsumeBodyRunnable final : public Runnable { RefPtr<FetchBodyConsumer<Derived>> mFetchBodyConsumer; public: explicit BeginConsumeBodyRunnable(FetchBodyConsumer<Derived>* aConsumer) - : mFetchBodyConsumer(aConsumer) + : Runnable("BeginConsumeBodyRunnable") + , mFetchBodyConsumer(aConsumer) { } NS_IMETHOD Run() override { mFetchBodyConsumer->BeginConsumeBodyMainThread(); return NS_OK; }
--- a/dom/fetch/FetchDriver.cpp +++ b/dom/fetch/FetchDriver.cpp @@ -638,17 +638,18 @@ namespace { // Runnable to call the observer OnDataAvailable on the main-thread. class DataAvailableRunnable final : public Runnable { RefPtr<FetchDriverObserver> mObserver; public: explicit DataAvailableRunnable(FetchDriverObserver* aObserver) - : mObserver(aObserver) + : Runnable("dom::DataAvailableRunnable") + , mObserver(aObserver) { MOZ_ASSERT(aObserver); } NS_IMETHOD Run() override { mObserver->OnDataAvailable();
--- a/dom/file/MutableBlobStorage.cpp +++ b/dom/file/MutableBlobStorage.cpp @@ -26,17 +26,18 @@ namespace { // error must be propagated. class BlobCreationDoneRunnable final : public Runnable { public: BlobCreationDoneRunnable(MutableBlobStorage* aBlobStorage, MutableBlobStorageCallback* aCallback, Blob* aBlob, nsresult aRv) - : mBlobStorage(aBlobStorage) + : Runnable("dom::BlobCreationDoneRunnable") + , mBlobStorage(aBlobStorage) , mCallback(aCallback) , mBlob(aBlob) , mRv(aRv) { MOZ_ASSERT(aBlobStorage); MOZ_ASSERT(aCallback); MOZ_ASSERT((NS_FAILED(aRv) && !aBlob) || (NS_SUCCEEDED(aRv) && aBlob)); @@ -74,17 +75,18 @@ private: }; // This runnable goes back to the main-thread and informs the BlobStorage about // the temporary file. class FileCreatedRunnable final : public Runnable { public: FileCreatedRunnable(MutableBlobStorage* aBlobStorage, PRFileDesc* aFD) - : mBlobStorage(aBlobStorage) + : Runnable("dom::FileCreatedRunnable") + , mBlobStorage(aBlobStorage) , mFD(aFD) { MOZ_ASSERT(aBlobStorage); MOZ_ASSERT(aFD); } NS_IMETHOD Run() override @@ -109,17 +111,18 @@ private: }; // This runnable creates the temporary file. When done, FileCreatedRunnable is // dispatched back to the main-thread. class CreateTemporaryFileRunnable final : public Runnable { public: explicit CreateTemporaryFileRunnable(MutableBlobStorage* aBlobStorage) - : mBlobStorage(aBlobStorage) + : Runnable("dom::CreateTemporaryFileRunnable") + , mBlobStorage(aBlobStorage) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(XRE_IsParentProcess()); MOZ_ASSERT(aBlobStorage); } NS_IMETHOD Run() override @@ -143,17 +146,18 @@ private: RefPtr<MutableBlobStorage> mBlobStorage; }; // Simple runnable to propagate the error to the BlobStorage. class ErrorPropagationRunnable final : public Runnable { public: ErrorPropagationRunnable(MutableBlobStorage* aBlobStorage, nsresult aRv) - : mBlobStorage(aBlobStorage) + : Runnable("dom::ErrorPropagationRunnable") + , mBlobStorage(aBlobStorage) , mRv(aRv) {} NS_IMETHOD Run() override { mBlobStorage->ErrorPropagated(mRv); return NS_OK; @@ -212,19 +216,22 @@ public: new ErrorPropagationRunnable(mBlobStorage, NS_ERROR_FAILURE), NS_DISPATCH_NORMAL); } return NS_OK; } private: - WriteRunnable(MutableBlobStorage* aBlobStorage, PRFileDesc* aFD, - void* aData, uint32_t aLength) - : mBlobStorage(aBlobStorage) + WriteRunnable(MutableBlobStorage* aBlobStorage, + PRFileDesc* aFD, + void* aData, + uint32_t aLength) + : Runnable("dom::WriteRunnable") + , mBlobStorage(aBlobStorage) , mFD(aFD) , mData(aData) , mLength(aLength) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(mBlobStorage); MOZ_ASSERT(aFD); MOZ_ASSERT(aData); @@ -242,17 +249,18 @@ private: }; // This runnable closes the FD in case something goes wrong or the temporary // file is not needed anymore. class CloseFileRunnable final : public Runnable { public: explicit CloseFileRunnable(PRFileDesc* aFD) - : mFD(aFD) + : Runnable("dom::CloseFileRunnable") + , mFD(aFD) {} NS_IMETHOD Run() override { MOZ_ASSERT(!NS_IsMainThread()); PR_Close(mFD); mFD = nullptr; @@ -274,17 +282,18 @@ private: // task is to create the blob and inform the callback. class CreateBlobRunnable final : public Runnable { public: CreateBlobRunnable(MutableBlobStorage* aBlobStorage, already_AddRefed<nsISupports> aParent, const nsACString& aContentType, already_AddRefed<MutableBlobStorageCallback> aCallback) - : mBlobStorage(aBlobStorage) + : Runnable("dom::CreateBlobRunnable") + , mBlobStorage(aBlobStorage) , mParent(aParent) , mContentType(aContentType) , mCallback(aCallback) { MOZ_ASSERT(!NS_IsMainThread()); MOZ_ASSERT(aBlobStorage); } @@ -322,17 +331,18 @@ private: // it dispatches a CreateBlobRunnable to the main-thread. class LastRunnable final : public Runnable { public: LastRunnable(MutableBlobStorage* aBlobStorage, nsISupports* aParent, const nsACString& aContentType, MutableBlobStorageCallback* aCallback) - : mBlobStorage(aBlobStorage) + : Runnable("dom::LastRunnable") + , mBlobStorage(aBlobStorage) , mParent(aParent) , mContentType(aContentType) , mCallback(aCallback) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(mBlobStorage); MOZ_ASSERT(aCallback); }
--- a/dom/file/ipc/IPCBlobInputStream.cpp +++ b/dom/file/ipc/IPCBlobInputStream.cpp @@ -41,17 +41,18 @@ public: mCallback = nullptr; mStream = nullptr; return NS_OK; } private: CallbackRunnable(nsIInputStreamCallback* aCallback, IPCBlobInputStream* aStream) - : mCallback(aCallback) + : CancelableRunnable("dom::CallbackRunnable") + , mCallback(aCallback) , mStream(aStream) { MOZ_ASSERT(mCallback); MOZ_ASSERT(mStream); } nsCOMPtr<nsIInputStreamCallback> mCallback; RefPtr<IPCBlobInputStream> mStream;
--- a/dom/file/ipc/IPCBlobInputStreamChild.cpp +++ b/dom/file/ipc/IPCBlobInputStreamChild.cpp @@ -20,17 +20,18 @@ using namespace workers; namespace { // This runnable is used in case the last stream is forgotten on the 'wrong' // thread. class ShutdownRunnable final : public CancelableRunnable { public: explicit ShutdownRunnable(IPCBlobInputStreamChild* aActor) - : mActor(aActor) + : CancelableRunnable("dom::ShutdownRunnable") + , mActor(aActor) {} NS_IMETHOD Run() override { mActor->Shutdown(); return NS_OK; } @@ -40,17 +41,18 @@ private: }; // This runnable is used in case StreamNeeded() has been called on a non-owning // thread. class StreamNeededRunnable final : public CancelableRunnable { public: explicit StreamNeededRunnable(IPCBlobInputStreamChild* aActor) - : mActor(aActor) + : CancelableRunnable("dom::StreamNeededRunnable") + , mActor(aActor) {} NS_IMETHOD Run() override { MOZ_ASSERT(mActor->State() != IPCBlobInputStreamChild::eActiveMigrating && mActor->State() != IPCBlobInputStreamChild::eInactiveMigrating); if (mActor->State() == IPCBlobInputStreamChild::eActive) { @@ -65,17 +67,18 @@ private: // When the stream has been received from the parent, we inform the // IPCBlobInputStream. class StreamReadyRunnable final : public CancelableRunnable { public: StreamReadyRunnable(IPCBlobInputStream* aDestinationStream, nsIInputStream* aCreatedStream) - : mDestinationStream(aDestinationStream) + : CancelableRunnable("dom::StreamReadyRunnable") + , mDestinationStream(aDestinationStream) , mCreatedStream(aCreatedStream) { MOZ_ASSERT(mDestinationStream); // mCreatedStream can be null. } NS_IMETHOD Run() override @@ -97,18 +100,20 @@ public: // We must keep the worker alive until the migration is completed. return true; } }; class ReleaseWorkerHolderRunnable final : public CancelableRunnable { public: - explicit ReleaseWorkerHolderRunnable(UniquePtr<workers::WorkerHolder>&& aWorkerHolder) - : mWorkerHolder(Move(aWorkerHolder)) + explicit ReleaseWorkerHolderRunnable( + UniquePtr<workers::WorkerHolder>&& aWorkerHolder) + : CancelableRunnable("dom::ReleaseWorkerHolderRunnable") + , mWorkerHolder(Move(aWorkerHolder)) {} NS_IMETHOD Run() override { mWorkerHolder = nullptr; return NS_OK; }
--- a/dom/file/ipc/IPCBlobInputStreamThread.cpp +++ b/dom/file/ipc/IPCBlobInputStreamThread.cpp @@ -22,16 +22,18 @@ namespace { StaticMutex gIPCBlobThreadMutex; StaticRefPtr<IPCBlobInputStreamThread> gIPCBlobThread; bool gShutdownHasStarted = false; class ThreadInitializeRunnable final : public Runnable { public: + ThreadInitializeRunnable() : Runnable("dom::ThreadInitializeRunnable") {} + NS_IMETHOD Run() override { mozilla::StaticMutexAutoLock lock(gIPCBlobThreadMutex); MOZ_ASSERT(gIPCBlobThread); gIPCBlobThread->Initialize(); return NS_OK; } @@ -39,17 +41,18 @@ public: class MigrateActorRunnable final : public Runnable , public nsIIPCBackgroundChildCreateCallback { public: NS_DECL_ISUPPORTS_INHERITED explicit MigrateActorRunnable(IPCBlobInputStreamChild* aActor) - : mActor(aActor) + : Runnable("dom::MigrateActorRunnable") + , mActor(aActor) { MOZ_ASSERT(mActor); } NS_IMETHOD Run() override { BackgroundChild::GetOrCreateForCurrentThread(this);
--- a/dom/filehandle/ActorsParent.cpp +++ b/dom/filehandle/ActorsParent.cpp @@ -583,17 +583,18 @@ class CopyFileHandleOp::ProgressRunnable RefPtr<CopyFileHandleOp> mCopyFileHandleOp; uint64_t mProgress; uint64_t mProgressMax; public: ProgressRunnable(CopyFileHandleOp* aCopyFileHandleOp, uint64_t aProgress, uint64_t aProgressMax) - : mCopyFileHandleOp(aCopyFileHandleOp) + : Runnable("dom::CopyFileHandleOp::ProgressRunnable") + , mCopyFileHandleOp(aCopyFileHandleOp) , mProgress(aProgress) , mProgressMax(aProgressMax) { } private: ~ProgressRunnable() {} NS_DECL_NSIRUNNABLE @@ -1076,20 +1077,21 @@ FileHandleThreadPool::MaybeFireCallback( return false; } } aCallback->mCallback->Run(); return true; } -FileHandleThreadPool:: -FileHandleQueue::FileHandleQueue(FileHandleThreadPool* aFileHandleThreadPool, - FileHandle* aFileHandle) - : mOwningFileHandleThreadPool(aFileHandleThreadPool) +FileHandleThreadPool::FileHandleQueue::FileHandleQueue( + FileHandleThreadPool* aFileHandleThreadPool, + FileHandle* aFileHandle) + : Runnable("dom::FileHandleThreadPool::FileHandleQueue") + , mOwningFileHandleThreadPool(aFileHandleThreadPool) , mFileHandle(aFileHandle) , mShouldFinish(false) { MOZ_ASSERT(aFileHandleThreadPool); aFileHandleThreadPool->AssertIsOnOwningThread(); MOZ_ASSERT(aFileHandle); }
--- a/dom/filesystem/FileSystemRequestParent.cpp +++ b/dom/filesystem/FileSystemRequestParent.cpp @@ -77,17 +77,18 @@ namespace { class CheckPermissionRunnable final : public Runnable { public: CheckPermissionRunnable(already_AddRefed<ContentParent> aParent, FileSystemRequestParent* aActor, FileSystemTaskParentBase* aTask, const nsAString& aPath) - : mContentParent(aParent) + : Runnable("dom::CheckPermissionRunnable") + , mContentParent(aParent) , mActor(aActor) , mTask(aTask) , mPath(aPath) , mBackgroundEventTarget(GetCurrentThreadEventTarget()) { AssertIsInMainProcess(); AssertIsOnBackgroundThread();
--- a/dom/filesystem/FileSystemTaskBase.cpp +++ b/dom/filesystem/FileSystemTaskBase.cpp @@ -226,20 +226,22 @@ FileSystemTaskChildBase::SetError(const { mErrorValue = FileSystemErrorFromNsError(aErrorValue); } /** * FileSystemTaskParentBase class */ -FileSystemTaskParentBase::FileSystemTaskParentBase(FileSystemBase* aFileSystem, - const FileSystemParams& aParam, - FileSystemRequestParent* aParent) - : mErrorValue(NS_OK) +FileSystemTaskParentBase::FileSystemTaskParentBase( + FileSystemBase* aFileSystem, + const FileSystemParams& aParam, + FileSystemRequestParent* aParent) + : Runnable("dom::FileSystemTaskParentBase") + , mErrorValue(NS_OK) , mFileSystem(aFileSystem) , mRequestParent(aParent) , mBackgroundEventTarget(GetCurrentThreadEventTarget()) { MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!"); MOZ_ASSERT(aFileSystem, "aFileSystem should not be null."); MOZ_ASSERT(aParent);
--- a/dom/filesystem/GetFilesHelper.cpp +++ b/dom/filesystem/GetFilesHelper.cpp @@ -56,16 +56,17 @@ public: return NS_OK; } private: ReleaseRunnable(nsTArray<RefPtr<Promise>>& aPromises, nsTArray<RefPtr<GetFilesCallback>>& aCallbacks, Sequence<RefPtr<File>>& aFiles, already_AddRefed<nsIGlobalObject> aGlobal) + : Runnable("dom::ReleaseRunnable") { mPromises.SwapElements(aPromises); mCallbacks.SwapElements(aCallbacks); mFiles.SwapElements(aFiles); mGlobal = aGlobal; } nsTArray<RefPtr<Promise>> mPromises;
--- a/dom/flyweb/HttpServer.cpp +++ b/dom/flyweb/HttpServer.cpp @@ -84,20 +84,19 @@ HttpServer::HandleCert(nsIX509Cert* aCer return NS_OK; } void HttpServer::NotifyStarted(nsresult aStatus) { RefPtr<HttpServerListener> listener = mListener; - nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction([listener, aStatus] () - { - listener->OnServerStarted(aStatus); - }); + nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction( + "dom::HttpServer::NotifyStarted", + [listener, aStatus]() { listener->OnServerStarted(aStatus); }); NS_DispatchToCurrentThread(event); } nsresult HttpServer::StartServerSocket(nsIX509Cert* aCert) { nsresult rv; mServerSocket = @@ -283,22 +282,22 @@ HttpServer::TransportProvider::SetTransp MaybeNotify(); } void HttpServer::TransportProvider::MaybeNotify() { if (mTransport && mListener) { RefPtr<TransportProvider> self = this; - nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction([self, this] () - { - DebugOnly<nsresult> rv = mListener->OnTransportAvailable(mTransport, - mInput, mOutput); - MOZ_ASSERT(NS_SUCCEEDED(rv)); - }); + nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction( + "dom::HttpServer::TransportProvider::MaybeNotify", [self, this]() { + DebugOnly<nsresult> rv = + mListener->OnTransportAvailable(mTransport, mInput, mOutput); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + }); NS_DispatchToCurrentThread(event); } } NS_IMPL_ISUPPORTS(HttpServer::Connection, nsIInputStreamCallback, nsIOutputStreamCallback) @@ -628,21 +627,19 @@ HttpServer::Connection::ConsumeLine(cons LOG_V("HttpServer::Connection::ConsumeLine(%p) - Fire OnWebSocket", this); mState = ePause; mPendingWebSocketRequest = mPendingReq.forget(); mPendingReqVersion = 0; RefPtr<HttpServerListener> listener = mServer->mListener; RefPtr<InternalRequest> request = mPendingWebSocketRequest; - nsCOMPtr<nsIRunnable> event = - NS_NewRunnableFunction([listener, request] () - { - listener->OnWebSocket(request); - }); + nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction( + "dom::HttpServer::Connection::ConsumeLine", + [listener, request]() { listener->OnWebSocket(request); }); NS_DispatchToCurrentThread(event); return NS_OK; } nsAutoCString header; mPendingReq->Headers()->GetFirst(NS_LITERAL_CSTRING("connection"), header, @@ -697,21 +694,19 @@ HttpServer::Connection::ConsumeLine(cons } mPendingRequests.AppendElement(PendingRequest(mPendingReq, nullptr)); LOG_V("HttpServer::Connection::ConsumeLine(%p) - Fire OnRequest", this); RefPtr<HttpServerListener> listener = mServer->mListener; RefPtr<InternalRequest> request = mPendingReq.forget(); - nsCOMPtr<nsIRunnable> event = - NS_NewRunnableFunction([listener, request] () - { - listener->OnRequest(request); - }); + nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction( + "dom::HttpServer::Connection::ConsumeLine", + [listener, request]() { listener->OnRequest(request); }); NS_DispatchToCurrentThread(event); mPendingReqVersion = 0; return NS_OK; } // Parse header line
--- a/dom/gamepad/cocoa/CocoaGamepad.cpp +++ b/dom/gamepad/cocoa/CocoaGamepad.cpp @@ -230,17 +230,17 @@ class DarwinGamepadServiceStartupRunnabl private: ~DarwinGamepadServiceStartupRunnable() {} // This Runnable schedules startup of DarwinGamepadService // in a new thread, pointer to DarwinGamepadService is only // used by this Runnable within its thread. DarwinGamepadService MOZ_NON_OWNING_REF *mService; public: explicit DarwinGamepadServiceStartupRunnable(DarwinGamepadService *service) - : mService(service) {} + : Runnable("DarwinGamepadServiceStartupRunnable"), mService(service) {} NS_IMETHOD Run() override { MOZ_ASSERT(mService); mService->StartupInternal(); return NS_OK; } };
--- a/dom/gamepad/ipc/GamepadEventChannelChild.cpp +++ b/dom/gamepad/ipc/GamepadEventChannelChild.cpp @@ -7,25 +7,28 @@ namespace mozilla { namespace dom{ namespace { class GamepadUpdateRunnable final : public Runnable { public: - explicit GamepadUpdateRunnable(const GamepadChangeEvent& aGamepadEvent) - : mEvent(aGamepadEvent) {} - NS_IMETHOD Run() override - { - RefPtr<GamepadManager> svc(GamepadManager::GetService()); - if (svc) { - svc->Update(mEvent); - } - return NS_OK; + explicit GamepadUpdateRunnable(const GamepadChangeEvent& aGamepadEvent) + : Runnable("dom::GamepadUpdateRunnable") + , mEvent(aGamepadEvent) + { + } + NS_IMETHOD Run() override + { + RefPtr<GamepadManager> svc(GamepadManager::GetService()); + if (svc) { + svc->Update(mEvent); + } + return NS_OK; } protected: GamepadChangeEvent mEvent; }; } // namespace mozilla::ipc::IPCResult
--- a/dom/gamepad/ipc/GamepadEventChannelParent.cpp +++ b/dom/gamepad/ipc/GamepadEventChannelParent.cpp @@ -15,22 +15,23 @@ namespace { class SendGamepadUpdateRunnable final : public Runnable { private: ~SendGamepadUpdateRunnable() {} RefPtr<GamepadEventChannelParent> mParent; GamepadChangeEvent mEvent; public: - SendGamepadUpdateRunnable(GamepadEventChannelParent* aParent, - GamepadChangeEvent aEvent) - : mEvent(aEvent) - { - MOZ_ASSERT(aParent); - mParent = aParent; + SendGamepadUpdateRunnable(GamepadEventChannelParent* aParent, + GamepadChangeEvent aEvent) + : Runnable("dom::SendGamepadUpdateRunnable") + , mEvent(aEvent) + { + MOZ_ASSERT(aParent); + mParent = aParent; } NS_IMETHOD Run() override { AssertIsOnBackgroundThread(); if(mParent->HasGamepadListener()) { Unused << mParent->SendGamepadUpdate(mEvent); } return NS_OK;
--- a/dom/gamepad/windows/WindowsGamepad.cpp +++ b/dom/gamepad/windows/WindowsGamepad.cpp @@ -997,17 +997,19 @@ GamepadWindowProc(HWND hwnd, UINT msg, W break; } return DefWindowProc(hwnd, msg, wParam, lParam); } class StartWindowsGamepadServiceRunnable final : public Runnable { public: - StartWindowsGamepadServiceRunnable() {} + StartWindowsGamepadServiceRunnable() + : Runnable("StartWindowsGamepadServiceRunnable") + {} NS_IMETHOD Run() override { MOZ_ASSERT(NS_GetCurrentThread() == gMonitorThread); gService = new WindowsGamepadService(); gService->Startup(); if (sHWnd == nullptr) { @@ -1035,17 +1037,19 @@ public: } private: ~StartWindowsGamepadServiceRunnable() {} }; class StopWindowsGamepadServiceRunnable final : public Runnable { public: - StopWindowsGamepadServiceRunnable() {} + StopWindowsGamepadServiceRunnable() + : Runnable("StopWindowsGamepadServiceRunnable") + {} NS_IMETHOD Run() override { MOZ_ASSERT(NS_GetCurrentThread() == gMonitorThread); if (sHWnd) { RegisterRawInput(sHWnd, false); DestroyWindow(sHWnd); sHWnd = nullptr;
--- a/dom/geolocation/nsGeolocation.cpp +++ b/dom/geolocation/nsGeolocation.cpp @@ -142,17 +142,18 @@ CreatePositionOptionsCopy(const Position return geoOptions; } class RequestPromptEvent : public Runnable { public: RequestPromptEvent(nsGeolocationRequest* aRequest, nsWeakPtr aWindow) - : mRequest(aRequest) + : mozilla::Runnable("RequestPromptEvent") + , mRequest(aRequest) , mWindow(aWindow) { } NS_IMETHOD Run() override { nsCOMPtr<nsPIDOMWindowInner> window = do_QueryReferent(mWindow); nsContentPermissionUtils::AskPermission(mRequest, window); @@ -163,18 +164,19 @@ private: RefPtr<nsGeolocationRequest> mRequest; nsWeakPtr mWindow; }; class RequestAllowEvent : public Runnable { public: RequestAllowEvent(int allow, nsGeolocationRequest* request) - : mAllow(allow), - mRequest(request) + : mozilla::Runnable("RequestAllowEvent") + , mAllow(allow) + , mRequest(request) { } NS_IMETHOD Run() override { if (mAllow) { mRequest->Allow(JS::UndefinedHandleValue); } else { mRequest->Cancel(); @@ -187,18 +189,19 @@ private: RefPtr<nsGeolocationRequest> mRequest; }; class RequestSendLocationEvent : public Runnable { public: RequestSendLocationEvent(nsIDOMGeoPosition* aPosition, nsGeolocationRequest* aRequest) - : mPosition(aPosition), - mRequest(aRequest) + : mozilla::Runnable("RequestSendLocationEvent") + , mPosition(aPosition) + , mRequest(aRequest) { } NS_IMETHOD Run() override { mRequest->SendLocation(mPosition); return NS_OK; }
--- a/dom/html/HTMLCanvasElement.cpp +++ b/dom/html/HTMLCanvasElement.cpp @@ -236,18 +236,20 @@ void HTMLCanvasPrintState::Done() { if (!mPendingNotify && !mIsDone) { // The canvas needs to be invalidated for printing reftests on linux to // work. if (mCanvas) { mCanvas->InvalidateCanvas(); } - RefPtr<nsRunnableMethod<HTMLCanvasPrintState> > doneEvent = - NewRunnableMethod(this, &HTMLCanvasPrintState::NotifyDone); + RefPtr<nsRunnableMethod<HTMLCanvasPrintState>> doneEvent = + NewRunnableMethod("dom::HTMLCanvasPrintState::NotifyDone", + this, + &HTMLCanvasPrintState::NotifyDone); if (NS_SUCCEEDED(NS_DispatchToCurrentThread(doneEvent))) { mPendingNotify = true; } } } void HTMLCanvasPrintState::NotifyDone() @@ -516,18 +518,20 @@ HTMLCanvasElement::DispatchPrintCallback if (!mCurrentContext) { nsresult rv; nsCOMPtr<nsISupports> context; rv = GetContext(NS_LITERAL_STRING("2d"), getter_AddRefs(context)); NS_ENSURE_SUCCESS(rv, rv); } mPrintState = new HTMLCanvasPrintState(this, mCurrentContext, aCallback); - RefPtr<nsRunnableMethod<HTMLCanvasElement> > renderEvent = - NewRunnableMethod(this, &HTMLCanvasElement::CallPrintCallback); + RefPtr<nsRunnableMethod<HTMLCanvasElement>> renderEvent = + NewRunnableMethod("dom::HTMLCanvasElement::CallPrintCallback", + this, + &HTMLCanvasElement::CallPrintCallback); return OwnerDoc()->Dispatch("HTMLCanvasElement::CallPrintCallback", TaskCategory::Other, renderEvent.forget()); } void HTMLCanvasElement::CallPrintCallback() { @@ -839,23 +843,26 @@ HTMLCanvasElement::ToBlob(JSContext* aCx nsCOMPtr<nsIGlobalObject> global = OwnerDoc()->GetScopeObject(); MOZ_ASSERT(global); nsIntSize elemSize = GetWidthHeight(); if (elemSize.width == 0 || elemSize.height == 0) { // According to spec, blob should return null if either its horizontal // dimension or its vertical dimension is zero. See link below. // https://html.spec.whatwg.org/multipage/scripting.html#dom-canvas-toblob - OwnerDoc()->Dispatch("FireNullBlobEvent", - TaskCategory::Other, - NewRunnableMethod<Blob*, const char*>( - &aCallback, - static_cast<void(BlobCallback::*)( - Blob*, const char*)>(&BlobCallback::Call), - nullptr, nullptr)); + OwnerDoc()->Dispatch( + "FireNullBlobEvent", + TaskCategory::Other, + NewRunnableMethod<Blob*, const char*>( + "dom::HTMLCanvasElement::ToBlob", + &aCallback, + static_cast<void (BlobCallback::*)(Blob*, const char*)>( + &BlobCallback::Call), + nullptr, + nullptr)); return; } CanvasRenderingContextHelper::ToBlob(aCx, global, aCallback, aType, aParams, aRv); } @@ -1348,17 +1355,18 @@ HTMLCanvasElement::OnVisibilityChange() return; } if (mOffscreenCanvas) { class Runnable final : public CancelableRunnable { public: explicit Runnable(AsyncCanvasRenderer* aRenderer) - : mRenderer(aRenderer) + : mozilla::CancelableRunnable("Runnable") + , mRenderer(aRenderer) {} NS_IMETHOD Run() override { if (mRenderer && mRenderer->mContext) { mRenderer->mContext->OnVisibilityChange(); } @@ -1390,17 +1398,18 @@ HTMLCanvasElement::OnVisibilityChange() void HTMLCanvasElement::OnMemoryPressure() { if (mOffscreenCanvas) { class Runnable final : public CancelableRunnable { public: explicit Runnable(AsyncCanvasRenderer* aRenderer) - : mRenderer(aRenderer) + : mozilla::CancelableRunnable("Runnable") + , mRenderer(aRenderer) {} NS_IMETHOD Run() override { if (mRenderer && mRenderer->mContext) { mRenderer->mContext->OnMemoryPressure(); }
--- a/dom/html/HTMLFormElement.h +++ b/dom/html/HTMLFormElement.h @@ -421,17 +421,18 @@ protected: RefPtr<AsyncEventDispatcher> mFormPasswordEventDispatcher; class RemoveElementRunnable; friend class RemoveElementRunnable; class RemoveElementRunnable : public Runnable { public: explicit RemoveElementRunnable(HTMLFormElement* aForm) - : mForm(aForm) + : Runnable("dom::HTMLFormElement::RemoveElementRunnable") + , mForm(aForm) {} NS_IMETHOD Run() override { mForm->HandleDefaultSubmitRemoval(); return NS_OK; } private:
--- a/dom/html/HTMLImageElement.cpp +++ b/dom/html/HTMLImageElement.cpp @@ -74,19 +74,21 @@ namespace mozilla { namespace dom { // Calls LoadSelectedImage on host element unless it has been superseded or // canceled -- this is the synchronous section of "update the image data". // https://html.spec.whatwg.org/multipage/embedded-content.html#update-the-image-data class ImageLoadTask : public Runnable { public: - ImageLoadTask(HTMLImageElement *aElement, bool aAlwaysLoad, + ImageLoadTask(HTMLImageElement* aElement, + bool aAlwaysLoad, bool aUseUrgentStartForChannel) - : mElement(aElement) + : Runnable("dom::ImageLoadTask") + , mElement(aElement) , mAlwaysLoad(aAlwaysLoad) , mUseUrgentStartForChannel(aUseUrgentStartForChannel) { mDocument = aElement->OwnerDoc(); mDocument->BlockOnload(); } NS_IMETHOD Run() override @@ -671,17 +673,20 @@ HTMLImageElement::BindToTree(nsIDocument // script. // If loading is temporarily disabled, don't even launch MaybeLoadImage. // Otherwise MaybeLoadImage may run later when someone has reenabled // loading. if (LoadingEnabled() && OwnerDoc()->IsCurrentActiveDocument()) { nsContentUtils::AddScriptRunner( - NewRunnableMethod<bool>(this, &HTMLImageElement::MaybeLoadImage, false)); + NewRunnableMethod<bool>("dom::HTMLImageElement::MaybeLoadImage", + this, + &HTMLImageElement::MaybeLoadImage, + false)); } } return rv; } void HTMLImageElement::UnbindFromTree(bool aDeep, bool aNullParent) @@ -764,19 +769,24 @@ HTMLImageElement::NodeInfoChanged(nsIDoc // Force reload image if adoption steps are run. // If loading is temporarily disabled, don't even launch script runner. // Otherwise script runner may run later when someone has reenabled loading. if (LoadingEnabled()) { // Use script runner for the case the adopt is from appendChild. // Bug 1076583 - We still behave synchronously in the non-responsive case nsContentUtils::AddScriptRunner( (InResponsiveMode()) - ? NewRunnableMethod<bool>(this, &HTMLImageElement::QueueImageLoadTask, true) - : NewRunnableMethod<bool>(this, &HTMLImageElement::MaybeLoadImage, true) - ); + ? NewRunnableMethod<bool>("dom::HTMLImageElement::QueueImageLoadTask", + this, + &HTMLImageElement::QueueImageLoadTask, + true) + : NewRunnableMethod<bool>("dom::HTMLImageElement::MaybeLoadImage", + this, + &HTMLImageElement::MaybeLoadImage, + true)); } } // static already_AddRefed<HTMLImageElement> HTMLImageElement::Image(const GlobalObject& aGlobal, const Optional<uint32_t>& aWidth, const Optional<uint32_t>& aHeight, @@ -889,17 +899,20 @@ HTMLImageElement::CopyInnerTo(Element* a if (!dest->InResponsiveMode() && dest->HasAttr(kNameSpaceID_None, nsGkAtoms::src) && dest->OwnerDoc()->IsCurrentActiveDocument()) { // Mark channel as urgent-start before load image if the image load is // initaiated by a user interaction. mUseUrgentStartForChannel = EventStateManager::IsHandlingUserInput(); nsContentUtils::AddScriptRunner( - NewRunnableMethod<bool>(dest, &HTMLImageElement::MaybeLoadImage, false)); + NewRunnableMethod<bool>("dom::HTMLImageElement::MaybeLoadImage", + dest, + &HTMLImageElement::MaybeLoadImage, + false)); } } return NS_OK; } CORSMode HTMLImageElement::GetCORSMode()
--- a/dom/html/HTMLInputElement.cpp +++ b/dom/html/HTMLInputElement.cpp @@ -4865,17 +4865,19 @@ HTMLInputElement::BindToTree(nsIDocument // initaiated by a user interaction. mUseUrgentStartForChannel = EventStateManager::IsHandlingUserInput(); // FIXME: Bug 660963 it would be nice if we could just have // ClearBrokenState update our state and do it fast... ClearBrokenState(); RemoveStatesSilently(NS_EVENT_STATE_BROKEN); nsContentUtils::AddScriptRunner( - NewRunnableMethod(this, &HTMLInputElement::MaybeLoadImage)); + NewRunnableMethod("dom::HTMLInputElement::MaybeLoadImage", + this, + &HTMLInputElement::MaybeLoadImage)); } } // Add radio to document if we don't have a form already (if we do it's // already been added into that group) if (aDocument && !mForm && mType == NS_FORM_INPUT_RADIO) { AddedToRadioGroup(); }
--- a/dom/html/HTMLLinkElement.cpp +++ b/dom/html/HTMLLinkElement.cpp @@ -166,17 +166,18 @@ HTMLLinkElement::BindToTree(nsIDocument* aDocument->RegisterPendingLinkUpdate(this); } if (IsInComposedDoc()) { TryDNSPrefetchPreconnectOrPrefetchOrPrerender(); } void (HTMLLinkElement::*update)() = &HTMLLinkElement::UpdateStyleSheetInternal; - nsContentUtils::AddScriptRunner(NewRunnableMethod(this, update)); + nsContentUtils::AddScriptRunner( + NewRunnableMethod("dom::HTMLLinkElement::BindToTree", this, update)); CreateAndDispatchEvent(aDocument, NS_LITERAL_STRING("DOMLinkAdded")); return rv; } void HTMLLinkElement::LinkAdded()
--- a/dom/html/HTMLMediaElement.cpp +++ b/dom/html/HTMLMediaElement.cpp @@ -227,20 +227,22 @@ RejectPromises(const nsTArray<RefPtr<Pro // since if we neglect to add a self-reference, this element might be // garbage collected while there are still event listeners that should // receive events. If we neglect to remove the self-reference then the element // just lives longer than it needs to. class nsMediaEvent : public Runnable { public: - - explicit nsMediaEvent(HTMLMediaElement* aElement) : - mElement(aElement), - mLoadID(mElement->GetCurrentLoadID()) {} + explicit nsMediaEvent(HTMLMediaElement* aElement) + : Runnable("dom::nsMediaEvent") + , mElement(aElement) + , mLoadID(mElement->GetCurrentLoadID()) + { + } ~nsMediaEvent() {} NS_IMETHOD Run() = 0; protected: bool IsCancelled() { return mElement->GetCurrentLoadID() != mLoadID; } @@ -400,19 +402,21 @@ public: MOZ_ASSERT(false, "Should only lock on to a video track"); return; } const VideoSegment& video = static_cast<const VideoSegment&>(aMedia); for (VideoSegment::ConstChunkIterator c(video); !c.IsEnded(); c.Next()) { if (c->mFrame.GetIntrinsicSize() != gfx::IntSize(0,0)) { mInitialSizeFound = true; - nsCOMPtr<nsIRunnable> event = - NewRunnableMethod<gfx::IntSize>(this, &StreamSizeListener::ReceivedSize, - c->mFrame.GetIntrinsicSize()); + nsCOMPtr<nsIRunnable> event = NewRunnableMethod<gfx::IntSize>( + "dom::HTMLMediaElement::StreamSizeListener::ReceivedSize", + this, + &StreamSizeListener::ReceivedSize, + c->mFrame.GetIntrinsicSize()); // This is fine to dispatch straight to main thread (instead of via // ...AfterStreamUpdate()) since it reflects state of the element, // not the stream. Events reflecting stream or track state should be // dispatched so their order is preserved. NS_DispatchToMainThread(event.forget()); return; } } @@ -965,34 +969,36 @@ private: return; } if (!IsPlayingStarted()) { return; } uint64_t windowID = mAudioChannelAgent->WindowID(); - NS_DispatchToMainThread(NS_NewRunnableFunction([windowID]() -> void { - nsCOMPtr<nsIObserverService> observerService = - services::GetObserverService(); - if (NS_WARN_IF(!observerService)) { - return; - } - - nsCOMPtr<nsISupportsPRUint64> wrapper = - do_CreateInstance(NS_SUPPORTS_PRUINT64_CONTRACTID); - if (NS_WARN_IF(!wrapper)) { - return; - } - - wrapper->SetData(windowID); - observerService->NotifyObservers(wrapper, - "media-playback-resumed", - u"active"); - })); + NS_DispatchToMainThread(NS_NewRunnableFunction( + "dom::HTMLMediaElement::AudioChannelAgentCallback::" + "MaybeNotifyMediaResumed", + [windowID]() -> void { + nsCOMPtr<nsIObserverService> observerService = + services::GetObserverService(); + if (NS_WARN_IF(!observerService)) { + return; + } + + nsCOMPtr<nsISupportsPRUint64> wrapper = + do_CreateInstance(NS_SUPPORTS_PRUINT64_CONTRACTID); + if (NS_WARN_IF(!wrapper)) { + return; + } + + wrapper->SetData(windowID); + observerService->NotifyObservers( + wrapper, "media-playback-resumed", u"active"); + })); } bool IsTabActivated() { if (MaybeCreateAudioChannelAgent()) { return !mAudioChannelAgent->ShouldBlockMedia(); } @@ -4085,18 +4091,22 @@ HTMLMediaElement::WakeLockBoolWrapper::U } mOuter->WakeLockCreate(); } else if (!mTimer) { // Don't release the wake lock immediately; instead, release it after a // grace period. int timeout = Preferences::GetInt("media.wakelock_timeout", 2000); mTimer = do_CreateInstance("@mozilla.org/timer;1"); if (mTimer) { - mTimer->InitWithFuncCallback(TimerCallback, this, timeout, - nsITimer::TYPE_ONE_SHOT); + mTimer->InitWithNamedFuncCallback( + TimerCallback, + this, + timeout, + nsITimer::TYPE_ONE_SHOT, + "dom::HTMLMediaElement::WakeLockBoolWrapper::UpdateWakeLock"); } } } void HTMLMediaElement::WakeLockBoolWrapper::TimerCallback(nsITimer* aTimer, void* aClosure) { @@ -4526,21 +4536,22 @@ void HTMLMediaElement::UnbindFromTree(bo mVisibilityState = Visibility::UNTRACKED; nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent); MOZ_ASSERT(IsHidden()); NotifyDecoderActivityChanges(); RefPtr<HTMLMediaElement> self(this); - nsCOMPtr<nsIRunnable> task = NS_NewRunnableFunction([self] () { - if (self->mUnboundFromTree) { - self->Pause(); - } - }); + nsCOMPtr<nsIRunnable> task = + NS_NewRunnableFunction("dom::HTMLMediaElement::UnbindFromTree", [self]() { + if (self->mUnboundFromTree) { + self->Pause(); + } + }); RunInStableState(task); } static bool IsVP9InMP4(const MediaContainerType& aContainerType) { const MediaContainerType mimeType(aContainerType.Type()); return DecoderTraits::IsMP4SupportedType(mimeType, @@ -4839,40 +4850,51 @@ public: } // These notifications run on the media graph thread so we need to // dispatch events to the main thread. virtual void NotifyBlockingChanged(MediaStreamGraph* aGraph, Blocking aBlocked) override { nsCOMPtr<nsIRunnable> event; if (aBlocked == BLOCKED) { - event = NewRunnableMethod(this, &StreamListener::DoNotifyBlocked); + event = NewRunnableMethod( + "dom::HTMLMediaElement::StreamListener::DoNotifyBlocked", + this, + &StreamListener::DoNotifyBlocked); } else { - event = NewRunnableMethod(this, &StreamListener::DoNotifyUnblocked); + event = NewRunnableMethod( + "dom::HTMLMediaElement::StreamListener::DoNotifyUnblocked", + this, + &StreamListener::DoNotifyUnblocked); } aGraph->DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread, event.forget()); } virtual void NotifyHasCurrentData(MediaStreamGraph* aGraph) override { MutexAutoLock lock(mMutex); aGraph->DispatchToMainThreadAfterStreamStateUpdate( mAbstractMainThread, - NewRunnableMethod(this, &StreamListener::DoNotifyHaveCurrentData)); + NewRunnableMethod( + "dom::HTMLMediaElement::StreamListener::DoNotifyHaveCurrentData", + this, + &StreamListener::DoNotifyHaveCurrentData)); } virtual void NotifyOutput(MediaStreamGraph* aGraph, GraphTime aCurrentTime) override { MutexAutoLock lock(mMutex); if (mPendingNotifyOutput) return; mPendingNotifyOutput = true; aGraph->DispatchToMainThreadAfterStreamStateUpdate( mAbstractMainThread, - NewRunnableMethod(this, &StreamListener::DoNotifyOutput)); + NewRunnableMethod("dom::HTMLMediaElement::StreamListener::DoNotifyOutput", + this, + &StreamListener::DoNotifyOutput)); } private: // These fields may only be accessed on the main thread HTMLMediaElement* mElement; bool mHaveCurrentData; bool mBlocked; bool mFinished; @@ -6291,17 +6313,19 @@ void HTMLMediaElement::AddRemoveSelfRefe // The shutdown observer will hold a strong reference to us. This // will do to keep us alive. We need to know about shutdown so that // we can release our self-reference. mShutdownObserver->AddRefMediaElement(); } else { // Dispatch Release asynchronously so that we don't destroy this object // inside a call stack of method calls on this object nsCOMPtr<nsIRunnable> event = - NewRunnableMethod(this, &HTMLMediaElement::DoRemoveSelfReference); + NewRunnableMethod("dom::HTMLMediaElement::DoRemoveSelfReference", + this, + &HTMLMediaElement::DoRemoveSelfReference); NS_DispatchToMainThread(event); } } } void HTMLMediaElement::DoRemoveSelfReference() { mShutdownObserver->ReleaseMediaElement(); @@ -7488,33 +7512,33 @@ bool HasDebuggerPrivilege(JSContext* aCx } void HTMLMediaElement::AsyncResolveSeekDOMPromiseIfExists() { MOZ_ASSERT(NS_IsMainThread()); if (mSeekDOMPromise) { RefPtr<dom::Promise> promise = mSeekDOMPromise.forget(); - nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () { - promise->MaybeResolveWithUndefined(); - }); + nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction( + "dom::HTMLMediaElement::AsyncResolveSeekDOMPromiseIfExists", + [=]() { promise->MaybeResolveWithUndefined(); }); mAbstractMainThread->Dispatch(r.forget()); mSeekDOMPromise = nullptr; } } void HTMLMediaElement::AsyncRejectSeekDOMPromiseIfExists() { MOZ_ASSERT(NS_IsMainThread()); if (mSeekDOMPromise) { RefPtr<dom::Promise> promise = mSeekDOMPromise.forget(); - nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () { - promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); - }); + nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction( + "dom::HTMLMediaElement::AsyncRejectSeekDOMPromiseIfExists", + [=]() { promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); }); mAbstractMainThread->Dispatch(r.forget()); mSeekDOMPromise = nullptr; } } void HTMLMediaElement::ReportCanPlayTelemetry() { @@ -7522,36 +7546,39 @@ HTMLMediaElement::ReportCanPlayTelemetry RefPtr<nsIThread> thread; nsresult rv = NS_NewNamedThread("MediaTelemetry", getter_AddRefs(thread)); if (NS_WARN_IF(NS_FAILED(rv))) { return; } thread->Dispatch( - NS_NewRunnableFunction([thread]() { + NS_NewRunnableFunction( + "dom::HTMLMediaElement::ReportCanPlayTelemetry", + [thread]() { #if XP_WIN - // Windows Media Foundation requires MSCOM to be inited. - HRESULT hr = CoInitializeEx(0, COINIT_MULTITHREADED); - MOZ_ASSERT(hr == S_OK); + // Windows Media Foundation requires MSCOM to be inited. + HRESULT hr = CoInitializeEx(0, COINIT_MULTITHREADED); + MOZ_ASSERT(hr == S_OK); #endif - bool aac = MP4Decoder::IsSupportedType( - MediaContainerType(MEDIAMIMETYPE("audio/mp4")), nullptr); - bool h264 = MP4Decoder::IsSupportedType( - MediaContainerType(MEDIAMIMETYPE("video/mp4")), nullptr); + bool aac = MP4Decoder::IsSupportedType( + MediaContainerType(MEDIAMIMETYPE("audio/mp4")), nullptr); + bool h264 = MP4Decoder::IsSupportedType( + MediaContainerType(MEDIAMIMETYPE("video/mp4")), nullptr); #if XP_WIN - CoUninitialize(); + CoUninitialize(); #endif - AbstractThread::MainThread()->Dispatch( - NS_NewRunnableFunction([thread, aac, h264]() { - LOG(LogLevel::Debug, ("MediaTelemetry aac=%d h264=%d", aac, h264)); - Telemetry::Accumulate( - Telemetry::HistogramID::VIDEO_CAN_CREATE_AAC_DECODER, aac); - Telemetry::Accumulate( - Telemetry::HistogramID::VIDEO_CAN_CREATE_H264_DECODER, h264); - thread->AsyncShutdown(); - })); - }), + AbstractThread::MainThread()->Dispatch(NS_NewRunnableFunction( + "dom::HTMLMediaElement::ReportCanPlayTelemetry", + [thread, aac, h264]() { + LOG(LogLevel::Debug, ("MediaTelemetry aac=%d h264=%d", aac, h264)); + Telemetry::Accumulate( + Telemetry::HistogramID::VIDEO_CAN_CREATE_AAC_DECODER, aac); + Telemetry::Accumulate( + Telemetry::HistogramID::VIDEO_CAN_CREATE_H264_DECODER, h264); + thread->AsyncShutdown(); + })); + }), NS_DISPATCH_NORMAL); } } // namespace dom } // namespace mozilla
--- a/dom/html/HTMLObjectElement.cpp +++ b/dom/html/HTMLObjectElement.cpp @@ -126,17 +126,19 @@ static nsIWidget* GetWidget(Element* aEl } Element* HTMLObjectElement::sLastFocused = nullptr; // Weak class PluginFocusSetter : public Runnable { public: PluginFocusSetter(nsIWidget* aWidget, Element* aElement) - : mWidget(aWidget), mElement(aElement) + : Runnable("PluginFocusSetter") + , mWidget(aWidget) + , mElement(aElement) { } NS_IMETHOD Run() override { if (mElement) { HTMLObjectElement::sLastFocused = mElement; bool value = true; @@ -264,17 +266,18 @@ HTMLObjectElement::BindToTree(nsIDocumen // Don't kick off load from being bound to a plugin document - the plugin // document will call nsObjectLoadingContent::InitializeFromChannel() for the // initial load. nsCOMPtr<nsIPluginDocument> pluginDoc = do_QueryInterface(aDocument); // If we already have all the children, start the load. if (mIsDoneAddingChildren && !pluginDoc) { void (HTMLObjectElement::*start)() = &HTMLObjectElement::StartObjectLoad; - nsContentUtils::AddScriptRunner(NewRunnableMethod(this, start)); + nsContentUtils::AddScriptRunner( + NewRunnableMethod("dom::HTMLObjectElement::BindToTree", this, start)); } return NS_OK; } void HTMLObjectElement::UnbindFromTree(bool aDeep, bool aNullParent)
--- a/dom/html/HTMLSharedObjectElement.cpp +++ b/dom/html/HTMLSharedObjectElement.cpp @@ -134,17 +134,18 @@ HTMLSharedObjectElement::BindToTree(nsID // document will call nsObjectLoadingContent::InitializeFromChannel() for the // initial load. nsCOMPtr<nsIPluginDocument> pluginDoc = do_QueryInterface(aDocument); // If we already have all the children, start the load. if (mIsDoneAddingChildren && !pluginDoc) { void (HTMLSharedObjectElement::*start)() = &HTMLSharedObjectElement::StartObjectLoad; - nsContentUtils::AddScriptRunner(NewRunnableMethod(this, start)); + nsContentUtils::AddScriptRunner(NewRunnableMethod( + "dom::HTMLSharedObjectElement::BindToTree", this, start)); } return NS_OK; } void HTMLSharedObjectElement::UnbindFromTree(bool aDeep, bool aNullParent)
--- a/dom/html/HTMLStyleElement.cpp +++ b/dom/html/HTMLStyleElement.cpp @@ -141,17 +141,18 @@ HTMLStyleElement::BindToTree(nsIDocument bool aCompileEventHandlers) { nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent, aBindingParent, aCompileEventHandlers); NS_ENSURE_SUCCESS(rv, rv); void (HTMLStyleElement::*update)() = &HTMLStyleElement::UpdateStyleSheetInternal; - nsContentUtils::AddScriptRunner(NewRunnableMethod(this, update)); + nsContentUtils::AddScriptRunner( + NewRunnableMethod("dom::HTMLStyleElement::BindToTree", this, update)); return rv; } void HTMLStyleElement::UnbindFromTree(bool aDeep, bool aNullParent) { nsCOMPtr<nsIDocument> oldDoc = GetUncomposedDoc();
--- a/dom/html/HTMLTrackElement.cpp +++ b/dom/html/HTMLTrackElement.cpp @@ -260,17 +260,20 @@ HTMLTrackElement::SetSrc(const nsAString DispatchLoadResource(); } void HTMLTrackElement::DispatchLoadResource() { if (!mLoadResourceDispatched) { - RefPtr<Runnable> r = NewRunnableMethod(this, &HTMLTrackElement::LoadResource); + RefPtr<Runnable> r = + NewRunnableMethod("dom::HTMLTrackElement::LoadResource", + this, + &HTMLTrackElement::LoadResource); nsContentUtils::RunInStableState(r.forget()); mLoadResourceDispatched = true; } } void HTMLTrackElement::LoadResource() { @@ -432,21 +435,21 @@ HTMLTrackElement::SetReadyState(uint16_t void HTMLTrackElement::DispatchTrackRunnable(const nsString& aEventName) { nsIDocument* doc = OwnerDoc(); if (!doc) { return; } - nsCOMPtr<nsIRunnable> runnable = - NewRunnableMethod - <const nsString>(this, - &HTMLTrackElement::DispatchTrustedEvent, - aEventName); + nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod<const nsString>( + "dom::HTMLTrackElement::DispatchTrustedEvent", + this, + &HTMLTrackElement::DispatchTrustedEvent, + aEventName); doc->Dispatch("HTMLTrackElement::DispatchTrackRunnable", TaskCategory::Other, runnable.forget()); } void HTMLTrackElement::DispatchTrustedEvent(const nsAString& aName) { nsIDocument* doc = OwnerDoc();
--- a/dom/html/ImageDocument.cpp +++ b/dom/html/ImageDocument.cpp @@ -488,17 +488,19 @@ ImageDocument::Notify(imgIRequest* aRequ aRequest->GetImage(getter_AddRefs(image)); return OnSizeAvailable(aRequest, image); } // Run this using a script runner because HAS_TRANSPARENCY notifications can // come during painting and this will trigger invalidation. if (aType == imgINotificationObserver::HAS_TRANSPARENCY) { nsCOMPtr<nsIRunnable> runnable = - NewRunnableMethod(this, &ImageDocument::OnHasTransparency); + NewRunnableMethod("dom::ImageDocument::OnHasTransparency", + this, + &ImageDocument::OnHasTransparency); nsContentUtils::AddScriptRunner(runnable); } if (aType == imgINotificationObserver::LOAD_COMPLETE) { uint32_t reqStatus; aRequest->GetImageStatus(&reqStatus); nsresult status = reqStatus & imgIRequest::STATUS_ERROR ? NS_ERROR_FAILURE : NS_OK; @@ -561,17 +563,19 @@ ImageDocument::OnSizeAvailable(imgIReque // Multipart images send size available for each part; ignore them if it // doesn't change our size. (We may not even support changing size in // multipart images in the future.) if (oldWidth == mImageWidth && oldHeight == mImageHeight) { return NS_OK; } nsCOMPtr<nsIRunnable> runnable = - NewRunnableMethod(this, &ImageDocument::DefaultCheckOverflowing); + NewRunnableMethod("dom::ImageDocument::DefaultCheckOverflowing", + this, + &ImageDocument::DefaultCheckOverflowing); nsContentUtils::AddScriptRunner(runnable); UpdateTitleAndCharset(); return NS_OK; } nsresult ImageDocument::OnLoadComplete(imgIRequest* aRequest, nsresult aStatus)
--- a/dom/html/TextTrackManager.cpp +++ b/dom/html/TextTrackManager.cpp @@ -165,18 +165,20 @@ TextTrackManager::AddTextTrack(TextTrack NS_ConvertUTF16toUTF8(aLabel).get(), NS_ConvertUTF16toUTF8(aLanguage).get()); RefPtr<TextTrack> track = mTextTracks->AddTextTrack(aKind, aLabel, aLanguage, aMode, aReadyState, aTextTrackSource, CompareTextTracks(mMediaElement)); AddCues(track); ReportTelemetryForTrack(track); if (aTextTrackSource == TextTrackSource::Track) { - RefPtr<nsIRunnable> task = - NewRunnableMethod(this, &TextTrackManager::HonorUserPreferencesForTrackSelection); + RefPtr<nsIRunnable> task = NewRunnableMethod( + "dom::TextTrackManager::HonorUserPreferencesForTrackSelection", + this, + &TextTrackManager::HonorUserPreferencesForTrackSelection); nsContentUtils::RunInStableState(task.forget()); } return track.forget(); } void TextTrackManager::AddTextTrack(TextTrack* aTextTrack) @@ -185,18 +187,20 @@ TextTrackManager::AddTextTrack(TextTrack return; } WEBVTT_LOG("%p AddTextTrack TextTrack %p",this, aTextTrack); mTextTracks->AddTextTrack(aTextTrack, CompareTextTracks(mMediaElement)); AddCues(aTextTrack); ReportTelemetryForTrack(aTextTrack); if (aTextTrack->GetTextTrackSource() == TextTrackSource::Track) { - RefPtr<nsIRunnable> task = - NewRunnableMethod(this, &TextTrackManager::HonorUserPreferencesForTrackSelection); + RefPtr<nsIRunnable> task = NewRunnableMethod( + "dom::TextTrackManager::HonorUserPreferencesForTrackSelection", + this, + &TextTrackManager::HonorUserPreferencesForTrackSelection); nsContentUtils::RunInStableState(task.forget()); } } void TextTrackManager::AddCues(TextTrack* aTextTrack) { if (!mNewCues) { @@ -478,22 +482,25 @@ TextTrackManager::HandleEvent(nsIDOMEven return NS_OK; } class SimpleTextTrackEvent : public Runnable { public: friend class CompareSimpleTextTrackEvents; - SimpleTextTrackEvent(const nsAString& aEventName, double aTime, - TextTrack* aTrack, TextTrackCue* aCue) - : mName(aEventName), - mTime(aTime), - mTrack(aTrack), - mCue(aCue) + SimpleTextTrackEvent(const nsAString& aEventName, + double aTime, + TextTrack* aTrack, + TextTrackCue* aCue) + : Runnable("dom::SimpleTextTrackEvent") + , mName(aEventName) + , mTime(aTime) + , mTrack(aTrack) + , mCue(aCue) {} NS_IMETHOD Run() { WEBVTT_LOGV("SimpleTextTrackEvent cue %p mName %s mTime %lf", mCue.get(), NS_ConvertUTF16toUTF8(mName).get(), mTime); mCue->DispatchTrustedEvent(mName); return NS_OK; } @@ -619,18 +626,21 @@ void TextTrackManager::DispatchUpdateCueDisplay() { if (!mUpdateCueDisplayDispatched && !mShutdown && (mMediaElement->GetHasUserInteraction() || mMediaElement->IsCurrentlyPlaying())) { WEBVTT_LOG("DispatchUpdateCueDisplay"); nsPIDOMWindowInner* win = mMediaElement->OwnerDoc()->GetInnerWindow(); if (win) { nsGlobalWindow::Cast(win)->Dispatch( - "TextTrackManager::UpdateCueDisplay", TaskCategory::Other, - NewRunnableMethod(this, &TextTrackManager::UpdateCueDisplay)); + "TextTrackManager::UpdateCueDisplay", + TaskCategory::Other, + NewRunnableMethod("dom::TextTrackManager::UpdateCueDisplay", + this, + &TextTrackManager::UpdateCueDisplay)); mUpdateCueDisplayDispatched = true; } } } void TextTrackManager::DispatchTimeMarchesOn() { @@ -639,18 +649,21 @@ TextTrackManager::DispatchTimeMarchesOn( // through its usual monotonic increase during normal playback; current // executing call upon completion will check queue for further 'work'. if (!mTimeMarchesOnDispatched && !mShutdown && (mMediaElement->GetHasUserInteraction() || mMediaElement->IsCurrentlyPlaying())) { WEBVTT_LOG("DispatchTimeMarchesOn"); nsPIDOMWindowInner* win = mMediaElement->OwnerDoc()->GetInnerWindow(); if (win) { nsGlobalWindow::Cast(win)->Dispatch( - "TextTrackManager::TimeMarchesOn", TaskCategory::Other, - NewRunnableMethod(this, &TextTrackManager::TimeMarchesOn)); + "TextTrackManager::TimeMarchesOn", + TaskCategory::Other, + NewRunnableMethod("dom::TextTrackManager::TimeMarchesOn", + this, + &TextTrackManager::TimeMarchesOn)); mTimeMarchesOnDispatched = true; } } } // https://html.spec.whatwg.org/multipage/embedded-content.html#time-marches-on void TextTrackManager::TimeMarchesOn()
--- a/dom/html/nsGenericHTMLElement.cpp +++ b/dom/html/nsGenericHTMLElement.cpp @@ -115,17 +115,21 @@ using namespace mozilla::dom; /** * nsAutoFocusEvent is used to dispatch a focus event when a * nsGenericHTMLFormElement is binded to the tree with the autofocus attribute * enabled. */ class nsAutoFocusEvent : public Runnable { public: - explicit nsAutoFocusEvent(nsGenericHTMLFormElement* aElement) : mElement(aElement) {} + explicit nsAutoFocusEvent(nsGenericHTMLFormElement* aElement) + : mozilla::Runnable("nsAutoFocusEvent") + , mElement(aElement) + { + } NS_IMETHOD Run() override { nsFocusManager* fm = nsFocusManager::GetFocusManager(); if (!fm) { return NS_ERROR_NULL_POINTER; } nsIDocument* document = mElement->OwnerDoc();
--- a/dom/html/nsHTMLDocument.cpp +++ b/dom/html/nsHTMLDocument.cpp @@ -2500,17 +2500,19 @@ void nsHTMLDocument::MaybeEditingStateChanged() { if (!mPendingMaybeEditingStateChanged && mMayStartLayout && mUpdateNestLevel == 0 && (mContentEditableCount > 0) != IsEditingOn()) { if (nsContentUtils::IsSafeToRunScript()) { EditingStateChanged(); } else if (!mInDestructor) { nsContentUtils::AddScriptRunner( - NewRunnableMethod(this, &nsHTMLDocument::MaybeEditingStateChanged)); + NewRunnableMethod("nsHTMLDocument::MaybeEditingStateChanged", + this, + &nsHTMLDocument::MaybeEditingStateChanged)); } } } void nsHTMLDocument::EndUpdate(nsUpdateType aUpdateType) { const bool reset = !mPendingMaybeEditingStateChanged; @@ -2531,19 +2533,20 @@ nsHTMLDocument::SetMayStartLayout(bool a } // Helper class, used below in ChangeContentEditableCount(). class DeferredContentEditableCountChangeEvent : public Runnable { public: - DeferredContentEditableCountChangeEvent(nsHTMLDocument *aDoc, - nsIContent *aElement) - : mDoc(aDoc) + DeferredContentEditableCountChangeEvent(nsHTMLDocument* aDoc, + nsIContent* aElement) + : mozilla::Runnable("DeferredContentEditableCountChangeEvent") + , mDoc(aDoc) , mElement(aElement) { } NS_IMETHOD Run() override { if (mElement && mElement->OwnerDoc() == mDoc) { mDoc->DeferredContentEditableCountChange(mElement); }
--- a/dom/html/nsTextEditorState.cpp +++ b/dom/html/nsTextEditorState.cpp @@ -81,19 +81,20 @@ public: private: nsCOMPtr<nsIEditor> mEditor; bool mOuterTransaction; }; class RestoreSelectionState : public Runnable { public: - RestoreSelectionState(nsTextEditorState *aState, nsTextControlFrame *aFrame) - : mFrame(aFrame), - mTextEditorState(aState) + RestoreSelectionState(nsTextEditorState* aState, nsTextControlFrame* aFrame) + : mozilla::Runnable("RestoreSelectionState") + , mFrame(aFrame) + , mTextEditorState(aState) { } NS_IMETHOD Run() override { if (!mTextEditorState) { return NS_OK; } @@ -1244,20 +1245,21 @@ nsISelectionController* nsTextEditorState::GetSelectionController() const { return mSelCon; } // Helper class, used below in BindToFrame(). class PrepareEditorEvent : public Runnable { public: - PrepareEditorEvent(nsTextEditorState &aState, - nsIContent *aOwnerContent, - const nsAString &aCurrentValue) - : mState(&aState) + PrepareEditorEvent(nsTextEditorState& aState, + nsIContent* aOwnerContent, + const nsAString& aCurrentValue) + : mozilla::Runnable("PrepareEditorEvent") + , mState(&aState) , mOwnerContent(aOwnerContent) , mCurrentValue(aCurrentValue) { aState.mValueTransferInProgress = true; } NS_IMETHOD Run() override { NS_ENSURE_TRUE(mState, NS_ERROR_NULL_POINTER);
--- a/dom/indexedDB/ActorsParent.cpp +++ b/dom/indexedDB/ActorsParent.cpp @@ -5989,17 +5989,18 @@ public: MOZ_ASSERT(NS_FAILED(aErrorCode)); mResultCode = aErrorCode; } protected: DatabaseOperationBase(const nsID& aBackgroundChildLoggingId, uint64_t aLoggingSerialNumber) - : mOwningEventTarget(GetCurrentThreadEventTarget()) + : Runnable("dom::indexedDB::DatabaseOperationBase") + , mOwningEventTarget(GetCurrentThreadEventTarget()) , mBackgroundChildLoggingId(aBackgroundChildLoggingId) , mLoggingSerialNumber(aLoggingSerialNumber) , mResultCode(NS_OK) , mOperationMayProceed(true) , mActorDestroyed(false) { AssertIsOnOwningThread(); } @@ -6345,17 +6346,18 @@ class WaitForTransactionsHelper final WaitingForTransactions, WaitingForFileHandles, Complete } mState; public: WaitForTransactionsHelper(const nsCString& aDatabaseId, nsIRunnable* aCallback) - : mDatabaseId(aDatabaseId) + : Runnable("dom::indexedDB::WaitForTransactionsHelper") + , mDatabaseId(aDatabaseId) , mCallback(aCallback) , mState(State::Initial) { AssertIsOnBackgroundThread(); MOZ_ASSERT(!aDatabaseId.IsEmpty()); MOZ_ASSERT(aCallback); } @@ -8994,17 +8996,18 @@ class GetFileReferencesHelper final bool mResult; bool mWaiting; public: GetFileReferencesHelper(PersistenceType aPersistenceType, const nsACString& aOrigin, const nsAString& aDatabaseName, int64_t aFileId) - : mPersistenceType(aPersistenceType) + : Runnable("dom::indexedDB::GetFileReferencesHelper") + , mPersistenceType(aPersistenceType) , mOrigin(aOrigin) , mDatabaseName(aDatabaseName) , mFileId(aFileId) , mMutex("GetFileReferencesHelper::mMutex") , mCondVar(mMutex, "GetFileReferencesHelper::mCondVar") , mMemRefCnt(-1) , mDBRefCnt(-1) , mSliceRefCnt(-1) @@ -9022,16 +9025,19 @@ private: ~GetFileReferencesHelper() override = default; NS_DECL_NSIRUNNABLE }; class FlushPendingFileDeletionsRunnable final : public Runnable { +public: + FlushPendingFileDeletionsRunnable() : Runnable("FlushPendingFileDeletionsRunnable") {} + private: ~FlushPendingFileDeletionsRunnable() override = default; NS_DECL_NSIRUNNABLE }; class PermissionRequestHelper final : public PermissionRequestBase @@ -9360,17 +9366,18 @@ class Maintenance final nsTArray<DirectoryInfo> mDirectoryInfos; nsDataHashtable<nsStringHashKey, DatabaseMaintenance*> mDatabaseMaintenances; nsresult mResultCode; Atomic<bool> mAborted; State mState; public: explicit Maintenance(QuotaClient* aQuotaClient) - : mQuotaClient(aQuotaClient) + : Runnable("dom::indexedDB::Maintenance") + , mQuotaClient(aQuotaClient) , mStartTime(PR_Now()) , mResultCode(NS_OK) , mAborted(false) , mState(State::Initial) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aQuotaClient); MOZ_ASSERT(QuotaClient::GetInstance() == aQuotaClient); @@ -9576,17 +9583,18 @@ class DatabaseMaintenance final const PersistenceType mPersistenceType; public: DatabaseMaintenance(Maintenance* aMaintenance, PersistenceType aPersistenceType, const nsCString& aGroup, const nsCString& aOrigin, const nsString& aDatabasePath) - : mMaintenance(aMaintenance) + : Runnable("dom::indexedDB::DatabaseMaintenance") + , mMaintenance(aMaintenance) , mGroup(aGroup) , mOrigin(aOrigin) , mDatabasePath(aDatabasePath) , mPersistenceType(aPersistenceType) { } const nsString& DatabasePath() const @@ -12626,17 +12634,17 @@ ConnectionPool::ShutdownThread(ThreadInf IDB_DEBUG_LOG(("ConnectionPool shutting down thread %" PRIu32, runnable->SerialNumber())); // This should clean up the thread with the profiler. MOZ_ALWAYS_SUCCEEDS(thread->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL)); MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread( - NewRunnableMethod(thread, &nsIThread::Shutdown))); + NewRunnableMethod("nsIThread::Shutdown", thread, &nsIThread::Shutdown))); mTotalThreadCount--; } void ConnectionPool::CloseIdleDatabases() { AssertIsOnOwningThread(); @@ -12734,17 +12742,17 @@ ConnectionPool::ScheduleTransaction(Tran created = true; } else { NS_WARNING("Failed to make new thread!"); } } else if (!mDatabasesPerformingIdleMaintenance.IsEmpty()) { // We need a thread right now so force all idle processing to stop by // posting a dummy runnable to each thread that might be doing idle // maintenance. - nsCOMPtr<nsIRunnable> runnable = new Runnable(); + nsCOMPtr<nsIRunnable> runnable = new Runnable("IndexedDBDummyRunnable"); for (uint32_t index = mDatabasesPerformingIdleMaintenance.Length(); index > 0; index--) { DatabaseInfo* dbInfo = mDatabasesPerformingIdleMaintenance[index - 1]; MOZ_ASSERT(dbInfo); MOZ_ASSERT(dbInfo->mThreadInfo.mThread); @@ -13178,17 +13186,18 @@ ConnectionPool::CloseDatabaseWhenIdleInt return true; } return false; } ConnectionPool:: ConnectionRunnable::ConnectionRunnable(DatabaseInfo* aDatabaseInfo) - : mDatabaseInfo(aDatabaseInfo) + : Runnable("dom::indexedDB::ConnectionPool::ConnectionRunnable") + , mDatabaseInfo(aDatabaseInfo) , mOwningEventTarget(GetCurrentThreadEventTarget()) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aDatabaseInfo); MOZ_ASSERT(aDatabaseInfo->mConnectionPool); aDatabaseInfo->mConnectionPool->AssertIsOnOwningThread(); MOZ_ASSERT(mOwningEventTarget); } @@ -13340,21 +13349,22 @@ DatabasesCompleteCallback::DatabasesComp ConnectionPool:: DatabasesCompleteCallback::~DatabasesCompleteCallback() { AssertIsOnBackgroundThread(); MOZ_COUNT_DTOR(ConnectionPool::DatabasesCompleteCallback); } -ConnectionPool:: -FinishCallbackWrapper::FinishCallbackWrapper(ConnectionPool* aConnectionPool, - uint64_t aTransactionId, - FinishCallback* aCallback) - : mConnectionPool(aConnectionPool) +ConnectionPool::FinishCallbackWrapper::FinishCallbackWrapper( + ConnectionPool* aConnectionPool, + uint64_t aTransactionId, + FinishCallback* aCallback) + : Runnable("dom::indexedDB::ConnectionPool::FinishCallbackWrapper") + , mConnectionPool(aConnectionPool) , mCallback(aCallback) , mOwningEventTarget(GetCurrentThreadEventTarget()) , mTransactionId(aTransactionId) , mHasRunOnce(false) { AssertIsOnBackgroundThread(); MOZ_ASSERT(aConnectionPool); MOZ_ASSERT(aCallback); @@ -13407,19 +13417,19 @@ FinishCallbackWrapper::Run() callback->TransactionFinishedAfterUnblock(); return NS_OK; } uint32_t ConnectionPool::ThreadRunnable::sNextSerialNumber = 0; -ConnectionPool:: -ThreadRunnable::ThreadRunnable() - : mSerialNumber(++sNextSerialNumber) +ConnectionPool::ThreadRunnable::ThreadRunnable() + : Runnable("dom::indexedDB::ConnectionPool::ThreadRunnable") + , mSerialNumber(++sNextSerialNumber) , mFirstRun(true) , mContinueRunning(true) { AssertIsOnBackgroundThread(); } ConnectionPool:: ThreadRunnable::~ThreadRunnable() @@ -14472,17 +14482,19 @@ Database::MaybeCloseConnection() { AssertIsOnBackgroundThread(); if (!mTransactions.Count() && !mActiveMutableFileCount && IsClosed() && mDirectoryLock) { nsCOMPtr<nsIRunnable> callback = - NewRunnableMethod(this, &Database::ConnectionClosedCallback); + NewRunnableMethod("dom::indexedDB::Database::ConnectionClosedCallback", + this, + &Database::ConnectionClosedCallback); RefPtr<WaitForTransactionsHelper> helper = new WaitForTransactionsHelper(Id(), callback); helper->WaitForTransactions(); } } void @@ -22674,18 +22686,20 @@ OpenDatabaseOp::SendResults() if (NS_FAILED(mResultCode)) { mDatabase->Invalidate(); } // Make sure to release the database on this thread. mDatabase = nullptr; } else if (mDirectoryLock) { - nsCOMPtr<nsIRunnable> callback = - NewRunnableMethod(this, &OpenDatabaseOp::ConnectionClosedCallback); + nsCOMPtr<nsIRunnable> callback = NewRunnableMethod( + "dom::indexedDB::OpenDatabaseOp::ConnectionClosedCallback", + this, + &OpenDatabaseOp::ConnectionClosedCallback); RefPtr<WaitForTransactionsHelper> helper = new WaitForTransactionsHelper(mDatabaseId, callback); helper->WaitForTransactions(); } FinishSendResults(); }
--- a/dom/indexedDB/FileInfo.cpp +++ b/dom/indexedDB/FileInfo.cpp @@ -55,17 +55,18 @@ class CleanupFileRunnable final RefPtr<FileManager> mFileManager; int64_t mFileId; public: static void DoCleanup(FileManager* aFileManager, int64_t aFileId); CleanupFileRunnable(FileManager* aFileManager, int64_t aFileId) - : mFileManager(aFileManager) + : Runnable("dom::indexedDB::CleanupFileRunnable") + , mFileManager(aFileManager) , mFileId(aFileId) { MOZ_ASSERT(aFileManager); MOZ_ASSERT(aFileId > 0); } NS_DECL_ISUPPORTS_INHERITED
--- a/dom/indexedDB/IDBDatabase.cpp +++ b/dom/indexedDB/IDBDatabase.cpp @@ -68,19 +68,19 @@ const char kMemoryPressureObserverTopic[ const char kWindowObserverTopic[] = "inner-window-destroyed"; class CancelableRunnableWrapper final : public CancelableRunnable { nsCOMPtr<nsIRunnable> mRunnable; public: - explicit - CancelableRunnableWrapper(nsIRunnable* aRunnable) - : mRunnable(aRunnable) + explicit CancelableRunnableWrapper(nsIRunnable* aRunnable) + : CancelableRunnable("dom::CancelableRunnableWrapper") + , mRunnable(aRunnable) { MOZ_ASSERT(aRunnable); } private: ~CancelableRunnableWrapper() { }