Backed out changeset 4f6302a98ae4 (bug 1372405)
authorCarsten "Tomcat" Book <cbook@mozilla.com>
Wed, 21 Jun 2017 13:59:26 +0200
changeset 404234 4472d2623eceb63b76d650103b0e20f8c7d7c775
parent 404233 17bfc89021aedc0a76876d797969ea6475c042e3
child 404235 af979c2baf41046a6fad16ab6eb7ff8b4acab818
push id57
push userfmarier@mozilla.com
push dateSat, 24 Jun 2017 00:05:50 +0000
bugs1372405
milestone56.0a1
backs out4f6302a98ae41ff2d57c768996d1edbb0afda73a
Backed out changeset 4f6302a98ae4 (bug 1372405)
accessible/generic/Accessible.cpp
accessible/generic/DocAccessible.cpp
accessible/ipc/win/HandlerProvider.cpp
accessible/windows/msaa/AccessibleWrap.cpp
accessible/windows/msaa/LazyInstantiator.cpp
accessible/xpcom/xpcAccessibilityService.cpp
docshell/base/nsDocShell.cpp
docshell/base/nsDocShell.h
docshell/base/nsDocShellTreeOwner.cpp
docshell/shistory/nsSHEntryShared.cpp
dom/animation/Animation.cpp
dom/asmjscache/AsmJSCache.cpp
dom/audiochannel/AudioChannelService.cpp
dom/base/CustomElementRegistry.cpp
dom/base/CustomElementRegistry.h
dom/base/DOMRequest.cpp
dom/base/Element.cpp
dom/base/EventSource.cpp
dom/base/ImageEncoder.cpp
dom/base/PostMessageEvent.cpp
dom/base/ScreenOrientation.cpp
dom/base/Selection.h
dom/base/WebSocket.cpp
dom/base/nsContentSink.cpp
dom/base/nsContentUtils.cpp
dom/base/nsDOMMutationObserver.cpp
dom/base/nsDOMWindowUtils.cpp
dom/base/nsDocElementCreatedNotificationRunner.h
dom/base/nsDocument.cpp
dom/base/nsFocusManager.cpp
dom/base/nsFrameLoader.cpp
dom/base/nsFrameMessageManager.cpp
dom/base/nsGlobalWindow.cpp
dom/base/nsIGlobalObject.cpp
dom/base/nsInProcessTabChildGlobal.cpp
dom/base/nsJSEnvironment.cpp
dom/base/nsJSEnvironment.h
dom/base/nsObjectLoadingContent.cpp
dom/base/nsReferencedElement.h
dom/base/nsTextNode.cpp
dom/cache/Context.cpp
dom/cache/Manager.cpp
dom/cache/PrincipalVerifier.cpp
dom/cache/ReadStream.cpp
dom/canvas/CanvasRenderingContext2D.cpp
dom/canvas/ImageBitmap.cpp
dom/canvas/WebGLContext.cpp
dom/canvas/WebGLQuery.cpp
dom/events/AsyncEventDispatcher.cpp
dom/events/AsyncEventDispatcher.h
dom/events/DataTransferItem.cpp
dom/events/EventStateManager.cpp
dom/events/TextComposition.cpp
dom/events/TextComposition.h
dom/events/WheelHandlingHelper.cpp
dom/fetch/Fetch.cpp
dom/fetch/FetchConsumer.cpp
dom/fetch/FetchDriver.cpp
dom/file/MutableBlobStorage.cpp
dom/file/ipc/IPCBlobInputStream.cpp
dom/file/ipc/IPCBlobInputStreamChild.cpp
dom/file/ipc/IPCBlobInputStreamThread.cpp
dom/filehandle/ActorsParent.cpp
dom/filesystem/FileSystemRequestParent.cpp
dom/filesystem/FileSystemTaskBase.cpp
dom/filesystem/GetFilesHelper.cpp
dom/flyweb/HttpServer.cpp
dom/gamepad/cocoa/CocoaGamepad.cpp
dom/gamepad/ipc/GamepadEventChannelChild.cpp
dom/gamepad/ipc/GamepadEventChannelParent.cpp
dom/gamepad/windows/WindowsGamepad.cpp
dom/geolocation/nsGeolocation.cpp
dom/html/HTMLCanvasElement.cpp
dom/html/HTMLFormElement.h
dom/html/HTMLImageElement.cpp
dom/html/HTMLInputElement.cpp
dom/html/HTMLLinkElement.cpp
dom/html/HTMLMediaElement.cpp
dom/html/HTMLObjectElement.cpp
dom/html/HTMLSharedObjectElement.cpp
dom/html/HTMLStyleElement.cpp
dom/html/HTMLTrackElement.cpp
dom/html/ImageDocument.cpp
dom/html/TextTrackManager.cpp
dom/html/nsGenericHTMLElement.cpp
dom/html/nsHTMLDocument.cpp
dom/html/nsTextEditorState.cpp
dom/indexedDB/ActorsParent.cpp
dom/indexedDB/FileInfo.cpp
dom/indexedDB/IDBDatabase.cpp
dom/indexedDB/ScriptErrorHelper.cpp
dom/ipc/ContentBridgeChild.cpp
dom/ipc/ContentBridgeParent.cpp
dom/ipc/ContentChild.cpp
dom/ipc/ContentParent.cpp
dom/ipc/FilePickerParent.cpp
dom/ipc/PreallocatedProcessManager.cpp
dom/ipc/ProcessHangMonitor.cpp
dom/ipc/TabParent.cpp
dom/jsurl/nsJSProtocolHandler.cpp
dom/media/Benchmark.cpp
dom/media/CanvasCaptureMediaStream.cpp
dom/media/CubebUtils.cpp
dom/media/DOMMediaStream.cpp
dom/media/EncodedBufferCache.cpp
dom/media/FileBlockCache.cpp
dom/media/GraphDriver.cpp
dom/media/Latency.cpp
dom/media/MediaDecoder.cpp
dom/media/MediaDecoderReader.cpp
dom/media/MediaDecoderReaderWrapper.cpp
dom/media/MediaDecoderStateMachine.cpp
dom/media/MediaDecoderStateMachine.h
dom/media/MediaEventSource.h
dom/media/MediaFormatReader.cpp
dom/media/MediaManager.cpp
dom/media/MediaManager.h
dom/media/MediaRecorder.cpp
dom/media/MediaResource.cpp
dom/media/MediaStreamGraph.cpp
dom/media/MediaStreamTrack.cpp
dom/media/MediaTimer.cpp
dom/media/TextTrack.cpp
dom/media/TextTrackList.cpp
dom/media/VideoUtils.cpp
dom/media/VideoUtils.h
dom/media/android/AndroidMediaPluginHost.cpp
dom/media/android/AndroidMediaResourceServer.cpp
dom/media/eme/mediadrm/MediaDrmCDMProxy.cpp
dom/media/eme/mediadrm/MediaDrmCDMProxy.h
dom/media/gmp/ChromiumCDMParent.cpp
dom/media/gmp/ChromiumCDMProxy.cpp
dom/media/gmp/GMPCDMCallbackProxy.cpp
dom/media/gmp/GMPCDMProxy.cpp
dom/media/gmp/GMPCDMProxy.h
dom/media/gmp/GMPContentParent.cpp
dom/media/gmp/GMPCrashHelper.cpp
dom/media/gmp/GMPDecryptorChild.cpp
dom/media/gmp/GMPParent.cpp
dom/media/gmp/GMPPlatform.cpp
dom/media/gmp/GMPProcessParent.cpp
dom/media/gmp/GMPServiceChild.cpp
dom/media/gmp/GMPServiceParent.cpp
dom/media/gmp/GMPServiceParent.h
dom/media/gmp/GMPTimerParent.cpp
dom/media/gmp/GMPVideoDecoderChild.cpp
dom/media/gmp/GMPVideoDecoderParent.cpp
dom/media/gmp/GMPVideoEncoderChild.cpp
dom/media/gtest/GMPTestMonitor.h
dom/media/gtest/TestGMPCrossOrigin.cpp
dom/media/gtest/TestGMPRemoveAndDelete.cpp
dom/media/gtest/TestMP4Demuxer.cpp
dom/media/hls/HLSDemuxer.cpp
dom/media/imagecapture/CaptureTask.cpp
dom/media/ipc/RemoteVideoDecoder.cpp
dom/media/ipc/VideoDecoderChild.cpp
dom/media/ipc/VideoDecoderManagerChild.cpp
dom/media/ipc/VideoDecoderManagerParent.cpp
dom/media/mediasink/DecodedStream.cpp
dom/media/mediasource/AsyncEventRunner.h
dom/media/mediasource/AutoTaskQueue.h
dom/media/mediasource/MediaSourceDemuxer.cpp
dom/media/mediasource/TrackBuffersManager.cpp
dom/media/ogg/OggDemuxer.cpp
dom/media/platforms/PDMFactory.cpp
dom/media/platforms/android/RemoteDataDecoder.cpp
dom/media/platforms/omx/OmxDataDecoder.cpp
dom/media/platforms/wmf/WMFAudioMFTManager.cpp
dom/media/platforms/wmf/WMFMediaDataDecoder.cpp
dom/media/platforms/wmf/WMFVideoMFTManager.cpp
dom/media/platforms/wrappers/MediaDataDecoderProxy.cpp
dom/media/systemservices/CamerasChild.cpp
dom/media/systemservices/CamerasParent.cpp
dom/media/systemservices/MediaSystemResourceManager.cpp
dom/media/systemservices/MediaTaskUtils.h
dom/media/systemservices/MediaUtils.h
dom/media/webaudio/AnalyserNode.cpp
dom/media/webaudio/AudioBufferSourceNode.cpp
dom/media/webaudio/AudioDestinationNode.cpp
dom/media/webaudio/AudioNode.cpp
dom/media/webaudio/ConstantSourceNode.cpp
dom/media/webaudio/DynamicsCompressorNode.cpp
dom/media/webaudio/MediaBufferDecoder.cpp
dom/media/webaudio/OscillatorNode.cpp
dom/media/webaudio/PlayingRefChangeHandler.h
dom/media/webaudio/ScriptProcessorNode.cpp
dom/media/webaudio/WebAudioUtils.cpp
dom/media/webaudio/blink/HRTFDatabaseLoader.cpp
dom/media/webaudio/blink/ReverbConvolver.cpp
dom/media/webrtc/MediaEngineTabVideoSource.h
dom/media/webspeech/recognition/SpeechRecognition.h
dom/media/webspeech/synth/cocoa/OSXSpeechSynthesizerService.mm
dom/media/webspeech/synth/nsSpeechTask.cpp
dom/media/webspeech/synth/pico/nsPicoService.cpp
dom/media/webspeech/synth/speechd/SpeechDispatcherService.cpp
dom/media/webspeech/synth/test/nsFakeSynthServices.cpp
dom/messagechannel/MessagePort.cpp
dom/network/UDPSocket.cpp
dom/notification/DesktopNotification.cpp
dom/payments/ipc/PaymentRequestParent.cpp
dom/performance/Performance.cpp
dom/plugins/base/nsNPAPIPluginInstance.cpp
dom/plugins/ipc/ChildAsyncCall.cpp
dom/plugins/ipc/PluginInstanceChild.cpp
dom/plugins/ipc/PluginProcessParent.cpp
dom/plugins/ipc/PluginProcessParent.h
dom/presentation/PresentationAvailability.cpp
dom/presentation/PresentationCallbacks.cpp
dom/presentation/PresentationConnection.cpp
dom/presentation/PresentationDeviceManager.cpp
dom/presentation/PresentationReceiver.cpp
dom/presentation/PresentationRequest.cpp
dom/presentation/PresentationService.cpp
dom/presentation/PresentationSessionInfo.cpp
dom/presentation/PresentationTCPSessionTransport.cpp
dom/presentation/ipc/PresentationIPCService.cpp
dom/presentation/provider/MulticastDNSDeviceProvider.cpp
dom/promise/PromiseDebugging.cpp
dom/push/PushManager.cpp
dom/push/PushSubscription.cpp
dom/quota/ActorsParent.cpp
dom/quota/QuotaManagerService.cpp
dom/script/ScriptLoader.cpp
dom/security/nsCSPContext.cpp
dom/security/nsMixedContentBlocker.cpp
dom/smil/nsSMILTimedElement.cpp
dom/storage/LocalStorageCache.cpp
dom/storage/StorageDBThread.cpp
dom/storage/StorageIPC.cpp
dom/svg/SVGFEImageElement.cpp
dom/svg/SVGImageElement.cpp
dom/svg/SVGStyleElement.cpp
dom/system/nsDeviceSensors.cpp
dom/u2f/U2F.cpp
dom/url/URLMainThread.cpp
dom/url/URLWorker.cpp
dom/webauthn/U2FSoftTokenManager.cpp
dom/webbrowserpersist/WebBrowserPersistDocumentParent.cpp
dom/webbrowserpersist/WebBrowserPersistResourcesParent.cpp
dom/webbrowserpersist/WebBrowserPersistSerializeParent.cpp
dom/webbrowserpersist/nsWebBrowserPersist.cpp
dom/workers/RuntimeService.cpp
dom/workers/ScriptLoader.cpp
dom/workers/ServiceWorkerClient.cpp
dom/workers/ServiceWorkerClients.cpp
dom/workers/ServiceWorkerEvents.cpp
dom/workers/ServiceWorkerInfo.cpp
dom/workers/ServiceWorkerManager.cpp
dom/workers/ServiceWorkerManagerParent.cpp
dom/workers/ServiceWorkerManagerService.cpp
dom/workers/ServiceWorkerPrivate.cpp
dom/workers/ServiceWorkerPrivate.h
dom/workers/ServiceWorkerRegistrar.cpp
dom/workers/ServiceWorkerRegistration.cpp
dom/workers/ServiceWorkerRegistrationInfo.cpp
dom/workers/ServiceWorkerUpdateJob.cpp
dom/workers/ServiceWorkerWindowClient.cpp
dom/workers/WorkerDebuggerManager.cpp
dom/workers/WorkerPrivate.cpp
dom/workers/WorkerRunnable.cpp
dom/workers/WorkerScope.cpp
dom/xbl/nsBindingManager.cpp
dom/xhr/XMLHttpRequestMainThread.cpp
dom/xhr/XMLHttpRequestWorker.cpp
dom/xml/XMLStylesheetProcessingInstruction.cpp
dom/xml/nsXMLContentSink.cpp
dom/xml/nsXMLPrettyPrinter.cpp
dom/xslt/xslt/txMozillaXSLTProcessor.cpp
dom/xul/XULDocument.cpp
dom/xul/nsXULElement.cpp
dom/xul/templates/nsXULTemplateBuilder.cpp
editor/composer/nsEditingSession.cpp
editor/composer/nsEditorSpellCheck.cpp
editor/libeditor/EditorBase.cpp
editor/libeditor/HTMLEditRules.cpp
editor/libeditor/HTMLEditor.cpp
extensions/auth/nsHttpNegotiateAuth.cpp
extensions/spellcheck/src/mozPersonalDictionary.cpp
gfx/ipc/GPUChild.cpp
gfx/ipc/GPUParent.cpp
gfx/ipc/VsyncBridgeChild.cpp
gfx/ipc/VsyncBridgeParent.cpp
gfx/ipc/VsyncIOThreadHolder.cpp
gfx/layers/AsyncCanvasRenderer.cpp
gfx/layers/ImageContainer.h
gfx/layers/LayerScope.cpp
gfx/layers/apz/src/APZCTreeManager.cpp
gfx/layers/apz/src/AndroidAPZ.cpp
gfx/layers/apz/src/AndroidDynamicToolbarAnimator.cpp
gfx/layers/apz/src/AsyncPanZoomController.cpp
gfx/layers/apz/src/GenericFlingAnimation.h
gfx/layers/apz/src/GestureEventListener.cpp
gfx/layers/apz/src/InputQueue.cpp
gfx/layers/apz/src/Overscroll.h
gfx/layers/apz/util/ActiveElementManager.cpp
gfx/layers/apz/util/CheckerboardReportService.cpp
gfx/layers/apz/util/ChromeProcessController.cpp
gfx/layers/basic/BasicCompositor.cpp
gfx/layers/client/CompositableClient.cpp
gfx/layers/client/TextureClient.cpp
gfx/layers/client/TextureClient.h
gfx/layers/client/TextureClientPool.cpp
gfx/layers/d3d11/DeviceAttachmentsD3D11.cpp
gfx/layers/ipc/APZCTreeManagerParent.cpp
gfx/layers/ipc/CompositorBridgeChild.cpp
gfx/layers/ipc/CompositorBridgeParent.cpp
gfx/layers/ipc/CompositorManagerParent.cpp
gfx/layers/ipc/CompositorVsyncScheduler.cpp
gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
gfx/layers/ipc/ImageBridgeChild.cpp
gfx/layers/ipc/ImageBridgeParent.cpp
gfx/layers/ipc/RemoteContentController.cpp
gfx/layers/ipc/ShadowLayers.cpp
gfx/layers/ipc/ThreadSafeRefcountingWithMainThreadDestruction.h
gfx/layers/ipc/UiCompositorControllerChild.cpp
gfx/layers/ipc/UiCompositorControllerParent.cpp
gfx/src/gfxCrashReporterUtils.cpp
gfx/thebes/DeviceManagerDx.cpp
gfx/thebes/SoftwareVsyncSource.cpp
gfx/thebes/gfxFcPlatformFontList.cpp
gfx/thebes/gfxFont.cpp
gfx/thebes/gfxFontInfoLoader.cpp
gfx/thebes/gfxPlatform.cpp
gfx/thebes/gfxPlatformGtk.cpp
gfx/thebes/gfxWindowsPlatform.cpp
gfx/vr/gfxVROculus.cpp
gfx/vr/gfxVROpenVR.cpp
gfx/vr/ipc/VRManagerChild.cpp
gfx/vr/ipc/VRManagerParent.cpp
gfx/webrender_bindings/RenderThread.cpp
image/DecodePool.cpp
image/Image.cpp
image/ProgressTracker.cpp
image/RasterImage.cpp
image/test/gtest/TestDecodeToSurface.cpp
ipc/chromium/src/base/message_loop.h
ipc/chromium/src/base/object_watcher.cc
ipc/chromium/src/base/task.h
ipc/chromium/src/base/thread.cc
ipc/chromium/src/base/timer.h
ipc/chromium/src/chrome/common/process_watcher_posix_sigchld.cc
ipc/chromium/src/chrome/common/process_watcher_win.cc
ipc/glue/BackgroundImpl.cpp
ipc/glue/BackgroundParentImpl.cpp
ipc/glue/CrashReporterHost.cpp
ipc/glue/GeckoChildProcessHost.cpp
ipc/glue/IPCStreamDestination.cpp
ipc/glue/MessageChannel.cpp
ipc/glue/MessageLink.cpp
ipc/glue/MessagePump.cpp
ipc/glue/TaskFactory.h
ipc/ipdl/test/cxx/TestCancel.cpp
ipc/ipdl/test/cxx/TestDemon.cpp
ipc/ipdl/test/cxx/TestEndpointBridgeMain.cpp
ipc/ipdl/test/cxx/TestEndpointOpens.cpp
ipc/ipdl/test/cxx/TestHangs.cpp
ipc/ipdl/test/cxx/TestInterruptRaces.cpp
ipc/ipdl/test/cxx/TestInterruptShutdownRace.cpp
ipc/ipdl/test/cxx/TestNestedLoops.cpp
ipc/ipdl/test/cxx/TestUrgentHangs.cpp
ipc/mscom/DispatchForwarder.cpp
ipc/mscom/EnsureMTA.cpp
ipc/mscom/EnsureMTA.h
ipc/mscom/Interceptor.cpp
ipc/mscom/InterceptorLog.cpp
ipc/mscom/MainThreadHandoff.cpp
ipc/mscom/MainThreadInvoker.h
ipc/mscom/Ptr.h
js/xpconnect/loader/ChromeScriptLoader.cpp
js/xpconnect/loader/ScriptPreloader.cpp
js/xpconnect/loader/mozJSSubScriptLoader.cpp
js/xpconnect/src/XPCComponents.cpp
js/xpconnect/src/XPCJSRuntime.cpp
layout/base/AccessibleCaretEventHub.cpp
layout/base/PresShell.cpp
layout/base/ZoomConstraintsClient.cpp
layout/base/nsLayoutUtils.cpp
layout/base/nsPresContext.cpp
layout/base/nsRefreshDriver.cpp
layout/forms/nsComboboxControlFrame.cpp
layout/forms/nsComboboxControlFrame.h
layout/forms/nsDateTimeControlFrame.cpp
layout/forms/nsDateTimeControlFrame.h
layout/forms/nsFileControlFrame.h
layout/forms/nsNumberControlFrame.cpp
layout/forms/nsNumberControlFrame.h
layout/forms/nsTextControlFrame.h
layout/generic/nsGfxScrollFrame.cpp
layout/generic/nsGfxScrollFrame.h
layout/generic/nsPluginFrame.h
layout/generic/nsSubDocumentFrame.cpp
layout/generic/nsVideoFrame.cpp
layout/ipc/VsyncParent.cpp
layout/printing/nsPrintEngine.cpp
layout/style/FontFaceSet.cpp
layout/style/nsFontFaceLoader.cpp
layout/style/nsStyleStruct.cpp
layout/svg/SVGTextFrame.h
layout/tables/nsTableFrame.cpp
layout/xul/nsImageBoxFrame.cpp
layout/xul/nsListBoxBodyFrame.h
layout/xul/nsMenuBarFrame.cpp
layout/xul/nsMenuFrame.cpp
layout/xul/nsMenuPopupFrame.h
layout/xul/nsProgressMeterFrame.cpp
layout/xul/nsSliderFrame.cpp
layout/xul/nsXULPopupManager.h
layout/xul/tree/nsTreeBodyFrame.cpp
layout/xul/tree/nsTreeBodyFrame.h
media/mtransport/nr_socket_prsock.cpp
media/mtransport/runnable_utils.h
media/mtransport/test/TestSyncRunnable.cpp
media/mtransport/test/sockettransportservice_unittest.cpp
media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.h
media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.cpp
media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp
media/webrtc/signaling/src/mediapipeline/MediaPipeline.h
modules/libjar/nsJARChannel.cpp
modules/libpref/Preferences.cpp
netwerk/base/BackgroundFileSaver.cpp
netwerk/base/Dashboard.cpp
netwerk/base/NetworkActivityMonitor.cpp
netwerk/base/Predictor.cpp
netwerk/base/TLSServerSocket.cpp
netwerk/base/Tickler.cpp
netwerk/base/nsAsyncStreamCopier.cpp
netwerk/base/nsBaseChannel.cpp
netwerk/base/nsBaseChannel.h
netwerk/base/nsIOService.cpp
netwerk/base/nsInputStreamPump.cpp
netwerk/base/nsPACMan.cpp
netwerk/base/nsPreloadedStream.cpp
netwerk/base/nsRequestObserverProxy.cpp
netwerk/base/nsServerSocket.cpp
netwerk/base/nsSocketTransport2.cpp
netwerk/base/nsSocketTransportService2.cpp
netwerk/base/nsStreamTransportService.cpp
netwerk/base/nsUDPSocket.cpp
netwerk/cache/nsCacheEntryDescriptor.cpp
netwerk/cache/nsCacheService.cpp
netwerk/cache/nsCacheService.h
netwerk/cache/nsCacheUtils.cpp
netwerk/cache/nsDeleteDir.cpp
netwerk/cache/nsDiskCacheDevice.cpp
netwerk/cache/nsDiskCacheDeviceSQL.cpp
netwerk/cache/nsDiskCacheMap.cpp
netwerk/cache2/CacheEntry.cpp
netwerk/cache2/CacheEntry.h
netwerk/cache2/CacheFile.cpp
netwerk/cache2/CacheFileChunk.cpp
netwerk/cache2/CacheFileContextEvictor.cpp
netwerk/cache2/CacheFileIOManager.cpp
netwerk/cache2/CacheIndex.cpp
netwerk/cache2/CacheIndex.h
netwerk/cache2/CacheObserver.cpp
netwerk/cache2/CacheStorageService.cpp
netwerk/cache2/CacheStorageService.h
netwerk/cache2/OldWrappers.cpp
netwerk/dns/DNSRequestChild.cpp
netwerk/dns/mdns/libmdns/MDNSResponderOperator.cpp
netwerk/dns/mdns/libmdns/MDNSResponderReply.cpp
netwerk/dns/nsDNSService2.cpp
netwerk/ipc/ChannelEventQueue.cpp
netwerk/protocol/about/nsAboutCache.cpp
netwerk/protocol/file/nsFileChannel.cpp
netwerk/protocol/ftp/FTPChannelParent.cpp
netwerk/protocol/ftp/nsFTPChannel.cpp
netwerk/protocol/ftp/nsFtpConnectionThread.cpp
netwerk/protocol/ftp/nsFtpProtocolHandler.cpp
netwerk/protocol/gio/nsGIOProtocolHandler.cpp
netwerk/protocol/http/AlternateServices.cpp
netwerk/protocol/http/Http2Push.cpp
netwerk/protocol/http/Http2Session.cpp
netwerk/protocol/http/HttpBackgroundChannelChild.cpp
netwerk/protocol/http/HttpBackgroundChannelParent.cpp
netwerk/protocol/http/HttpBaseChannel.cpp
netwerk/protocol/http/HttpBaseChannel.h
netwerk/protocol/http/HttpChannelChild.cpp
netwerk/protocol/http/HttpChannelParent.cpp
netwerk/protocol/http/HttpChannelParentListener.cpp
netwerk/protocol/http/nsHttpActivityDistributor.cpp
netwerk/protocol/http/nsHttpChannel.cpp
netwerk/protocol/http/nsHttpConnection.cpp
netwerk/protocol/http/nsHttpConnectionMgr.cpp
netwerk/protocol/http/nsHttpHandler.cpp
netwerk/protocol/http/nsHttpTransaction.cpp
netwerk/protocol/http/nsHttpTransaction.h
netwerk/protocol/websocket/WebSocketChannel.cpp
netwerk/protocol/websocket/WebSocketChannelChild.cpp
netwerk/protocol/websocket/WebSocketEventService.cpp
netwerk/protocol/wyciwyg/nsWyciwygChannel.cpp
netwerk/sctp/datachannel/DataChannel.cpp
netwerk/sctp/datachannel/DataChannel.h
netwerk/socket/nsNamedPipeIOLayer.cpp
netwerk/socket/nsNamedPipeService.cpp
netwerk/system/linux/nsNotifyAddrListener_Linux.h
netwerk/system/win32/nsNotifyAddrListener.h
parser/html/nsHtml5StreamParser.cpp
parser/html/nsHtml5TreeOpExecutor.cpp
parser/htmlparser/nsParser.cpp
security/manager/ssl/CryptoTask.h
security/manager/ssl/DataStorage.cpp
security/manager/ssl/PSMContentListener.cpp
security/manager/ssl/PSMRunnable.cpp
security/manager/ssl/PSMRunnable.h
security/manager/ssl/SSLServerCertVerification.cpp
security/manager/ssl/nsNSSCallbacks.cpp
security/manager/ssl/nsNSSComponent.cpp
security/manager/ssl/nsNSSIOLayer.cpp
security/manager/ssl/nsNSSModule.cpp
security/sandbox/linux/reporter/SandboxReporter.cpp
services/crypto/component/IdentityCryptoService.cpp
storage/StorageBaseStatementInternal.cpp
storage/mozStorageConnection.cpp
storage/mozStoragePrivateHelpers.cpp
storage/mozStorageService.cpp
storage/test/gtest/storage_test_harness.h
storage/test/gtest/test_service_init_background_thread.cpp
storage/test/gtest/test_spinningSynchronousClose.cpp
storage/test/gtest/test_unlock_notify.cpp
toolkit/components/filewatcher/NativeFileWatcherWin.cpp
toolkit/components/osfile/NativeOSFileInternals.cpp
toolkit/components/places/FaviconHelpers.cpp
toolkit/components/places/Helpers.cpp
toolkit/components/places/Helpers.h
toolkit/components/places/History.cpp
toolkit/components/places/nsNavHistory.cpp
toolkit/components/places/tests/gtest/places_test_harness_tail.h
toolkit/components/satchel/nsFormFillController.cpp
toolkit/components/startup/nsAppStartup.cpp
toolkit/components/telemetry/Telemetry.cpp
toolkit/components/telemetry/TelemetryCommon.cpp
toolkit/components/telemetry/tests/gtest/TestScalars.cpp
toolkit/components/url-classifier/Classifier.cpp
toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
toolkit/components/url-classifier/nsUrlClassifierProxies.cpp
toolkit/components/url-classifier/nsUrlClassifierProxies.h
toolkit/components/url-classifier/tests/gtest/Common.cpp
toolkit/crashreporter/InjectCrashReporter.cpp
toolkit/crashreporter/nsExceptionHandler.cpp
toolkit/crashreporter/test/gtest/TestCrashThreadAnnotation.cpp
toolkit/xre/ProfileReset.h
toolkit/xre/nsEmbedFunctions.cpp
toolkit/xre/nsNativeAppSupportUnix.cpp
toolkit/xre/nsUpdateDriver.cpp
tools/profiler/core/platform.cpp
tools/profiler/gecko/ChildProfilerController.cpp
tools/profiler/gecko/ThreadResponsiveness.cpp
tools/profiler/tests/gtest/GeckoProfiler.cpp
uriloader/prefetch/nsOfflineCacheUpdate.cpp
view/nsView.cpp
widget/VsyncDispatcher.cpp
widget/android/AndroidBridge.cpp
widget/android/AndroidJNIWrapper.cpp
widget/android/AndroidUiThread.cpp
widget/android/EventDispatcher.cpp
widget/android/fennec/ThumbnailHelper.h
widget/android/jni/Natives.h
widget/android/nsAppShell.cpp
widget/android/nsScreenManagerAndroid.cpp
widget/android/nsWindow.cpp
widget/cocoa/nsChildView.mm
widget/gtk/nsDeviceContextSpecG.cpp
widget/gtk/nsWindow.cpp
widget/nsBaseFilePicker.cpp
widget/nsBaseWidget.cpp
widget/nsIdleService.cpp
widget/windows/AudioSession.cpp
widget/windows/LSPAnnotator.cpp
widget/windows/WidgetTraceEvent.cpp
widget/windows/nsColorPicker.cpp
widget/windows/nsSound.cpp
widget/windows/nsWindow.cpp
widget/windows/nsWindowGfx.cpp
xpcom/base/CycleCollectedJSContext.cpp
xpcom/base/nsConsoleService.cpp
xpcom/base/nsCycleCollector.cpp
xpcom/base/nsDumpUtils.cpp
xpcom/base/nsDumpUtils.h
xpcom/base/nsMemoryInfoDumper.cpp
xpcom/base/nsMemoryReporterManager.cpp
xpcom/base/nsMessageLoop.cpp
xpcom/base/nsStatusReporterManager.cpp
xpcom/ds/nsHashPropertyBag.cpp
xpcom/ds/nsObserverService.cpp
xpcom/io/nsInputStreamTee.cpp
xpcom/io/nsLocalFileWin.cpp
xpcom/tests/gtest/TestMozPromise.cpp
xpcom/tests/gtest/TestRWLock.cpp
xpcom/tests/gtest/TestRacingServiceManager.cpp
xpcom/tests/gtest/TestStateWatching.cpp
xpcom/tests/gtest/TestTaskQueue.cpp
xpcom/tests/gtest/TestThreadPool.cpp
xpcom/tests/gtest/TestThreadPoolListener.cpp
xpcom/tests/gtest/TestThreadUtils.cpp
xpcom/tests/gtest/TestTimers.cpp
xpcom/threads/AbstractThread.cpp
xpcom/threads/BackgroundHangMonitor.cpp
xpcom/threads/LazyIdleThread.cpp
xpcom/threads/MozPromise.h
xpcom/threads/SchedulerGroup.cpp
xpcom/threads/SharedThreadPool.cpp
xpcom/threads/StateMirroring.h
xpcom/threads/StateWatching.h
xpcom/threads/SyncRunnable.h
xpcom/threads/TaskDispatcher.h
xpcom/threads/TaskQueue.h
xpcom/threads/ThrottledEventQueue.cpp
xpcom/threads/TimerThread.cpp
xpcom/threads/nsMemoryPressure.cpp
xpcom/threads/nsProcessCommon.cpp
xpcom/threads/nsThread.cpp
xpcom/threads/nsThreadUtils.cpp
xpcom/threads/nsThreadUtils.h
xpfe/appshell/nsAppShellService.cpp
xpfe/appshell/nsContentTreeOwner.cpp
xpfe/components/directory/nsDirectoryViewer.cpp
--- a/accessible/generic/Accessible.cpp
+++ b/accessible/generic/Accessible.cpp
@@ -1794,23 +1794,18 @@ 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)
-      : mozilla::Runnable("Runnable")
-      , mAcc(aAcc)
-      , mContent(aContent)
-      , mIdx(aIdx)
-    {
-    }
+    Runnable(Accessible* aAcc, nsIContent* aContent, uint32_t aIdx) :
+      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,22 +644,19 @@ 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->InitWithNamedFuncCallback(
-        ScrollTimerCallback,
-        this,
-        kScrollPosCheckWait,
-        nsITimer::TYPE_REPEATING_SLACK,
-        "a11y::DocAccessible::ScrollPositionDidChange");
+      mScrollWatchTimer->InitWithFuncCallback(ScrollTimerCallback, this,
+                                              kScrollPosCheckWait,
+                                              nsITimer::TYPE_REPEATING_SLACK);
     }
   }
   mScrollPositionChangedTicks = 1;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIObserver
 
--- a/accessible/ipc/win/HandlerProvider.cpp
+++ b/accessible/ipc/win/HandlerProvider.cpp
@@ -90,18 +90,17 @@ HandlerProvider::GetAndSerializePayload(
   MOZ_ASSERT(mscom::IsCurrentThreadMTA());
 
   if (mSerializer) {
     return;
   }
 
   IA2Payload payload{};
 
-  if (!mscom::InvokeOnMainThread("HandlerProvider::BuildIA2Data",
-                                 this, &HandlerProvider::BuildIA2Data,
+  if (!mscom::InvokeOnMainThread(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.
@@ -232,33 +231,31 @@ HandlerProvider::put_HandlerControl(long
   MOZ_ASSERT(mscom::IsCurrentThreadMTA());
 
   if (!aCtrl) {
     return E_INVALIDARG;
   }
 
   auto ptrProxy = mscom::ToProxyUniquePtr(aCtrl);
 
-  if (!mscom::InvokeOnMainThread("HandlerProvider::SetHandlerControlOnMainThread",
-                                 this,
+  if (!mscom::InvokeOnMainThread(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("HandlerProvider::BuildIA2Data",
-                                 this, &HandlerProvider::BuildIA2Data,
+  if (!mscom::InvokeOnMainThread(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,18 +836,17 @@ 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("Accessible::TakeFocus",
-                                   this, &Accessible::TakeFocus);
+        mozilla::NewRunnableMethod(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,18 +246,17 @@ 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>>("LazyInstantiator::GatherTelemetry",
-                                             this,
+        NewRunnableMethod<nsCOMPtr<nsIFile>>(this,
                                              &LazyInstantiator::GatherTelemetry,
                                              clientExe));
     NS_NewThread(getter_AddRefs(mTelemetryThread), runnable);
   }
 #endif // defined(MOZ_TELEMETRY_REPORTING)
   return true;
 }
 
@@ -323,19 +322,17 @@ 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>(
-        "LazyInstantiator::AccumulateTelemetry",
-        this,
+  NS_DispatchToMainThread(NewNonOwningRunnableMethod<nsString>(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,22 +74,18 @@ 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->InitWithNamedFuncCallback(
-        ShutdownCallback,
-        this,
-        100,
-        nsITimer::TYPE_ONE_SHOT,
-        "xpcAccessibilityService::Release");
+      mShutdownTimer->InitWithFuncCallback(ShutdownCallback, this, 100,
+                                           nsITimer::TYPE_ONE_SHOT);
     }
   }
 
   return count;
 }
 
 NS_IMPL_QUERY_INTERFACE(xpcAccessibilityService, nsIAccessibilityService,
                                                  nsIAccessibleRetrieval)
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -449,22 +449,19 @@ 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->InitWithNamedFuncCallback(OnPingTimeout,
-                                       mLoadGroup,
-                                       PING_TIMEOUT,
-                                       nsITimer::TYPE_ONE_SHOT,
-                                       "nsPingListener::StartTimeout");
+    nsresult rv = timer->InitWithFuncCallback(OnPingTimeout, mLoadGroup,
+                                              PING_TIMEOUT,
+                                              nsITimer::TYPE_ONE_SHOT);
     if (NS_SUCCEEDED(rv)) {
       mTimer = timer;
       return NS_OK;
     }
   }
 
   return NS_ERROR_OUT_OF_MEMORY;
 }
@@ -1765,22 +1762,20 @@ 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("nsDocShell::FireDummyOnLocationChange",
-                      this,
-                      &nsDocShell::FireDummyOnLocationChange));
+  return DispatchToTabGroup("nsDocShell::FireDummyOnLocationChange",
+                            TaskCategory::Other,
+                            NewRunnableMethod(this,
+                              &nsDocShell::FireDummyOnLocationChange));
 }
 
 bool
 nsDocShell::MaybeInitTiming()
 {
   if (mTiming && !mBlankTiming) {
     return false;
   }
@@ -9644,30 +9639,23 @@ 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)
-    : mozilla::Runnable("InternalLoadEvent")
-    , 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)
+    : mSrcdoc(aSrcdoc)
     , mDocShell(aDocShell)
     , mURI(aURI)
     , mOriginalURI(aOriginalURI)
     , mResultPrincipalURI(aResultPrincipalURI)
     , mLoadReplace(aLoadReplace)
     , mReferrer(aReferrer)
     , mReferrerPolicy(aReferrerPolicy)
     , mTriggeringPrincipal(aTriggeringPrincipal)
@@ -14047,18 +14035,17 @@ OnLinkClickEvent::OnLinkClickEvent(nsDoc
                                    nsIURI* aURI,
                                    const char16_t* aTargetSpec,
                                    const nsAString& aFileName,
                                    nsIInputStream* aPostDataStream,
                                    nsIInputStream* aHeadersDataStream,
                                    bool aNoOpenerImplied,
                                    bool aIsTrusted,
                                    nsIPrincipal* aTriggeringPrincipal)
-  : mozilla::Runnable("OnLinkClickEvent")
-  , mHandler(aHandler)
+  : 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,21 +772,17 @@ protected:
   }
 
 public:
   // Event type dispatched by RestorePresentation
   class RestorePresentationEvent : public mozilla::Runnable
   {
   public:
     NS_DECL_NSIRUNNABLE
-    explicit RestorePresentationEvent(nsDocShell* aDs)
-      : mozilla::Runnable("nsDocShell::RestorePresentationEvent")
-      , mDocShell(aDs)
-    {
-    }
+    explicit RestorePresentationEvent(nsDocShell* aDs) : mDocShell(aDs) {}
     void Revoke() { mDocShell = nullptr; }
   private:
     RefPtr<nsDocShell> mDocShell;
   };
 
 protected:
   bool JustStartedNetworkLoad();
 
--- a/docshell/base/nsDocShellTreeOwner.cpp
+++ b/docshell/base/nsDocShellTreeOwner.cpp
@@ -1255,22 +1255,20 @@ 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->InitWithNamedFuncCallback(
-          sTooltipCallback,
-          this,
+        nsresult rv = mTooltipTimer->InitWithFuncCallback(
+          sTooltipCallback, this,
           LookAndFeel::GetInt(LookAndFeel::eIntID_TooltipDelay, 500),
-          nsITimer::TYPE_ONE_SHOT,
-          "ChromeTooltipListener::MouseMove");
+          nsITimer::TYPE_ONE_SHOT);
         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,18 +180,17 @@ nsSHEntryShared::RemoveFromBFCacheSync()
 
   return NS_OK;
 }
 
 class DestroyViewerEvent : public mozilla::Runnable
 {
 public:
   DestroyViewerEvent(nsIContentViewer* aViewer, nsIDocument* aDocument)
-    : mozilla::Runnable("DestroyViewerEvent")
-    , mViewer(aViewer)
+    : mViewer(aViewer)
     , mDocument(aDocument)
   {
   }
 
   NS_IMETHOD Run() override
   {
     if (mViewer) {
       mViewer->Destroy();
--- a/dom/animation/Animation.cpp
+++ b/dom/animation/Animation.cpp
@@ -1448,19 +1448,17 @@ void
 Animation::DoFinishNotification(SyncNotifyFlag aSyncNotifyFlag)
 {
   CycleCollectedJSContext* context = CycleCollectedJSContext::Get();
 
   if (aSyncNotifyFlag == SyncNotifyFlag::Sync) {
     DoFinishNotificationImmediately();
   } else if (!mFinishNotificationTask.IsPending()) {
     RefPtr<nsRunnableMethod<Animation>> runnable =
-      NewRunnableMethod("dom::Animation::DoFinishNotificationImmediately",
-                        this,
-                        &Animation::DoFinishNotificationImmediately);
+      NewRunnableMethod(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,22 +237,21 @@ 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()
-    : Runnable("dom::asmjscache::FileDescriptorHolder")
-    , mQuotaObject(nullptr)
-    , mFileSize(INT64_MIN)
-    , mFileDesc(nullptr)
-    , mFileMap(nullptr)
-    , mMappedMemory(nullptr)
+  : 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,21 +80,19 @@ 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)
-    : mozilla::Runnable("AudioPlaybackRunnable")
-    , mWindow(aWindow)
+    : mWindow(aWindow)
     , mActive(aActive)
     , mReason(aReason)
   {}
 
  NS_IMETHOD Run() override
  {
     nsCOMPtr<nsIObserverService> observerService =
       services::GetObserverService();
@@ -871,29 +869,28 @@ 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(
-    "dom::AudioChannelService::AudioChannelWindow::NotifyMediaBlockStop",
-    [window]() -> void {
+  NS_DispatchToCurrentThread(NS_NewRunnableFunction([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));
 
@@ -1047,27 +1044,26 @@ AudioChannelService::AudioChannelWindow:
 
   if (window->GetMediaSuspend() != nsISuspendedTypes::SUSPENDED_BLOCK ||
       !doc->Hidden()) {
     return;
   }
 
   if (!mShouldSendBlockStopEvent) {
       mShouldSendBlockStopEvent = true;
-      NS_DispatchToCurrentThread(NS_NewRunnableFunction(
-        "dom::AudioChannelService::AudioChannelWindow::"
-        "MaybeNotifyMediaBlockStart",
-        [window]() -> void {
-          nsCOMPtr<nsIObserverService> observerService =
-            services::GetObserverService();
-          if (NS_WARN_IF(!observerService)) {
-            return;
-          }
+      NS_DispatchToCurrentThread(NS_NewRunnableFunction([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,19 +449,18 @@ 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(
-        "dom::CustomElementRegistry::EnqueueLifecycleCallback",
-        &CustomElementRegistry::ProcessTopElementQueue);
+      nsCOMPtr<nsIRunnable> runnable =
+        NS_NewRunnableFunction(&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,21 +238,18 @@ private:
    */
   void InvokeReactions(ElementQueue& aElementQueue);
 
   void Enqueue(Element* aElement, CustomElementReaction* aReaction);
 
 private:
   class ProcessBackupQueueRunnable : public mozilla::Runnable {
     public:
-      explicit ProcessBackupQueueRunnable(
-        CustomElementReactionsStack* aReactionStack)
-        : Runnable(
-            "dom::CustomElementReactionsStack::ProcessBackupQueueRunnable")
-        , mReactionStack(aReactionStack)
+      explicit ProcessBackupQueueRunnable(CustomElementReactionsStack* aReactionStack)
+        : 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)
-    : mozilla::Runnable("FireSuccessAsyncTask")
-    , mReq(aRequest)
-    , mResult(RootingCx(), aResult)
+  FireSuccessAsyncTask(DOMRequest* aRequest,
+                       const JS::Value& aResult) :
+    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)
-    : mozilla::Runnable("FireErrorAsyncTask")
-    , mReq(aRequest)
-    , mError(aError)
+  FireErrorAsyncTask(DOMRequest* aRequest,
+                     const nsAString& aError) :
+    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,19 +608,17 @@ 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("nsXBLBinding::ExecuteAttachedHandler",
-                              binding,
-                              &nsXBLBinding::ExecuteAttachedHandler));
+            NewRunnableMethod(binding, &nsXBLBinding::ExecuteAttachedHandler));
         }
       }
     }
   }
 
   return obj;
 }
 
@@ -1785,24 +1783,20 @@ 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)
-  : mozilla::Runnable("dom::RemoveFromBindingManagerRunnable")
-  , mManager(aManager)
-  , mContent(aContent)
-  , mDoc(aDoc)
+RemoveFromBindingManagerRunnable::RemoveFromBindingManagerRunnable(nsBindingManager* aManager,
+                                                                   nsIContent* aContent,
+                                                                   nsIDocument* aDoc):
+  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,19 +386,17 @@ 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("dom::EventSourceImpl::CloseInternal",
-                               this,
-                               &EventSourceImpl::CloseInternal),
+    Dispatch(NewRunnableMethod(this, &EventSourceImpl::CloseInternal),
              NS_DISPATCH_NORMAL);
   MOZ_ASSERT(NS_SUCCEEDED(rv));
 }
 
 void
 EventSourceImpl::CloseInternal()
 {
   AssertIsOnTargetThread();
@@ -680,19 +678,17 @@ 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("dom::EventSourceImpl::AnnounceConnection",
-                                  this,
-                                  &EventSourceImpl::AnnounceConnection),
+  rv = Dispatch(NewRunnableMethod(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.
@@ -751,18 +747,17 @@ class DataAvailableRunnable final : publ
   private:
     RefPtr<EventSourceImpl> mEventSourceImpl;
     UniquePtr<char[]> mData;
     uint32_t mLength;
   public:
     DataAvailableRunnable(EventSourceImpl* aEventSourceImpl,
                           UniquePtr<char[]> aData,
                           uint32_t aLength)
-      : Runnable("dom::DataAvailableRunnable")
-      , mEventSourceImpl(aEventSourceImpl)
+      : mEventSourceImpl(aEventSourceImpl)
       , mData(Move(aData))
       , mLength(aLength)
     {
     }
 
     NS_IMETHOD Run() override
     {
       mEventSourceImpl->ParseSegment(mData.get(), mLength);
@@ -840,20 +835,19 @@ 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("dom::EventSourceImpl::ReestablishConnection",
-                                  this,
-                                  &EventSourceImpl::ReestablishConnection),
-                NS_DISPATCH_NORMAL);
+  rv = Dispatch(
+         NewRunnableMethod(this, &EventSourceImpl::ReestablishConnection),
+         NS_DISPATCH_NORMAL);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 // EventSourceImpl::nsIChannelEventSink
 //-----------------------------------------------------------------------------
@@ -1246,22 +1240,19 @@ 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->InitWithNamedFuncCallback(
-    TimerCallback,
-    this,
-    mReconnectionTime,
-    nsITimer::TYPE_ONE_SHOT,
-    "dom::EventSourceImpl::SetReconnectionTimeout");
+  nsresult rv = mTimer->InitWithFuncCallback(TimerCallback, this,
+                                             mReconnectionTime,
+                                             nsITimer::TYPE_ONE_SHOT);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
 nsresult
 EventSourceImpl::PrintErrorOnConsole(const char* aBundleURI,
                                      const char16_t* aError,
@@ -1345,19 +1336,17 @@ 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("dom::EventSourceImpl::FailConnection",
-                                  this,
-                                  &EventSourceImpl::FailConnection),
+  rv = Dispatch(NewRunnableMethod(this, &EventSourceImpl::FailConnection),
                 NS_DISPATCH_NORMAL);
   MOZ_ASSERT(NS_SUCCEEDED(rv));
 }
 
 void
 EventSourceImpl::FailConnection()
 {
   AssertIsOnTargetThread();
@@ -1413,19 +1402,17 @@ EventSourceImpl::Thaw()
   }
 
   MOZ_ASSERT(!mHttpChannel, "the connection hasn't been closed!!!");
 
   SetFrozen(false);
   nsresult rv;
   if (!mGoingToDispatchAllMessages && mMessagesToDispatch.GetSize() > 0) {
     nsCOMPtr<nsIRunnable> event =
-      NewRunnableMethod("dom::EventSourceImpl::DispatchAllMessageEvents",
-                        this,
-                        &EventSourceImpl::DispatchAllMessageEvents);
+      NewRunnableMethod(this, &EventSourceImpl::DispatchAllMessageEvents);
     NS_ENSURE_STATE(event);
 
     mGoingToDispatchAllMessages = true;
 
     rv = Dispatch(event.forget(), NS_DISPATCH_NORMAL);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
@@ -1476,19 +1463,17 @@ 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("dom::EventSourceImpl::DispatchAllMessageEvents",
-                        this,
-                        &EventSourceImpl::DispatchAllMessageEvents);
+      NewRunnableMethod(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(
-        "dom::ImageEncoder::EnsureThreadPool",
-        []() -> void { RegisterEncoderThreadPoolTerminatorObserver(); }));
+      NS_DispatchToMainThread(NS_NewRunnableFunction([]() -> 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,26 +30,24 @@ namespace mozilla {
 namespace dom {
 
 PostMessageEvent::PostMessageEvent(nsGlobalWindow* aSource,
                                    const nsAString& aCallerOrigin,
                                    nsGlobalWindow* aTargetWindow,
                                    nsIPrincipal* aProvidedPrincipal,
                                    nsIDocument* aSourceDocument,
                                    bool aTrustedCaller)
-  : Runnable("dom::PostMessageEvent")
-  , StructuredCloneHolder(CloningSupported,
-                          TransferringSupported,
-                          StructuredCloneScope::SameProcessSameThread)
-  , mSource(aSource)
-  , mCallerOrigin(aCallerOrigin)
-  , mTargetWindow(aTargetWindow)
-  , mProvidedPrincipal(aProvidedPrincipal)
-  , mSourceDocument(aSourceDocument)
-  , mTrustedCaller(aTrustedCaller)
+: 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,20 +548,18 @@ ScreenOrientation::Notify(const hal::Scr
     doc->SetCurrentOrientation(mType, mAngle);
 
     Promise* pendingPromise = doc->GetOrientationPendingPromise();
     if (pendingPromise) {
       pendingPromise->MaybeResolveWithUndefined();
       doc->SetOrientationPendingPromise(nullptr);
     }
 
-    nsCOMPtr<nsIRunnable> runnable =
-      NewRunnableMethod("dom::ScreenOrientation::DispatchChangeEvent",
-                        this,
-                        &ScreenOrientation::DispatchChangeEvent);
+    nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod(this,
+      &ScreenOrientation::DispatchChangeEvent);
     rv = NS_DispatchToMainThread(runnable);
     NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed");
   }
 }
 
 void
 ScreenOrientation::UpdateActiveOrientationLock(ScreenOrientationInternal aOrientation)
 {
@@ -637,20 +635,18 @@ ScreenOrientation::VisibleEventListener:
 			       orientation->DeviceAngle(CallerType::System));
 
     Promise* pendingPromise = doc->GetOrientationPendingPromise();
     if (pendingPromise) {
       pendingPromise->MaybeResolveWithUndefined();
       doc->SetOrientationPendingPromise(nullptr);
     }
 
-    nsCOMPtr<nsIRunnable> runnable =
-      NewRunnableMethod("dom::ScreenOrientation::DispatchChangeEvent",
-                        orientation,
-                        &ScreenOrientation::DispatchChangeEvent);
+    nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod(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,23 +318,21 @@ private:
   class ScrollSelectionIntoViewEvent : public Runnable {
   public:
     NS_DECL_NSIRUNNABLE
     ScrollSelectionIntoViewEvent(Selection* aSelection,
                                  SelectionRegion aRegion,
                                  nsIPresShell::ScrollAxis aVertical,
                                  nsIPresShell::ScrollAxis aHorizontal,
                                  int32_t aFlags)
-      : Runnable("dom::Selection::ScrollSelectionIntoViewEvent")
-      , mSelection(aSelection)
-      , mRegion(aRegion)
-      , mVerticalScroll(aVertical)
-      , mHorizontalScroll(aHorizontal)
-      , mFlags(aFlags)
-    {
+      : 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,18 +263,17 @@ NS_IMPL_ISUPPORTS(WebSocketImpl,
                   nsISupportsWeakReference,
                   nsIRequest,
                   nsIEventTarget)
 
 class CallDispatchConnectionCloseEvents final : public CancelableRunnable
 {
 public:
   explicit CallDispatchConnectionCloseEvents(WebSocketImpl* aWebSocketImpl)
-    : CancelableRunnable("dom::CallDispatchConnectionCloseEvents")
-    , mWebSocketImpl(aWebSocketImpl)
+    : mWebSocketImpl(aWebSocketImpl)
   {
     aWebSocketImpl->AssertIsOnTargetThread();
   }
 
   NS_IMETHOD Run() override
   {
     mWebSocketImpl->AssertIsOnTargetThread();
     mWebSocketImpl->DispatchConnectionCloseEvents();
@@ -400,21 +399,19 @@ 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)
-    : Runnable("dom::CancelWebSocketRunnable")
-    , mChannel(aChannel)
+    : mChannel(aChannel)
     , mReasonCode(aReasonCode)
     , mReasonString(aReasonString)
   {}
 
   NS_IMETHOD Run() override
   {
     nsresult rv = mChannel->Close(mReasonCode, mReasonString);
     if (NS_FAILED(rv)) {
@@ -456,18 +453,17 @@ private:
 };
 
 class CloseConnectionRunnable final : public Runnable
 {
 public:
   CloseConnectionRunnable(WebSocketImpl* aImpl,
                           uint16_t aReasonCode,
                           const nsACString& aReasonString)
-    : Runnable("dom::CloseConnectionRunnable")
-    , mImpl(aImpl)
+    : 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,19 +280,18 @@ 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("nsContentSink::DoProcessLinkHeader",
-                                 this,
-                                 &nsContentSink::DoProcessLinkHeader);
+      NewNonOwningRunnableMethod(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,26 +5317,22 @@ nsContentUtils::IsInSameAnonymousTree(co
       aContent->GetContainingShadow();
   }
 
   return nodeAsContent->GetBindingParent() == aContent->GetBindingParent();
 }
 
 class AnonymousContentDestroyer : public Runnable {
 public:
-  explicit AnonymousContentDestroyer(nsCOMPtr<nsIContent>* aContent)
-    : mozilla::Runnable("AnonymousContentDestroyer")
-  {
+  explicit AnonymousContentDestroyer(nsCOMPtr<nsIContent>* aContent) {
     mContent.swap(*aContent);
     mParent = mContent->GetParent();
     mDoc = mContent->OwnerDoc();
   }
-  explicit AnonymousContentDestroyer(nsCOMPtr<Element>* aElement)
-    : mozilla::Runnable("AnonymousContentDestroyer")
-  {
+  explicit AnonymousContentDestroyer(nsCOMPtr<Element>* aElement) {
     mContent = aElement->forget();
     mParent = mContent->GetParent();
     mDoc = mContent->OwnerDoc();
   }
   NS_IMETHOD Run() override {
     mContent->UnbindFromTree();
     return NS_OK;
   }
@@ -10559,19 +10555,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("nsContentUtils::UserInteractionObserver::Init",
-                           [=]() { HangMonitor::RegisterAnnotator(*self); }));
+  NS_DispatchToMainThread(NS_NewRunnableFunction([=] () {
+        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,17 +862,16 @@ 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,76 +1104,59 @@ 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*>("nsIWidget::SynthesizeNativeKeyEvent",
-                                    widget,
-                                    &nsIWidget::SynthesizeNativeKeyEvent,
-                                    aNativeKeyboardLayout,
-                                    aNativeKeyCode,
-                                    aModifiers,
-                                    aCharacters,
-                                    aUnmodifiedCharacters,
-                                    aObserver));
+  NS_DispatchToMainThread(NewRunnableMethod
+    <int32_t, int32_t, uint32_t, nsString, nsString, nsIObserver*>
+    (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*>(
-      "nsIWidget::SynthesizeNativeMouseEvent",
-      widget,
-      &nsIWidget::SynthesizeNativeMouseEvent,
-      LayoutDeviceIntPoint(aScreenX, aScreenY),
-      aNativeMessage,
-      aModifierFlags,
-      aObserver));
+  NS_DispatchToMainThread(NewRunnableMethod
+    <LayoutDeviceIntPoint, int32_t, int32_t, nsIObserver*>
+    (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*>(
-    "nsIWidget::SynthesizeNativeMouseMove",
-    widget,
-    &nsIWidget::SynthesizeNativeMouseMove,
-    LayoutDeviceIntPoint(aScreenX, aScreenY),
-    aObserver));
+  NS_DispatchToMainThread(NewRunnableMethod
+    <LayoutDeviceIntPoint, nsIObserver*>
+    (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,
@@ -1185,35 +1168,21 @@ 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*>(
-    "nsIWidget::SynthesizeNativeMouseScrollEvent",
-    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*>
+    (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,
@@ -1225,69 +1194,53 @@ 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*>("nsIWidget::SynthesizeNativeTouchPoint",
-                                    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*>
+    (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*>(
-      "nsIWidget::SynthesizeNativeTouchTap",
-      widget,
-      &nsIWidget::SynthesizeNativeTouchTap,
-      LayoutDeviceIntPoint(aScreenX, aScreenY),
-      aLongTap,
-      aObserver));
+  NS_DispatchToMainThread(NewRunnableMethod
+    <LayoutDeviceIntPoint, bool, nsIObserver*>
+    (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*>("nsIWidget::ClearNativeTouchSequence",
-                                    widget,
-                                    &nsIWidget::ClearNativeTouchSequence,
-                                    aObserver));
+  NS_DispatchToMainThread(NewRunnableMethod<nsIObserver*>
+    (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,18 +13,17 @@
 #include "nsContentSink.h"
 #include "nsCOMPtr.h"
 #include "nsIDocument.h"
 
 class nsDocElementCreatedNotificationRunner : public mozilla::Runnable
 {
 public:
   explicit nsDocElementCreatedNotificationRunner(nsIDocument* aDoc)
-    : mozilla::Runnable("nsDocElementCreatedNotificationRunner")
-    , mDoc(aDoc)
+    : mDoc(aDoc)
   {
   }
 
   NS_IMETHOD Run() override
   {
     nsContentSink::NotifyDocElementCreated(mDoc);
     return NS_OK;
   }
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -4429,20 +4429,18 @@ nsDocument::SetStyleSheetApplicableState
     DO_STYLESHEET_NOTIFICATION(StyleSheetApplicableStateChangeEvent,
                                "StyleSheetApplicableStateChanged",
                                mApplicable,
                                aApplicable);
   }
 
   if (!mSSApplicableStateNotificationPending) {
     MOZ_RELEASE_ASSERT(NS_IsMainThread());
-    nsCOMPtr<nsIRunnable> notification =
-      NewRunnableMethod("nsDocument::NotifyStyleSheetApplicableStateChanged",
-                        this,
-                        &nsDocument::NotifyStyleSheetApplicableStateChanged);
+    nsCOMPtr<nsIRunnable> notification = NewRunnableMethod(this,
+      &nsDocument::NotifyStyleSheetApplicableStateChanged);
     mSSApplicableStateNotificationPending =
       NS_SUCCEEDED(
         Dispatch("nsDocument::NotifyStyleSheetApplicableStateChanged",
                  TaskCategory::Other, notification.forget()));
   }
 }
 
 void
@@ -5047,19 +5045,17 @@ 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("nsDocument::MaybeEndOutermostXBLUpdate",
-                            this,
-                            &nsDocument::MaybeEndOutermostXBLUpdate);
+          NewRunnableMethod(this, &nsDocument::MaybeEndOutermostXBLUpdate);
       }
       nsContentUtils::AddScriptRunner(mMaybeEndOutermostXBLUpdateRunner);
     }
   }
 }
 
 void
 nsDocument::BeginUpdate(nsUpdateType aUpdateType)
@@ -5380,19 +5376,17 @@ nsDocument::UnblockDOMContentLoaded()
     return;
   }
   mDidFireDOMContentLoaded = true;
 
   MOZ_ASSERT(mReadyState == READYSTATE_INTERACTIVE);
   if (!mSynchronousDOMContentLoaded) {
     MOZ_RELEASE_ASSERT(NS_IsMainThread());
     nsCOMPtr<nsIRunnable> ev =
-      NewRunnableMethod("nsDocument::DispatchContentLoadedEvents",
-                        this,
-                        &nsDocument::DispatchContentLoadedEvents);
+      NewRunnableMethod(this, &nsDocument::DispatchContentLoadedEvents);
     Dispatch("nsDocument::DispatchContentLoadedEvents", TaskCategory::Other, ev.forget());
   } else {
     DispatchContentLoadedEvents();
   }
 }
 
 void
 nsDocument::ContentStateChanged(nsIContent* aContent, EventStates aStateMask)
@@ -7020,19 +7014,17 @@ nsDocument::NotifyPossibleTitleChange(bo
   if (aBoundTitleElement) {
     mMayHaveTitleElement = true;
   }
   if (mPendingTitleChangeEvent.IsPending())
     return;
 
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   RefPtr<nsRunnableMethod<nsDocument, void, false>> event =
-    NewNonOwningRunnableMethod("nsDocument::DoNotifyPossibleTitleChange",
-                               this,
-                               &nsDocument::DoNotifyPossibleTitleChange);
+    NewNonOwningRunnableMethod(this, &nsDocument::DoNotifyPossibleTitleChange);
   nsresult rv = Dispatch("nsDocument::DoNotifyPossibleTitleChange",
                          TaskCategory::Other, do_AddRef(event));
   if (NS_SUCCEEDED(rv)) {
     mPendingTitleChangeEvent = event;
   }
 }
 
 void
@@ -7172,19 +7164,17 @@ 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("nsDocument::MaybeInitializeFinalizeFrameLoaders",
-                        this,
-                        &nsDocument::MaybeInitializeFinalizeFrameLoaders);
+      NewRunnableMethod(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)
@@ -7192,19 +7182,17 @@ nsDocument::FinalizeFrameLoader(nsFrameL
   mInitializableFrameLoaders.RemoveElement(aLoader);
   if (mInDestructor) {
     return NS_ERROR_FAILURE;
   }
 
   mFrameLoaderFinalizers.AppendElement(aFinalizer);
   if (!mFrameLoaderRunner) {
     mFrameLoaderRunner =
-      NewRunnableMethod("nsDocument::MaybeInitializeFinalizeFrameLoaders",
-                        this,
-                        &nsDocument::MaybeInitializeFinalizeFrameLoaders);
+      NewRunnableMethod(this, &nsDocument::MaybeInitializeFinalizeFrameLoaders);
     NS_ENSURE_TRUE(mFrameLoaderRunner, NS_ERROR_OUT_OF_MEMORY);
     nsContentUtils::AddScriptRunner(mFrameLoaderRunner);
   }
   return NS_OK;
 }
 
 void
 nsDocument::MaybeInitializeFinalizeFrameLoaders()
@@ -7218,19 +7206,17 @@ 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("nsDocument::MaybeInitializeFinalizeFrameLoaders",
-                          this,
-                          &nsDocument::MaybeInitializeFinalizeFrameLoaders);
+        NewRunnableMethod(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
@@ -8797,18 +8783,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(
-          "nsDocument::AsyncBlockOnload", this, &nsDocument::AsyncBlockOnload));
+        nsContentUtils::AddScriptRunner(
+          NewRunnableMethod(this, &nsDocument::AsyncBlockOnload));
       }
       return;
     }
     nsCOMPtr<nsILoadGroup> loadGroup = GetDocumentLoadGroup();
     if (loadGroup) {
       loadGroup->AddRequest(mOnloadBlocker, nullptr);
     }
   }
@@ -8855,21 +8841,17 @@ nsDocument::UnblockOnload(bool aFireSync
                                  false);
       asyncDispatcher->PostDOMEvent();
     }
   }
 }
 
 class nsUnblockOnloadEvent : public Runnable {
 public:
-  explicit nsUnblockOnloadEvent(nsDocument* aDoc)
-    : mozilla::Runnable("nsUnblockOnloadEvent")
-    , mDoc(aDoc)
-  {
-  }
+  explicit nsUnblockOnloadEvent(nsDocument* aDoc) : mDoc(aDoc) {}
   NS_IMETHOD Run() override {
     mDoc->DoUnblockOnload();
     return NS_OK;
   }
 private:
   RefPtr<nsDocument> mDoc;
 };
 
@@ -9741,17 +9723,16 @@ 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);
@@ -9988,19 +9969,17 @@ nsIDocument::RegisterPendingLinkUpdate(L
   if (aLink->HasPendingLinkUpdate()) {
     return;
   }
 
   aLink->SetHasPendingLinkUpdate();
 
   if (!mHasLinksToUpdateRunnable) {
     nsCOMPtr<nsIRunnable> event =
-      NewRunnableMethod("nsIDocument::FlushPendingLinkUpdatesFromRunnable",
-                        this,
-                        &nsIDocument::FlushPendingLinkUpdatesFromRunnable);
+      NewRunnableMethod(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;
     }
@@ -10912,20 +10891,17 @@ AskWindowToExitFullscreen(nsIDocument* a
     }
   }
 }
 
 class nsCallExitFullscreen : public Runnable
 {
 public:
   explicit nsCallExitFullscreen(nsIDocument* aDoc)
-    : mozilla::Runnable("nsCallExitFullscreen")
-    , mDoc(aDoc)
-  {
-  }
+    : mDoc(aDoc) {}
 
   NS_IMETHOD Run() override final
   {
     if (!mDoc) {
       FullscreenRoots::ForEach(&AskWindowToExitFullscreen);
     } else {
       AskWindowToExitFullscreen(mDoc);
     }
@@ -10995,20 +10971,17 @@ 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)
-    : mozilla::Runnable("ExitFullscreenScriptRunnable")
-    , mDocuments(Move(aDocuments))
-  {
-  }
+    : 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(
@@ -11192,20 +11165,17 @@ nsDocument::RestorePreviousFullScreenSta
       /* Bubbles */ true, /* ChromeOnly */ true);
   }
 }
 
 class nsCallRequestFullScreen : public Runnable
 {
 public:
   explicit nsCallRequestFullScreen(UniquePtr<FullscreenRequest>&& aRequest)
-    : mozilla::Runnable("nsCallRequestFullScreen")
-    , mRequest(Move(aRequest))
-  {
-  }
+    : mRequest(Move(aRequest)) { }
 
   NS_IMETHOD Run() override
   {
     mRequest->GetDocument()->RequestFullScreen(Move(mRequest));
     return NS_OK;
   }
 
   UniquePtr<FullscreenRequest> mRequest;
@@ -11925,18 +11895,17 @@ DispatchPointerLockError(nsIDocument* aT
                                   nsContentUtils::eDOM_PROPERTIES,
                                   aMessage);
 }
 
 class PointerLockRequest final : public Runnable
 {
 public:
   PointerLockRequest(Element* aElement, bool aUserInputOrChromeCaller)
-    : mozilla::Runnable("PointerLockRequest")
-    , mElement(do_GetWeakReference(aElement))
+    : mElement(do_GetWeakReference(aElement))
     , mDocument(do_GetWeakReference(aElement->OwnerDoc()))
     , mUserInputOrChromeCaller(aUserInputOrChromeCaller)
   {}
 
   NS_IMETHOD Run() final;
 
 private:
   nsWeakPtr mElement;
@@ -12277,19 +12246,17 @@ nsDocument::GetVisibilityState() const
 
   return dom::VisibilityState::Visible;
 }
 
 /* virtual */ void
 nsDocument::PostVisibilityUpdateEvent()
 {
   nsCOMPtr<nsIRunnable> event =
-    NewRunnableMethod("nsDocument::UpdateVisibilityState",
-                      this,
-                      &nsDocument::UpdateVisibilityState);
+    NewRunnableMethod(this, &nsDocument::UpdateVisibilityState);
   Dispatch("nsDocument::UpdateVisibilityState", TaskCategory::Other, event.forget());
 }
 
 void
 nsDocument::MaybeActiveMediaComponents()
 {
   if (!mWindow) {
     return;
@@ -12824,19 +12791,17 @@ nsDocument::UpdateIntersectionObservatio
 void
 nsDocument::ScheduleIntersectionObserverNotification()
 {
   if (mIntersectionObservers.IsEmpty()) {
     return;
   }
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   nsCOMPtr<nsIRunnable> notification =
-    NewRunnableMethod("nsDocument::NotifyIntersectionObservers",
-                      this,
-                      &nsDocument::NotifyIntersectionObservers);
+    NewRunnableMethod(this, &nsDocument::NotifyIntersectionObservers);
   Dispatch("nsDocument::IntersectionObserverNotification", TaskCategory::Other,
            notification.forget());
 }
 
 void
 nsDocument::NotifyIntersectionObservers()
 {
   nsTArray<RefPtr<DOMIntersectionObserver>> observers(mIntersectionObservers.Count());
@@ -13116,19 +13081,17 @@ 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("nsIDocument::HandleRebuildUserFontSet",
-                        this,
-                        &nsIDocument::HandleRebuildUserFontSet);
+      NewRunnableMethod(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,24 +2016,20 @@ 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)
-    : mozilla::Runnable("FocusBlurEvent")
-    , mTarget(aTarget)
+  FocusBlurEvent(nsISupports* aTarget, EventMessage aEventMessage,
+                 nsPresContext* aContext, bool aWindowRaised,
+                 bool aIsRefocus, EventTarget* aRelatedTarget)
+    : mTarget(aTarget)
     , mContext(aContext)
     , mEventMessage(aEventMessage)
     , mWindowRaised(aWindowRaised)
     , mIsRefocus(aIsRefocus)
     , mRelatedTarget(aRelatedTarget)
   {
   }
 
@@ -2054,24 +2050,22 @@ 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)
-    : mozilla::Runnable("FocusInOutEvent")
-    , mTarget(aTarget)
+  FocusInOutEvent(nsISupports* aTarget, EventMessage aEventMessage,
+                 nsPresContext* aContext,
+                 nsPIDOMWindowOuter* aOriginalFocusedWindow,
+                 nsIContent* aOriginalFocusedContent,
+                 EventTarget* aRelatedTarget)
+    : mTarget(aTarget)
     , mContext(aContext)
     , mEventMessage(aEventMessage)
     , mOriginalFocusedWindow(aOriginalFocusedWindow)
     , mOriginalFocusedContent(aOriginalFocusedContent)
     , mRelatedTarget(aRelatedTarget)
   {
   }
 
@@ -2265,18 +2259,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(
-      "nsFocusManager::RaiseWindow", [self, active, window]() -> void {
+    NS_DispatchToCurrentThread(
+      NS_NewRunnableFunction([self, active, window] () -> void {
         if (active) {
           self->WindowLowered(active);
         }
         self->WindowRaised(window);
       }));
     return;
   }
 
@@ -3624,17 +3618,16 @@ 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,21 +1980,17 @@ class nsFrameLoaderDestroyRunnable : pub
     eDestroyComplete
   };
 
   RefPtr<nsFrameLoader> mFrameLoader;
   DestroyPhase mPhase;
 
 public:
   explicit nsFrameLoaderDestroyRunnable(nsFrameLoader* aFrameLoader)
-    : mozilla::Runnable("nsFrameLoaderDestroyRunnable")
-    , mFrameLoader(aFrameLoader)
-    , mPhase(eDestroyDocShell)
-  {
-  }
+   : mFrameLoader(aFrameLoader), mPhase(eDestroyDocShell) {}
 
   NS_IMETHOD Run() override;
 };
 
 void
 nsFrameLoader::StartDestroy()
 {
   // nsFrameLoader::StartDestroy is called just before the frameloader is
@@ -2069,20 +2065,19 @@ 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(
-        "nsFrameLoader::StartDestroy", [groupedSHistory]() {
-          groupedSHistory->CloseInactiveFrameLoaderOwners();
-        }));
+      NS_DispatchToCurrentThread(NS_NewRunnableFunction([groupedSHistory] () {
+        groupedSHistory->CloseInactiveFrameLoaderOwners();
+      }));
     }
   }
 
   nsCOMPtr<nsIRunnable> destroyRunnable = new nsFrameLoaderDestroyRunnable(this);
   if (mNeedsAsyncDestroy || !doc ||
       NS_FAILED(doc->FinalizeFrameLoader(this, destroyRunnable))) {
     NS_DispatchToCurrentThread(destroyRunnable);
   }
@@ -3167,17 +3162,16 @@ 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,17 +1746,16 @@ 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(
-    "nsGlobalWindow::ClearStatus", this, &nsGlobalWindow::ClearStatus));
+  nsContentUtils::AddScriptRunner(
+    NewRunnableMethod(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,34 +3340,31 @@ 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("nsGlobalWindow::FireOnNewGlobalObject",
-                        newInnerWindow,
+      NewRunnableMethod(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("nsGlobalWindow::DispatchDOMWindowCreated",
-                          this,
-                          &nsGlobalWindow::DispatchDOMWindowCreated));
+        NewRunnableMethod(this, &nsGlobalWindow::DispatchDOMWindowCreated));
     }
   }
 
   PreloadLocalStorage();
 
   // If we have a recorded interesting Large-Allocation header status, report it
   // to the newly attached document.
   ReportLargeAllocStatus();
@@ -6868,23 +6865,20 @@ 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)
-    : mozilla::Runnable("FullscreenTransitionTask")
-    , mWindow(aWindow)
+    : mWindow(aWindow)
     , mWidget(aWidget)
     , mScreen(aScreen)
     , mTransitionData(aTransitionData)
     , mDuration(aDuration)
     , mStage(eBeforeToggle)
     , mFullscreen(aFullscreen)
   {
   }
@@ -9210,19 +9204,18 @@ nsGlobalWindow::PostMessageMoz(JSContext
                  aSubjectPrincipal, aRv);
 }
 
 class nsCloseEvent : public Runnable {
 
   RefPtr<nsGlobalWindow> mWindow;
   bool mIndirect;
 
-  nsCloseEvent(nsGlobalWindow* aWindow, bool aIndirect)
-    : mozilla::Runnable("nsCloseEvent")
-    , mWindow(aWindow)
+  nsCloseEvent(nsGlobalWindow *aWindow, bool aIndirect)
+    : mWindow(aWindow)
     , mIndirect(aIndirect)
   {}
 
 public:
 
   static nsresult
   PostCloseEvent(nsGlobalWindow* aWindow, bool aIndirect) {
     nsCOMPtr<nsIRunnable> ev = new nsCloseEvent(aWindow, aIndirect);
@@ -9641,21 +9634,21 @@ struct BrowserCompartmentMatcher : publi
     return nsContentUtils::IsSystemOrExpandedPrincipal(pc);
   }
 };
 
 
 class WindowDestroyedEvent final : public Runnable
 {
 public:
-  WindowDestroyedEvent(nsIDOMWindow* aWindow, uint64_t aID, const char* aTopic)
-    : mozilla::Runnable("WindowDestroyedEvent")
-    , mID(aID)
-    , mPhase(Phase::Destroying)
-    , mTopic(aTopic)
+  WindowDestroyedEvent(nsIDOMWindow* aWindow, uint64_t aID,
+                       const char* aTopic) :
+    mID(aID),
+    mPhase(Phase::Destroying),
+    mTopic(aTopic)
   {
     mWindow = do_GetWeakReference(aWindow);
   }
 
   enum class Phase
   {
     Destroying,
     Nuking
@@ -10135,22 +10128,17 @@ nsGlobalWindow::ShowModalDialog(JSContex
 }
 
 class ChildCommandDispatcher : public Runnable
 {
 public:
   ChildCommandDispatcher(nsGlobalWindow* aWindow,
                          nsITabChild* aTabChild,
                          const nsAString& aAction)
-    : mozilla::Runnable("ChildCommandDispatcher")
-    , mWindow(aWindow)
-    , mTabChild(aTabChild)
-    , mAction(aAction)
-  {
-  }
+  : mWindow(aWindow), mTabChild(aTabChild), mAction(aAction) {}
 
   NS_IMETHOD Run() override
   {
     nsCOMPtr<nsPIWindowRoot> root = mWindow->GetTopWindowRoot();
     if (!root) {
       return NS_OK;
     }
 
@@ -10169,21 +10157,17 @@ private:
   nsString                             mAction;
 };
 
 class CommandDispatcher : public Runnable
 {
 public:
   CommandDispatcher(nsIDOMXULCommandDispatcher* aDispatcher,
                     const nsAString& aAction)
-    : mozilla::Runnable("CommandDispatcher")
-    , mDispatcher(aDispatcher)
-    , mAction(aAction)
-  {
-  }
+  : mDispatcher(aDispatcher), mAction(aAction) {}
 
   NS_IMETHOD Run() override
   {
     return mDispatcher->UpdateCommands(mAction);
   }
 
   nsCOMPtr<nsIDOMXULCommandDispatcher> mDispatcher;
   nsString                             mAction;
@@ -10965,21 +10949,20 @@ 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)
-    : mozilla::Runnable("HashchangeCallback")
-    , mWindow(aWindow)
+    : mWindow(aWindow)
   {
     MOZ_ASSERT(mWindow);
     MOZ_ASSERT(mWindow->IsInnerWindow());
     mOldURL.Assign(aOldURL);
     mNewURL.Assign(aNewURL);
   }
 
   NS_IMETHOD Run() override
@@ -11582,21 +11565,18 @@ nsGlobalWindow::FireOfflineStatusEventIf
 
 class NotifyIdleObserverRunnable : public Runnable
 {
 public:
   NotifyIdleObserverRunnable(nsIIdleObserver* aIdleObserver,
                              uint32_t aTimeInS,
                              bool aCallOnidle,
                              nsGlobalWindow* aIdleWindow)
-    : mozilla::Runnable("NotifyIdleObserverRunnable")
-    , mIdleObserver(aIdleObserver)
-    , mTimeInS(aTimeInS)
-    , mIdleWindow(aIdleWindow)
-    , mCallOnidle(aCallOnidle)
+    : 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;
@@ -11694,22 +11674,20 @@ 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->InitWithNamedFuncCallback(
-    IdleObserverTimerCallback,
-    this,
-    callbackTimeMS,
-    nsITimer::TYPE_ONE_SHOT,
-    "nsGlobalWindow::ScheduleNextIdleObserverCallback");
+  rv = mIdleTimer->InitWithFuncCallback(IdleObserverTimerCallback,
+                                        this,
+                                        callbackTimeMS,
+                                        nsITimer::TYPE_ONE_SHOT);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
 uint32_t
 nsGlobalWindow::GetFuzzTimeMS()
 {
@@ -11741,22 +11719,20 @@ nsGlobalWindow::ScheduleActiveTimerCallb
   if (!mAddActiveEventFuzzTime) {
     return HandleIdleActiveEvent();
   }
 
   MOZ_ASSERT(mIdleTimer);
   mIdleTimer->Cancel();
 
   uint32_t fuzzFactorInMS = GetFuzzTimeMS();
-  nsresult rv = mIdleTimer->InitWithNamedFuncCallback(
-    IdleActiveTimerCallback,
-    this,
-    fuzzFactorInMS,
-    nsITimer::TYPE_ONE_SHOT,
-    "nsGlobalWindow::ScheduleActiveTimerCallback");
+  nsresult rv = mIdleTimer->InitWithFuncCallback(IdleActiveTimerCallback,
+                                                 this,
+                                                 fuzzFactorInMS,
+                                                 nsITimer::TYPE_ONE_SHOT);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 
 nsresult
 nsGlobalWindow::HandleIdleActiveEvent()
 {
   MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!");
@@ -12835,18 +12811,17 @@ public:
     : mWin(aWin)
   {
     MOZ_ASSERT(mWin);
     MOZ_ASSERT(mWin->IsOuterWindow());
   }
   ~AutoUnblockScriptClosing()
   {
     void (nsGlobalWindow::*run)() = &nsGlobalWindow::UnblockScriptedClosing;
-    nsCOMPtr<nsIRunnable> caller = NewRunnableMethod(
-      "AutoUnblockScriptClosing::~AutoUnblockScriptClosing", mWin, run);
+    nsCOMPtr<nsIRunnable> caller = NewRunnableMethod(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,17 +38,16 @@ 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,25 +304,19 @@ 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)
-    : mozilla::Runnable("nsAsyncScriptLoad")
-    , mTabChild(aTabChild)
-    , mURL(aURL)
-    , mRunInGlobalScope(aRunInGlobalScope)
-  {
-  }
+    nsAsyncScriptLoad(nsInProcessTabChildGlobal* aTabChild, const nsAString& aURL,
+                      bool aRunInGlobalScope)
+      : 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,18 +431,17 @@ NS_HandleScriptError(nsIScriptGlobalObje
 
 class ScriptErrorEvent : public Runnable
 {
 public:
   ScriptErrorEvent(nsPIDOMWindowInner* aWindow,
                    JS::RootingContext* aRootingCx,
                    xpc::ErrorReport* aReport,
                    JS::Handle<JS::Value> aError)
-    : mozilla::Runnable("ScriptErrorEvent")
-    , mWindow(aWindow)
+    : mWindow(aWindow)
     , mReport(aReport)
     , mError(aRootingCx, aError)
   {}
 
   NS_IMETHOD Run() override
   {
     nsEventStatus status = nsEventStatus_eIgnore;
     nsPIDOMWindowInner* win = mWindow;
@@ -2215,21 +2214,17 @@ nsJSContext::KillICCRunner()
   }
 }
 
 class NotifyGCEndRunnable : public Runnable
 {
   nsString mMessage;
 
 public:
-  explicit NotifyGCEndRunnable(const nsString& aMessage)
-    : mozilla::Runnable("NotifyGCEndRunnable")
-    , mMessage(aMessage)
-  {
-  }
+  explicit NotifyGCEndRunnable(const nsString& aMessage) : mMessage(aMessage) {}
 
   NS_DECL_NSIRUNNABLE
 };
 
 NS_IMETHODIMP
 NotifyGCEndRunnable::Run()
 {
   MOZ_ASSERT(NS_IsMainThread());
@@ -2545,18 +2540,17 @@ class AsyncTaskRunnable final : public R
 {
   ~AsyncTaskRunnable()
   {
     MOZ_ASSERT(!mTask);
   }
 
 public:
   explicit AsyncTaskRunnable(JS::AsyncTask* aTask)
-    : mozilla::Runnable("AsyncTaskRunnable")
-    , mTask(aTask)
+    : 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,18 +174,17 @@ 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)
-    : Runnable("dom::AsyncErrorReporter")
-    , mReport(aReport)
+    : mReport(aReport)
   {}
 
   NS_IMETHOD Run() override
   {
     mReport->LogToConsole();
     return NS_OK;
   }
 
--- a/dom/base/nsObjectLoadingContent.cpp
+++ b/dom/base/nsObjectLoadingContent.cpp
@@ -274,29 +274,27 @@ public:
     , mTarget(aTarget)
     , mDocument(aTarget->GetComposedDoc())
     , mEvent(aEvent)
   {
     MOZ_ASSERT(aTarget && mDocument);
   }
 
   nsSimplePluginEvent(nsIDocument* aTarget, const nsAString& aEvent)
-    : mozilla::Runnable("nsSimplePluginEvent")
-    , mTarget(aTarget)
+    : mTarget(aTarget)
     , mDocument(aTarget)
     , mEvent(aEvent)
   {
     MOZ_ASSERT(aTarget);
   }
 
   nsSimplePluginEvent(nsIContent* aTarget,
                       nsIDocument* aDocument,
                       const nsAString& aEvent)
-    : mozilla::Runnable("nsSimplePluginEvent")
-    , mTarget(aTarget)
+    : mTarget(aTarget)
     , mDocument(aDocument)
     , mEvent(aEvent)
   {
     MOZ_ASSERT(aTarget && aDocument);
   }
 
   ~nsSimplePluginEvent() override = default;
 
--- a/dom/base/nsReferencedElement.h
+++ b/dom/base/nsReferencedElement.h
@@ -124,22 +124,18 @@ private:
     nsReferencedElement* mTarget;
   };
 
   class ChangeNotification : public mozilla::Runnable,
                              public Notification
   {
   public:
     ChangeNotification(nsReferencedElement* aTarget,
-                       Element* aFrom,
-                       Element* aTo)
-      : mozilla::Runnable("nsReferencedElement::ChangeNotification")
-      , Notification(aTarget)
-      , mFrom(aFrom)
-      , mTo(aTo)
+                       Element* aFrom, Element* aTo)
+      : 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,18 +268,17 @@ 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("nsAttributeTextNode::AttributeChanged", this, update));
+    nsContentUtils::AddScriptRunner(NewRunnableMethod(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,39 +731,34 @@ 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(
-    "dom::cache::Context::ThreadsafeHandle::AllowToCloseOnOwningThread",
-    this,
-    &ThreadsafeHandle::AllowToCloseOnOwningThread);
+  nsCOMPtr<nsIRunnable> runnable =
+    NewRunnableMethod(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(
-    "dom::cache::Context::ThreadsafeHandle::"
-    "InvalidateAndAllowToCloseOnOwningThread",
-    this,
-    &ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread);
+  nsCOMPtr<nsIRunnable> runnable =
+    NewRunnableMethod(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,20 +907,17 @@ 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>(
-      "dom::cache::Manager::CachePutAllAction::OnAsyncCopyComplete",
-      this,
-      &CachePutAllAction::OnAsyncCopyComplete,
-      aRv);
+      this, &CachePutAllAction::OnAsyncCopyComplete, aRv);
     MOZ_ALWAYS_SUCCEEDS(
       mTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
   }
 
   void
   DoResolve(nsresult aRv)
   {
     MOZ_ASSERT(mTarget->IsOnCurrentThread());
@@ -1764,18 +1761,17 @@ 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("nsIThread::Shutdown",
-                                                                ioThread, &nsIThread::Shutdown)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(NewRunnableMethod(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,18 +60,17 @@ PrincipalVerifier::RemoveListener(Listen
   AssertIsOnBackgroundThread();
   MOZ_DIAGNOSTIC_ASSERT(aListener);
   MOZ_ALWAYS_TRUE(mListenerList.RemoveElement(aListener));
 }
 
 PrincipalVerifier::PrincipalVerifier(Listener* aListener,
                                      PBackgroundParent* aActor,
                                      const PrincipalInfo& aPrincipalInfo)
-  : Runnable("dom::cache::PrincipalVerifier")
-  , mActor(BackgroundParent::GetContentParent(aActor))
+  : 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,18 +127,17 @@ 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)
-    : CancelableRunnable("dom::cache::ReadStream::Inner::NoteClosedRunnable")
-    , mStream(aStream)
+    : mStream(aStream)
   { }
 
   NS_IMETHOD Run() override
   {
     mStream->NoteClosedOnOwningThread();
     mStream = nullptr;
     return NS_OK;
   }
@@ -163,18 +162,17 @@ 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)
-    : CancelableRunnable("dom::cache::ReadStream::Inner::ForgetRunnable")
-    , mStream(aStream)
+    : mStream(aStream)
   { }
 
   NS_IMETHOD Run() override
   {
     mStream->ForgetOnOwningThread();
     mStream = nullptr;
     return NS_OK;
   }
--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -1571,19 +1571,18 @@ void
 CanvasRenderingContext2D::ScheduleStableStateCallback()
 {
   if (mHasPendingStableStateCallback) {
     return;
   }
   mHasPendingStableStateCallback = true;
 
   nsContentUtils::RunInStableState(
-    NewRunnableMethod("dom::CanvasRenderingContext2D::OnStableState",
-                      this,
-                      &CanvasRenderingContext2D::OnStableState));
+    NewRunnableMethod(this, &CanvasRenderingContext2D::OnStableState)
+  );
 }
 
 void
 CanvasRenderingContext2D::OnStableState()
 {
   if (!mHasPendingStableStateCallback) {
     return;
   }
--- a/dom/canvas/ImageBitmap.cpp
+++ b/dom/canvas/ImageBitmap.cpp
@@ -1071,18 +1071,17 @@ private:
   RefPtr<ImageBitmap> mImageBitmap;
 };
 
 class FulfillImageBitmapPromiseTask final : public Runnable,
                                             public FulfillImageBitmapPromise
 {
 public:
   FulfillImageBitmapPromiseTask(Promise* aPromise, ImageBitmap* aImageBitmap)
-    : Runnable("dom::FulfillImageBitmapPromiseTask")
-    , FulfillImageBitmapPromise(aPromise, aImageBitmap)
+  : FulfillImageBitmapPromise(aPromise, aImageBitmap)
   {
   }
 
   NS_IMETHOD Run() override
   {
     DoFulfillImageBitmapPromise();
     return NS_OK;
   }
@@ -1274,18 +1273,17 @@ protected:
 class CreateImageBitmapFromBlobTask final : public Runnable,
                                             public CreateImageBitmapFromBlob
 {
 public:
   CreateImageBitmapFromBlobTask(Promise* aPromise,
                                 nsIGlobalObject* aGlobal,
                                 Blob& aBlob,
                                 const Maybe<IntRect>& aCropRect)
-    : Runnable("dom::CreateImageBitmapFromBlobTask")
-    , CreateImageBitmapFromBlob(aPromise, aGlobal, aBlob, aCropRect)
+  :CreateImageBitmapFromBlob(aPromise, aGlobal, aBlob, aCropRect)
   {
   }
 
   NS_IMETHOD Run() override
   {
     DoCreateImageBitmapFromBlob();
     return NS_OK;
   }
@@ -1729,28 +1727,22 @@ 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)
-    : Runnable("dom::MapDataIntoBufferSourceTask")
-    , MapDataIntoBufferSource<T>(aCx,
-                                 aPromise,
-                                 aImageBitmap,
-                                 aBuffer,
-                                 aOffset,
-                                 aFormat)
+  : 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,20 +1732,19 @@ WebGLContext::RunContextLossTimer()
     mContextLossHandler.RunTimer();
 }
 
 class UpdateContextLossStatusTask : public CancelableRunnable
 {
     RefPtr<WebGLContext> mWebGL;
 
 public:
-  explicit UpdateContextLossStatusTask(WebGLContext* webgl)
-    : CancelableRunnable("UpdateContextLossStatusTask")
-    , mWebGL(webgl)
-  {
+    explicit UpdateContextLossStatusTask(WebGLContext* webgl)
+        : mWebGL(webgl)
+    {
     }
 
     NS_IMETHOD Run() override {
         if (mWebGL)
             mWebGL->UpdateContextLossStatus();
 
         return NS_OK;
     }
--- a/dom/canvas/WebGLQuery.cpp
+++ b/dom/canvas/WebGLQuery.cpp
@@ -13,26 +13,23 @@
 
 namespace mozilla {
 
 class AvailableRunnable final : public Runnable
 {
     const RefPtr<WebGLQuery> mQuery;
 
 public:
-  explicit AvailableRunnable(WebGLQuery* query)
-    : Runnable("AvailableRunnable")
-    , mQuery(query)
-  {
-  }
+    explicit AvailableRunnable(WebGLQuery* query)
+        : 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,19 +17,18 @@ namespace mozilla {
 using namespace dom;
 
 /******************************************************************************
  * mozilla::AsyncEventDispatcher
  ******************************************************************************/
 
 AsyncEventDispatcher::AsyncEventDispatcher(EventTarget* aTarget,
                                            WidgetEvent& aEvent)
-  : CancelableRunnable("AsyncEventDispatcher")
-  , mTarget(aTarget)
-  , mEventMessage(eUnidentifiedEvent)
+  : 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,73 +29,66 @@ 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)
-    : CancelableRunnable("AsyncEventDispatcher")
-    , mTarget(aTarget)
+  AsyncEventDispatcher(nsINode* aTarget, const nsAString& aEventType,
+                       bool aBubbles, bool aOnlyChromeDispatch)
+    : 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)
-    : CancelableRunnable("AsyncEventDispatcher")
-    , mTarget(aTarget)
+    : mTarget(aTarget)
     , mEventMessage(aEventMessage)
     , mBubbles(aBubbles)
     , mOnlyChromeDispatch(aOnlyChromeDispatch)
   {
     mEventType.SetIsVoid(true);
     MOZ_ASSERT(mEventMessage != eUnidentifiedEvent);
   }
 
   AsyncEventDispatcher(dom::EventTarget* aTarget, const nsAString& aEventType,
                        bool aBubbles)
-    : CancelableRunnable("AsyncEventDispatcher")
-    , mTarget(aTarget)
+    : mTarget(aTarget)
     , mEventType(aEventType)
     , mEventMessage(eUnidentifiedEvent)
     , mBubbles(aBubbles)
   {
   }
 
   AsyncEventDispatcher(dom::EventTarget* aTarget,
                        mozilla::EventMessage aEventMessage,
                        bool aBubbles)
-    : CancelableRunnable("AsyncEventDispatcher")
-    , mTarget(aTarget)
+    : mTarget(aTarget)
     , mEventMessage(aEventMessage)
     , mBubbles(aBubbles)
   {
     mEventType.SetIsVoid(true);
     MOZ_ASSERT(mEventMessage != eUnidentifiedEvent);
   }
 
   AsyncEventDispatcher(dom::EventTarget* aTarget, nsIDOMEvent* aEvent)
-    : CancelableRunnable("AsyncEventDispatcher")
-    , mTarget(aTarget)
+    : 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,20 +441,19 @@ 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)
-      : mozilla::Runnable("GASRunnable")
-      , mCallback(aCallback)
-      , mStringData(aStringData)
+    GASRunnable(FunctionStringCallback* aCallback,
+                const nsAString& aStringData)
+      : 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,22 +1407,19 @@ 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->InitWithNamedFuncCallback(
-      sClickHoldCallback,
-      this,
-      clickHoldDelay,
-      nsITimer::TYPE_ONE_SHOT,
-      "EventStateManager::CreateClickHoldTimer");
+    mClickHoldTimer->InitWithFuncCallback(sClickHoldCallback, this,
+                                          clickHoldDelay,
+                                          nsITimer::TYPE_ONE_SHOT);
   }
 } // 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,23 +707,22 @@ TextComposition::HasEditor() const
   return !!editor;
 }
 
 /******************************************************************************
  * TextComposition::CompositionEventDispatcher
  ******************************************************************************/
 
 TextComposition::CompositionEventDispatcher::CompositionEventDispatcher(
-  TextComposition* aComposition,
-  nsINode* aEventTarget,
-  EventMessage aEventMessage,
-  const nsAString& aData,
-  bool aIsSynthesizedEvent)
-  : Runnable("TextComposition::CompositionEventDispatcher")
-  , mTextComposition(aComposition)
+                                               TextComposition* aComposition,
+                                               nsINode* aEventTarget,
+                                               EventMessage aEventMessage,
+                                               const nsAString& aData,
+                                               bool aIsSynthesizedEvent)
+  : mTextComposition(aComposition)
   , mEventTarget(aEventTarget)
   , mData(aData)
   , mEventMessage(aEventMessage)
   , mIsSynthesizedEvent(aIsSynthesizedEvent)
 {
 }
 
 NS_IMETHODIMP
--- a/dom/events/TextComposition.h
+++ b/dom/events/TextComposition.h
@@ -428,19 +428,17 @@ private:
 
   private:
     RefPtr<TextComposition> mTextComposition;
     nsCOMPtr<nsINode> mEventTarget;
     nsString mData;
     EventMessage mEventMessage;
     bool mIsSynthesizedEvent;
 
-    CompositionEventDispatcher()
-      : Runnable("TextComposition::CompositionEventDispatcher")
-      , mIsSynthesizedEvent(false){};
+    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,21 +327,18 @@ WheelTransaction::SetTimeout()
     nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID);
     if (!timer) {
       return;
     }
     timer.swap(sTimer);
   }
   sTimer->Cancel();
   DebugOnly<nsresult> rv =
-    sTimer->InitWithNamedFuncCallback(OnTimeout,
-                                      nullptr,
-                                      GetTimeoutTime(),
-                                      nsITimer::TYPE_ONE_SHOT,
-                                      "WheelTransaction::SetTimeout");
+    sTimer->InitWithFuncCallback(OnTimeout, nullptr, GetTimeoutTime(),
+                                 nsITimer::TYPE_ONE_SHOT);
   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,18 +70,17 @@ 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)
-      : Runnable("dom::FetchSignalProxy::FetchSignalProxyRunnable")
-      , mProxy(aProxy)
+      : mProxy(aProxy)
     {}
 
     NS_IMETHOD
     Run() override
     {
       MOZ_ASSERT(NS_IsMainThread());
       FetchSignal* signal = mProxy->GetOrCreateSignalForMainThread();
       signal->Abort();
@@ -260,18 +259,17 @@ private:
 class MainThreadFetchRunnable : public Runnable
 {
   RefPtr<WorkerFetchResolver> mResolver;
   RefPtr<InternalRequest> mRequest;
 
 public:
   MainThreadFetchRunnable(WorkerFetchResolver* aResolver,
                           InternalRequest* aRequest)
-    : Runnable("dom::MainThreadFetchRunnable")
-    , mResolver(aResolver)
+    : mResolver(aResolver)
     , mRequest(aRequest)
   {
     MOZ_ASSERT(mResolver);
   }
 
   NS_IMETHOD
   Run() override
   {
--- a/dom/fetch/FetchConsumer.cpp
+++ b/dom/fetch/FetchConsumer.cpp
@@ -53,18 +53,17 @@ public:
 
 template <class Derived>
 class BeginConsumeBodyRunnable final : public Runnable
 {
   RefPtr<FetchBodyConsumer<Derived>> mFetchBodyConsumer;
 
 public:
   explicit BeginConsumeBodyRunnable(FetchBodyConsumer<Derived>* aConsumer)
-    : Runnable("BeginConsumeBodyRunnable")
-    , mFetchBodyConsumer(aConsumer)
+    : mFetchBodyConsumer(aConsumer)
   { }
 
   NS_IMETHOD
   Run() override
   {
     mFetchBodyConsumer->BeginConsumeBodyMainThread();
     return NS_OK;
   }
--- a/dom/fetch/FetchDriver.cpp
+++ b/dom/fetch/FetchDriver.cpp
@@ -638,18 +638,17 @@ namespace {
 
 // Runnable to call the observer OnDataAvailable on the main-thread.
 class DataAvailableRunnable final : public Runnable
 {
   RefPtr<FetchDriverObserver> mObserver;
 
 public:
   explicit DataAvailableRunnable(FetchDriverObserver* aObserver)
-    : Runnable("dom::DataAvailableRunnable")
-    , mObserver(aObserver)
+    : mObserver(aObserver)
   {
      MOZ_ASSERT(aObserver);
   }
 
   NS_IMETHOD
   Run() override
   {
     mObserver->OnDataAvailable();
--- a/dom/file/MutableBlobStorage.cpp
+++ b/dom/file/MutableBlobStorage.cpp
@@ -26,18 +26,17 @@ namespace {
 // error must be propagated.
 class BlobCreationDoneRunnable final : public Runnable
 {
 public:
   BlobCreationDoneRunnable(MutableBlobStorage* aBlobStorage,
                            MutableBlobStorageCallback* aCallback,
                            Blob* aBlob,
                            nsresult aRv)
-    : Runnable("dom::BlobCreationDoneRunnable")
-    , mBlobStorage(aBlobStorage)
+    : mBlobStorage(aBlobStorage)
     , mCallback(aCallback)
     , mBlob(aBlob)
     , mRv(aRv)
   {
     MOZ_ASSERT(aBlobStorage);
     MOZ_ASSERT(aCallback);
     MOZ_ASSERT((NS_FAILED(aRv) && !aBlob) ||
                (NS_SUCCEEDED(aRv) && aBlob));
@@ -75,18 +74,17 @@ 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)
-    : Runnable("dom::FileCreatedRunnable")
-    , mBlobStorage(aBlobStorage)
+    : mBlobStorage(aBlobStorage)
     , mFD(aFD)
   {
     MOZ_ASSERT(aBlobStorage);
     MOZ_ASSERT(aFD);
   }
 
   NS_IMETHOD
   Run() override
@@ -111,18 +109,17 @@ 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)
-    : Runnable("dom::CreateTemporaryFileRunnable")
-    , mBlobStorage(aBlobStorage)
+    : mBlobStorage(aBlobStorage)
   {
     MOZ_ASSERT(NS_IsMainThread());
     MOZ_ASSERT(XRE_IsParentProcess());
     MOZ_ASSERT(aBlobStorage);
   }
 
   NS_IMETHOD
   Run() override
@@ -146,18 +143,17 @@ private:
   RefPtr<MutableBlobStorage> mBlobStorage;
 };
 
 // Simple runnable to propagate the error to the BlobStorage.
 class ErrorPropagationRunnable final : public Runnable
 {
 public:
   ErrorPropagationRunnable(MutableBlobStorage* aBlobStorage, nsresult aRv)
-    : Runnable("dom::ErrorPropagationRunnable")
-    , mBlobStorage(aBlobStorage)
+    : mBlobStorage(aBlobStorage)
     , mRv(aRv)
   {}
 
   NS_IMETHOD
   Run() override
   {
     mBlobStorage->ErrorPropagated(mRv);
     return NS_OK;
@@ -216,22 +212,19 @@ public:
         new ErrorPropagationRunnable(mBlobStorage, NS_ERROR_FAILURE),
         NS_DISPATCH_NORMAL);
     }
 
     return NS_OK;
   }
 
 private:
-  WriteRunnable(MutableBlobStorage* aBlobStorage,
-                PRFileDesc* aFD,
-                void* aData,
-                uint32_t aLength)
-    : Runnable("dom::WriteRunnable")
-    , mBlobStorage(aBlobStorage)
+  WriteRunnable(MutableBlobStorage* aBlobStorage, PRFileDesc* aFD,
+                void* aData, uint32_t aLength)
+    : mBlobStorage(aBlobStorage)
     , mFD(aFD)
     , mData(aData)
     , mLength(aLength)
   {
     MOZ_ASSERT(NS_IsMainThread());
     MOZ_ASSERT(mBlobStorage);
     MOZ_ASSERT(aFD);
     MOZ_ASSERT(aData);
@@ -249,18 +242,17 @@ 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)
-    : Runnable("dom::CloseFileRunnable")
-    , mFD(aFD)
+    : mFD(aFD)
   {}
 
   NS_IMETHOD
   Run() override
   {
     MOZ_ASSERT(!NS_IsMainThread());
     PR_Close(mFD);
     mFD = nullptr;
@@ -282,18 +274,17 @@ 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)
-    : Runnable("dom::CreateBlobRunnable")
-    , mBlobStorage(aBlobStorage)
+    : mBlobStorage(aBlobStorage)
     , mParent(aParent)
     , mContentType(aContentType)
     , mCallback(aCallback)
   {
     MOZ_ASSERT(!NS_IsMainThread());
     MOZ_ASSERT(aBlobStorage);
   }
 
@@ -331,18 +322,17 @@ 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)
-    : Runnable("dom::LastRunnable")
-    , mBlobStorage(aBlobStorage)
+    : 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,18 +41,17 @@ public:
     mCallback = nullptr;
     mStream = nullptr;
     return NS_OK;
   }
 
 private:
   CallbackRunnable(nsIInputStreamCallback* aCallback,
                    IPCBlobInputStream* aStream)
-    : CancelableRunnable("dom::CallbackRunnable")
-    , mCallback(aCallback)
+    : 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,18 +20,17 @@ 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)
-    : CancelableRunnable("dom::ShutdownRunnable")
-    , mActor(aActor)
+    : mActor(aActor)
   {}
 
   NS_IMETHOD
   Run() override
   {
     mActor->Shutdown();
     return NS_OK;
   }
@@ -41,18 +40,17 @@ 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)
-    : CancelableRunnable("dom::StreamNeededRunnable")
-    , mActor(aActor)
+    : mActor(aActor)
   {}
 
   NS_IMETHOD
   Run() override
   {
     MOZ_ASSERT(mActor->State() != IPCBlobInputStreamChild::eActiveMigrating &&
                mActor->State() != IPCBlobInputStreamChild::eInactiveMigrating);
     if (mActor->State() == IPCBlobInputStreamChild::eActive) {
@@ -67,18 +65,17 @@ 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)
-    : CancelableRunnable("dom::StreamReadyRunnable")
-    , mDestinationStream(aDestinationStream)
+    : mDestinationStream(aDestinationStream)
     , mCreatedStream(aCreatedStream)
   {
     MOZ_ASSERT(mDestinationStream);
     // mCreatedStream can be null.
   }
 
   NS_IMETHOD
   Run() override
@@ -100,20 +97,18 @@ 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)
-    : CancelableRunnable("dom::ReleaseWorkerHolderRunnable")
-    , mWorkerHolder(Move(aWorkerHolder))
+  explicit ReleaseWorkerHolderRunnable(UniquePtr<workers::WorkerHolder>&& aWorkerHolder)
+    : 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,18 +22,16 @@ 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;
   }
@@ -41,18 +39,17 @@ public:
 
 class MigrateActorRunnable final : public Runnable
                                  , public nsIIPCBackgroundChildCreateCallback
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
 
   explicit MigrateActorRunnable(IPCBlobInputStreamChild* aActor)
-    : Runnable("dom::MigrateActorRunnable")
-    , mActor(aActor)
+    : mActor(aActor)
   {
     MOZ_ASSERT(mActor);
   }
 
   NS_IMETHOD
   Run() override
   {
     BackgroundChild::GetOrCreateForCurrentThread(this);
--- a/dom/filehandle/ActorsParent.cpp
+++ b/dom/filehandle/ActorsParent.cpp
@@ -583,18 +583,17 @@ class CopyFileHandleOp::ProgressRunnable
   RefPtr<CopyFileHandleOp> mCopyFileHandleOp;
   uint64_t mProgress;
   uint64_t mProgressMax;
 
 public:
   ProgressRunnable(CopyFileHandleOp* aCopyFileHandleOp,
                    uint64_t aProgress,
                    uint64_t aProgressMax)
-    : Runnable("dom::CopyFileHandleOp::ProgressRunnable")
-    , mCopyFileHandleOp(aCopyFileHandleOp)
+    : mCopyFileHandleOp(aCopyFileHandleOp)
     , mProgress(aProgress)
     , mProgressMax(aProgressMax)
   { }
 
 private:
   ~ProgressRunnable() {}
 
   NS_DECL_NSIRUNNABLE
@@ -1077,21 +1076,20 @@ FileHandleThreadPool::MaybeFireCallback(
       return false;
     }
   }
 
   aCallback->mCallback->Run();
   return true;
 }
 
-FileHandleThreadPool::FileHandleQueue::FileHandleQueue(
-  FileHandleThreadPool* aFileHandleThreadPool,
-  FileHandle* aFileHandle)
-  : Runnable("dom::FileHandleThreadPool::FileHandleQueue")
-  , mOwningFileHandleThreadPool(aFileHandleThreadPool)
+FileHandleThreadPool::
+FileHandleQueue::FileHandleQueue(FileHandleThreadPool* aFileHandleThreadPool,
+                                 FileHandle* aFileHandle)
+  : 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,18 +77,17 @@ namespace {
 
 class CheckPermissionRunnable final : public Runnable
 {
 public:
   CheckPermissionRunnable(already_AddRefed<ContentParent> aParent,
                           FileSystemRequestParent* aActor,
                           FileSystemTaskParentBase* aTask,
                           const nsAString& aPath)
-    : Runnable("dom::CheckPermissionRunnable")
-    , mContentParent(aParent)
+    : mContentParent(aParent)
     , mActor(aActor)
     , mTask(aTask)
     , mPath(aPath)
     , mBackgroundEventTarget(GetCurrentThreadEventTarget())
   {
     AssertIsInMainProcess();
     AssertIsOnBackgroundThread();
 
--- a/dom/filesystem/FileSystemTaskBase.cpp
+++ b/dom/filesystem/FileSystemTaskBase.cpp
@@ -226,22 +226,20 @@ FileSystemTaskChildBase::SetError(const 
 {
   mErrorValue = FileSystemErrorFromNsError(aErrorValue);
 }
 
 /**
  * FileSystemTaskParentBase class
  */
 
-FileSystemTaskParentBase::FileSystemTaskParentBase(
-  FileSystemBase* aFileSystem,
-  const FileSystemParams& aParam,
-  FileSystemRequestParent* aParent)
-  : Runnable("dom::FileSystemTaskParentBase")
-  , mErrorValue(NS_OK)
+FileSystemTaskParentBase::FileSystemTaskParentBase(FileSystemBase* aFileSystem,
+                                                   const FileSystemParams& aParam,
+                                                   FileSystemRequestParent* aParent)
+  : 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,17 +56,16 @@ 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,19 +84,20 @@ HttpServer::HandleCert(nsIX509Cert* aCer
 
   return NS_OK;
 }
 
 void
 HttpServer::NotifyStarted(nsresult aStatus)
 {
   RefPtr<HttpServerListener> listener = mListener;
-  nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction(
-    "dom::HttpServer::NotifyStarted",
-    [listener, aStatus]() { listener->OnServerStarted(aStatus); });
+  nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction([listener, aStatus] ()
+  {
+    listener->OnServerStarted(aStatus);
+  });
   NS_DispatchToCurrentThread(event);
 }
 
 nsresult
 HttpServer::StartServerSocket(nsIX509Cert* aCert)
 {
   nsresult rv;
   mServerSocket =
@@ -282,22 +283,22 @@ HttpServer::TransportProvider::SetTransp
   MaybeNotify();
 }
 
 void
 HttpServer::TransportProvider::MaybeNotify()
 {
   if (mTransport && mListener) {
     RefPtr<TransportProvider> self = this;
-    nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction(
-      "dom::HttpServer::TransportProvider::MaybeNotify", [self, this]() {
-        DebugOnly<nsresult> rv =
-          mListener->OnTransportAvailable(mTransport, mInput, mOutput);
-        MOZ_ASSERT(NS_SUCCEEDED(rv));
-      });
+    nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction([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)
 
@@ -627,19 +628,21 @@ 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(
-        "dom::HttpServer::Connection::ConsumeLine",
-        [listener, request]() { listener->OnWebSocket(request); });
+      nsCOMPtr<nsIRunnable> event =
+        NS_NewRunnableFunction([listener, request] ()
+      {
+        listener->OnWebSocket(request);
+      });
       NS_DispatchToCurrentThread(event);
 
       return NS_OK;
     }
 
     nsAutoCString header;
     mPendingReq->Headers()->GetFirst(NS_LITERAL_CSTRING("connection"),
                                      header,
@@ -694,19 +697,21 @@ 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(
-      "dom::HttpServer::Connection::ConsumeLine",
-      [listener, request]() { listener->OnRequest(request); });
+    nsCOMPtr<nsIRunnable> event =
+      NS_NewRunnableFunction([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)
-    : Runnable("DarwinGamepadServiceStartupRunnable"), mService(service) {}
+             : 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,28 +7,25 @@
 namespace mozilla {
 namespace dom{
 
 namespace {
 
 class GamepadUpdateRunnable final : public Runnable
 {
  public:
-   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;
+  explicit GamepadUpdateRunnable(const GamepadChangeEvent& aGamepadEvent)
+             : 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,23 +15,22 @@ namespace {
 
 class SendGamepadUpdateRunnable final : public Runnable
 {
  private:
   ~SendGamepadUpdateRunnable() {}
   RefPtr<GamepadEventChannelParent> mParent;
   GamepadChangeEvent mEvent;
  public:
-   SendGamepadUpdateRunnable(GamepadEventChannelParent* aParent,
-                             GamepadChangeEvent aEvent)
-     : Runnable("dom::SendGamepadUpdateRunnable")
-     , mEvent(aEvent)
-   {
-     MOZ_ASSERT(aParent);
-     mParent = aParent;
+  SendGamepadUpdateRunnable(GamepadEventChannelParent* aParent,
+                            GamepadChangeEvent aEvent)
+    : 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,19 +997,17 @@ GamepadWindowProc(HWND hwnd, UINT msg, W
     break;
   }
   return DefWindowProc(hwnd, msg, wParam, lParam);
 }
 
 class StartWindowsGamepadServiceRunnable final : public Runnable
 {
 public:
-  StartWindowsGamepadServiceRunnable()
-    : Runnable("StartWindowsGamepadServiceRunnable")
-  {}
+  StartWindowsGamepadServiceRunnable() {}
 
   NS_IMETHOD Run() override
   {
     MOZ_ASSERT(NS_GetCurrentThread() == gMonitorThread);
     gService = new WindowsGamepadService();
     gService->Startup();
 
     if (sHWnd == nullptr) {
@@ -1037,19 +1035,17 @@ public:
   }
 private:
   ~StartWindowsGamepadServiceRunnable() {}
 };
 
 class StopWindowsGamepadServiceRunnable final : public Runnable
 {
  public:
-  StopWindowsGamepadServiceRunnable()
-    : Runnable("StopWindowsGamepadServiceRunnable")
-  {}
+  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,18 +142,17 @@ CreatePositionOptionsCopy(const Position
 
   return geoOptions;
 }
 
 class RequestPromptEvent : public Runnable
 {
 public:
   RequestPromptEvent(nsGeolocationRequest* aRequest, nsWeakPtr aWindow)
-    : mozilla::Runnable("RequestPromptEvent")
-    , mRequest(aRequest)
+    : mRequest(aRequest)
     , mWindow(aWindow)
   {
   }
 
   NS_IMETHOD Run() override
   {
     nsCOMPtr<nsPIDOMWindowInner> window = do_QueryReferent(mWindow);
     nsContentPermissionUtils::AskPermission(mRequest, window);
@@ -164,19 +163,18 @@ private:
   RefPtr<nsGeolocationRequest> mRequest;
   nsWeakPtr mWindow;
 };
 
 class RequestAllowEvent : public Runnable
 {
 public:
   RequestAllowEvent(int allow, nsGeolocationRequest* request)
-    : mozilla::Runnable("RequestAllowEvent")
-    , mAllow(allow)
-    , mRequest(request)
+    : mAllow(allow),
+      mRequest(request)
   {
   }
 
   NS_IMETHOD Run() override {
     if (mAllow) {
       mRequest->Allow(JS::UndefinedHandleValue);
     } else {
       mRequest->Cancel();
@@ -189,19 +187,18 @@ private:
   RefPtr<nsGeolocationRequest> mRequest;
 };
 
 class RequestSendLocationEvent : public Runnable
 {
 public:
   RequestSendLocationEvent(nsIDOMGeoPosition* aPosition,
                            nsGeolocationRequest* aRequest)
-    : mozilla::Runnable("RequestSendLocationEvent")
-    , mPosition(aPosition)
-    , mRequest(aRequest)
+    : 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,20 +236,18 @@ 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("dom::HTMLCanvasPrintState::NotifyDone",
-                        this,
-                        &HTMLCanvasPrintState::NotifyDone);
+    RefPtr<nsRunnableMethod<HTMLCanvasPrintState> > doneEvent =
+      NewRunnableMethod(this, &HTMLCanvasPrintState::NotifyDone);
     if (NS_SUCCEEDED(NS_DispatchToCurrentThread(doneEvent))) {
       mPendingNotify = true;
     }
   }
 }
 
 void
 HTMLCanvasPrintState::NotifyDone()
@@ -518,20 +516,18 @@ 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("dom::HTMLCanvasElement::CallPrintCallback",
-                      this,
-                      &HTMLCanvasElement::CallPrintCallback);
+  RefPtr<nsRunnableMethod<HTMLCanvasElement> > renderEvent =
+    NewRunnableMethod(this, &HTMLCanvasElement::CallPrintCallback);
   return OwnerDoc()->Dispatch("HTMLCanvasElement::CallPrintCallback",
                               TaskCategory::Other,
                               renderEvent.forget());
 }
 
 void
 HTMLCanvasElement::CallPrintCallback()
 {
@@ -843,26 +839,23 @@ 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*>(
-        "dom::HTMLCanvasElement::ToBlob",
-        &aCallback,
-        static_cast<void (BlobCallback::*)(Blob*, const char*)>(
-          &BlobCallback::Call),
-        nullptr,
-        nullptr));
+    OwnerDoc()->Dispatch("FireNullBlobEvent",
+                  TaskCategory::Other,
+                  NewRunnableMethod<Blob*, const char*>(
+                          &aCallback,
+                          static_cast<void(BlobCallback::*)(
+                            Blob*, const char*)>(&BlobCallback::Call),
+                          nullptr, nullptr));
     return;
   }
 
   CanvasRenderingContextHelper::ToBlob(aCx, global, aCallback, aType,
                                        aParams, aRv);
 
 }
 
@@ -1355,18 +1348,17 @@ HTMLCanvasElement::OnVisibilityChange()
     return;
   }
 
   if (mOffscreenCanvas) {
     class Runnable final : public CancelableRunnable
     {
     public:
       explicit Runnable(AsyncCanvasRenderer* aRenderer)
-        : mozilla::CancelableRunnable("Runnable")
-        , mRenderer(aRenderer)
+        : mRenderer(aRenderer)
       {}
 
       NS_IMETHOD Run() override
       {
         if (mRenderer && mRenderer->mContext) {
           mRenderer->mContext->OnVisibilityChange();
         }
 
@@ -1398,18 +1390,17 @@ HTMLCanvasElement::OnVisibilityChange()
 void
 HTMLCanvasElement::OnMemoryPressure()
 {
   if (mOffscreenCanvas) {
     class Runnable final : public CancelableRunnable
     {
     public:
       explicit Runnable(AsyncCanvasRenderer* aRenderer)
-        : mozilla::CancelableRunnable("Runnable")
-        , mRenderer(aRenderer)
+        : mRenderer(aRenderer)
       {}
 
       NS_IMETHOD Run() override
       {
         if (mRenderer && mRenderer->mContext) {
           mRenderer->mContext->OnMemoryPressure();
         }
 
--- a/dom/html/HTMLFormElement.h
+++ b/dom/html/HTMLFormElement.h
@@ -421,18 +421,17 @@ protected:
   RefPtr<AsyncEventDispatcher> mFormPasswordEventDispatcher;
 
   class RemoveElementRunnable;
   friend class RemoveElementRunnable;
 
   class RemoveElementRunnable : public Runnable {
   public:
     explicit RemoveElementRunnable(HTMLFormElement* aForm)
-      : Runnable("dom::HTMLFormElement::RemoveElementRunnable")
-      , mForm(aForm)
+      : mForm(aForm)
     {}
 
     NS_IMETHOD Run() override {
       mForm->HandleDefaultSubmitRemoval();
       return NS_OK;
     }
 
   private:
--- a/dom/html/HTMLImageElement.cpp
+++ b/dom/html/HTMLImageElement.cpp
@@ -74,21 +74,19 @@ 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)
-    : Runnable("dom::ImageLoadTask")
-    , mElement(aElement)
+    : mElement(aElement)
     , mAlwaysLoad(aAlwaysLoad)
     , mUseUrgentStartForChannel(aUseUrgentStartForChannel)
   {
     mDocument = aElement->OwnerDoc();
     mDocument->BlockOnload();
   }
 
   NS_IMETHOD Run() override
@@ -673,20 +671,17 @@ 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>("dom::HTMLImageElement::MaybeLoadImage",
-                                this,
-                                &HTMLImageElement::MaybeLoadImage,
-                                false));
+        NewRunnableMethod<bool>(this, &HTMLImageElement::MaybeLoadImage, false));
     }
   }
 
   return rv;
 }
 
 void
 HTMLImageElement::UnbindFromTree(bool aDeep, bool aNullParent)
@@ -769,24 +764,19 @@ 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>("dom::HTMLImageElement::QueueImageLoadTask",
-                                  this,
-                                  &HTMLImageElement::QueueImageLoadTask,
-                                  true)
-        : NewRunnableMethod<bool>("dom::HTMLImageElement::MaybeLoadImage",
-                                  this,
-                                  &HTMLImageElement::MaybeLoadImage,
-                                  true));
+        ? NewRunnableMethod<bool>(this, &HTMLImageElement::QueueImageLoadTask, true)
+        : NewRunnableMethod<bool>(this, &HTMLImageElement::MaybeLoadImage, true)
+    );
   }
 }
 
 // static
 already_AddRefed<HTMLImageElement>
 HTMLImageElement::Image(const GlobalObject& aGlobal,
                         const Optional<uint32_t>& aWidth,
                         const Optional<uint32_t>& aHeight,
@@ -899,20 +889,17 @@ 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>("dom::HTMLImageElement::MaybeLoadImage",
-                                dest,
-                                &HTMLImageElement::MaybeLoadImage,
-                                false));
+        NewRunnableMethod<bool>(dest, &HTMLImageElement::MaybeLoadImage, false));
     }
   }
 
   return NS_OK;
 }
 
 CORSMode
 HTMLImageElement::GetCORSMode()
--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -4865,19 +4865,17 @@ 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("dom::HTMLInputElement::MaybeLoadImage",
-                          this,
-                          &HTMLInputElement::MaybeLoadImage));
+        NewRunnableMethod(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,18 +166,17 @@ HTMLLinkElement::BindToTree(nsIDocument*
     aDocument->RegisterPendingLinkUpdate(this);
   }
 
   if (IsInComposedDoc()) {
     TryDNSPrefetchPreconnectOrPrefetchOrPrerender();
   }
 
   void (HTMLLinkElement::*update)() = &HTMLLinkElement::UpdateStyleSheetInternal;
-  nsContentUtils::AddScriptRunner(
-    NewRunnableMethod("dom::HTMLLinkElement::BindToTree", this, update));
+  nsContentUtils::AddScriptRunner(NewRunnableMethod(this, update));
 
   CreateAndDispatchEvent(aDocument, NS_LITERAL_STRING("DOMLinkAdded"));
 
   return rv;
 }
 
 void
 HTMLLinkElement::LinkAdded()
--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -227,22 +227,20 @@ 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)
-    : Runnable("dom::nsMediaEvent")
-    , mElement(aElement)
-    , mLoadID(mElement->GetCurrentLoadID())
-  {
-  }
+
+  explicit nsMediaEvent(HTMLMediaElement* aElement) :
+    mElement(aElement),
+    mLoadID(mElement->GetCurrentLoadID()) {}
   ~nsMediaEvent() {}
 
   NS_IMETHOD Run() = 0;
 
 protected:
   bool IsCancelled() {
     return mElement->GetCurrentLoadID() != mLoadID;
   }
@@ -402,21 +400,19 @@ 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>(
-          "dom::HTMLMediaElement::StreamSizeListener::ReceivedSize",
-          this,
-          &StreamSizeListener::ReceivedSize,
-          c->mFrame.GetIntrinsicSize());
+        nsCOMPtr<nsIRunnable> event =
+          NewRunnableMethod<gfx::IntSize>(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;
       }
     }
@@ -969,36 +965,34 @@ private:
       return;
     }
 
     if (!IsPlayingStarted()) {
       return;
     }
 
     uint64_t windowID = mAudioChannelAgent->WindowID();
-    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");
-      }));
+    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");
+    }));
   }
 
   bool
   IsTabActivated()
   {
     if (MaybeCreateAudioChannelAgent()) {
       return !mAudioChannelAgent->ShouldBlockMedia();
     }
@@ -4091,22 +4085,18 @@ 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->InitWithNamedFuncCallback(
-        TimerCallback,
-        this,
-        timeout,
-        nsITimer::TYPE_ONE_SHOT,
-        "dom::HTMLMediaElement::WakeLockBoolWrapper::UpdateWakeLock");
+      mTimer->InitWithFuncCallback(TimerCallback, this, timeout,
+                                   nsITimer::TYPE_ONE_SHOT);
     }
   }
 }
 
 void
 HTMLMediaElement::WakeLockBoolWrapper::TimerCallback(nsITimer* aTimer,
                                                      void* aClosure)
 {
@@ -4536,22 +4526,21 @@ void HTMLMediaElement::UnbindFromTree(bo
   mVisibilityState = Visibility::UNTRACKED;
 
   nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent);
 
   MOZ_ASSERT(IsHidden());
   NotifyDecoderActivityChanges();
 
   RefPtr<HTMLMediaElement> self(this);
-  nsCOMPtr<nsIRunnable> task =
-    NS_NewRunnableFunction("dom::HTMLMediaElement::UnbindFromTree", [self]() {
-      if (self->mUnboundFromTree) {
-        self->Pause();
-      }
-    });
+  nsCOMPtr<nsIRunnable> task = NS_NewRunnableFunction([self] () {
+    if (self->mUnboundFromTree) {
+      self->Pause();
+    }
+  });
   RunInStableState(task);
 }
 
 static bool
 IsVP9InMP4(const MediaContainerType& aContainerType)
 {
   const MediaContainerType mimeType(aContainerType.Type());
   return DecoderTraits::IsMP4SupportedType(mimeType,
@@ -4850,51 +4839,40 @@ 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(
-        "dom::HTMLMediaElement::StreamListener::DoNotifyBlocked",
-        this,
-        &StreamListener::DoNotifyBlocked);
+      event = NewRunnableMethod(this, &StreamListener::DoNotifyBlocked);
     } else {
-      event = NewRunnableMethod(
-        "dom::HTMLMediaElement::StreamListener::DoNotifyUnblocked",
-        this,
-        &StreamListener::DoNotifyUnblocked);
+      event = NewRunnableMethod(this, &StreamListener::DoNotifyUnblocked);
     }
     aGraph->DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
                                                        event.forget());
   }
   virtual void NotifyHasCurrentData(MediaStreamGraph* aGraph) override
   {
     MutexAutoLock lock(mMutex);
     aGraph->DispatchToMainThreadAfterStreamStateUpdate(
       mAbstractMainThread,
-      NewRunnableMethod(
-        "dom::HTMLMediaElement::StreamListener::DoNotifyHaveCurrentData",
-        this,
-        &StreamListener::DoNotifyHaveCurrentData));
+      NewRunnableMethod(this, &StreamListener::DoNotifyHaveCurrentData));
   }
   virtual void NotifyOutput(MediaStreamGraph* aGraph,
                             GraphTime aCurrentTime) override
   {
     MutexAutoLock lock(mMutex);
     if (mPendingNotifyOutput)
       return;
     mPendingNotifyOutput = true;
     aGraph->DispatchToMainThreadAfterStreamStateUpdate(
       mAbstractMainThread,
-      NewRunnableMethod("dom::HTMLMediaElement::StreamListener::DoNotifyOutput",
-                        this,
-                        &StreamListener::DoNotifyOutput));
+      NewRunnableMethod(this, &StreamListener::DoNotifyOutput));
   }
 
 private:
   // These fields may only be accessed on the main thread
   HTMLMediaElement* mElement;
   bool mHaveCurrentData;
   bool mBlocked;
   bool mFinished;
@@ -6313,19 +6291,17 @@ 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("dom::HTMLMediaElement::DoRemoveSelfReference",
-                          this,
-                          &HTMLMediaElement::DoRemoveSelfReference);
+        NewRunnableMethod(this, &HTMLMediaElement::DoRemoveSelfReference);
       NS_DispatchToMainThread(event);
     }
   }
 }
 
 void HTMLMediaElement::DoRemoveSelfReference()
 {
   mShutdownObserver->ReleaseMediaElement();
@@ -7512,33 +7488,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(
-      "dom::HTMLMediaElement::AsyncResolveSeekDOMPromiseIfExists",
-      [=]() { promise->MaybeResolveWithUndefined(); });
+    nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () {
+      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(
-      "dom::HTMLMediaElement::AsyncRejectSeekDOMPromiseIfExists",
-      [=]() { promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); });
+    nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () {
+      promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR);
+    });
     mAbstractMainThread->Dispatch(r.forget());
     mSeekDOMPromise = nullptr;
   }
 }
 
 void
 HTMLMediaElement::ReportCanPlayTelemetry()
 {
@@ -7546,39 +7522,36 @@ 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(
-      "dom::HTMLMediaElement::ReportCanPlayTelemetry",
-      [thread]() {
+    NS_NewRunnableFunction([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(
-          "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();
-          }));
-      }),
+      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();
+        }));
+    }),
     NS_DISPATCH_NORMAL);
 }
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/html/HTMLObjectElement.cpp
+++ b/dom/html/HTMLObjectElement.cpp
@@ -126,19 +126,17 @@ static nsIWidget* GetWidget(Element* aEl
 }
 
 Element* HTMLObjectElement::sLastFocused = nullptr; // Weak
 
 class PluginFocusSetter : public Runnable
 {
 public:
   PluginFocusSetter(nsIWidget* aWidget, Element* aElement)
-    : Runnable("PluginFocusSetter")
-    , mWidget(aWidget)
-    , mElement(aElement)
+  : mWidget(aWidget), mElement(aElement)
   {
   }
 
   NS_IMETHOD Run() override
   {
     if (mElement) {
       HTMLObjectElement::sLastFocused = mElement;
       bool value = true;
@@ -266,18 +264,17 @@ 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("dom::HTMLObjectElement::BindToTree", this, start));
+    nsContentUtils::AddScriptRunner(NewRunnableMethod(this, start));
   }
 
   return NS_OK;
 }
 
 void
 HTMLObjectElement::UnbindFromTree(bool aDeep,
                                   bool aNullParent)
--- a/dom/html/HTMLSharedObjectElement.cpp
+++ b/dom/html/HTMLSharedObjectElement.cpp
@@ -134,18 +134,17 @@ 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(
-      "dom::HTMLSharedObjectElement::BindToTree", this, start));
+    nsContentUtils::AddScriptRunner(NewRunnableMethod(this, start));
   }
 
   return NS_OK;
 }
 
 void
 HTMLSharedObjectElement::UnbindFromTree(bool aDeep,
                                         bool aNullParent)
--- a/dom/html/HTMLStyleElement.cpp
+++ b/dom/html/HTMLStyleElement.cpp
@@ -141,18 +141,17 @@ 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("dom::HTMLStyleElement::BindToTree", this, update));
+  nsContentUtils::AddScriptRunner(NewRunnableMethod(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,20 +260,17 @@ HTMLTrackElement::SetSrc(const nsAString
 
   DispatchLoadResource();
 }
 
 void
 HTMLTrackElement::DispatchLoadResource()
 {
   if (!mLoadResourceDispatched) {
-    RefPtr<Runnable> r =
-      NewRunnableMethod("dom::HTMLTrackElement::LoadResource",
-                        this,
-                        &HTMLTrackElement::LoadResource);
+    RefPtr<Runnable> r = NewRunnableMethod(this, &HTMLTrackElement::LoadResource);
     nsContentUtils::RunInStableState(r.forget());
     mLoadResourceDispatched = true;
   }
 }
 
 void
 HTMLTrackElement::LoadResource()
 {
@@ -435,21 +432,21 @@ HTMLTrackElement::SetReadyState(uint16_t
 
 void
 HTMLTrackElement::DispatchTrackRunnable(const nsString& aEventName)
 {
   nsIDocument* doc = OwnerDoc();
   if (!doc) {
     return;
   }
-  nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod<con