Bug 1263311: Part 3 - s/nsCancelableRunnable/CancelableRunnable/g. r=froydnj
authorKyle Huey <khuey@kylehuey.com>
Mon, 11 Apr 2016 11:40:06 -0700
changeset 330806 9639832c996cedbcc75cdd99e30320ea65bdfad8
parent 330805 6ca7effcd9abd76e8bf5560eb19390b34e3c1c43
child 330807 00cb5de040be36971fa941cb52fcc679fe67878d
push id6048
push userkmoir@mozilla.com
push dateMon, 06 Jun 2016 19:02:08 +0000
treeherdermozilla-beta@46d72a56c57d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1263311
milestone48.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1263311: Part 3 - s/nsCancelableRunnable/CancelableRunnable/g. r=froydnj
dom/base/ImageEncoder.cpp
dom/base/WebSocket.cpp
dom/base/nsPerformance.cpp
dom/cache/CachePushStreamChild.cpp
dom/cache/ReadStream.cpp
dom/canvas/WebGLContext.cpp
dom/canvas/WebGLContextLossHandler.cpp
dom/crypto/WebCryptoTask.h
dom/events/AsyncEventDispatcher.h
dom/filesystem/FileSystemPermissionRequest.cpp
dom/filesystem/FileSystemTaskBase.cpp
dom/html/HTMLCanvasElement.cpp
dom/indexedDB/ActorsChild.cpp
dom/indexedDB/IDBDatabase.cpp
dom/ipc/Blob.cpp
dom/messagechannel/MessagePort.cpp
dom/promise/PromiseDebugging.cpp
gfx/src/gfxCrashReporterUtils.cpp
ipc/glue/BackgroundImpl.cpp
ipc/glue/MessagePump.cpp
netwerk/protocol/websocket/WebSocketChannel.cpp
xpcom/base/DebuggerOnGCRunnable.h
xpcom/base/nsCycleCollector.cpp
xpcom/glue/nsThreadUtils.cpp
xpcom/glue/nsThreadUtils.h
xpcom/io/nsStreamUtils.cpp
xpcom/threads/TimerThread.cpp
--- a/dom/base/ImageEncoder.cpp
+++ b/dom/base/ImageEncoder.cpp
@@ -67,17 +67,17 @@ private:
 // main thread.
 already_AddRefed<DataSourceSurface>
 GetBRGADataSourceSurfaceSync(already_AddRefed<layers::Image> aImage)
 {
   RefPtr<SurfaceHelper> helper = new SurfaceHelper(Move(aImage));
   return helper->GetDataSurfaceSafe();
 }
 
-class EncodingCompleteEvent : public nsCancelableRunnable
+class EncodingCompleteEvent : public CancelableRunnable
 {
   virtual ~EncodingCompleteEvent() {}
 
 public:
   explicit EncodingCompleteEvent(EncodeCompleteCallback* aEncodeCompleteCallback)
     : mImgSize(0)
     , mType()
     , mImgData(nullptr)
--- a/dom/base/WebSocket.cpp
+++ b/dom/base/WebSocket.cpp
@@ -248,17 +248,17 @@ private:
 NS_IMPL_ISUPPORTS(WebSocketImpl,
                   nsIInterfaceRequestor,
                   nsIWebSocketListener,
                   nsIObserver,
                   nsISupportsWeakReference,
                   nsIRequest,
                   nsIEventTarget)
 
-class CallDispatchConnectionCloseEvents final : public nsCancelableRunnable
+class CallDispatchConnectionCloseEvents final : public CancelableRunnable
 {
 public:
   explicit CallDispatchConnectionCloseEvents(WebSocketImpl* aWebSocketImpl)
     : mWebSocketImpl(aWebSocketImpl)
   {
     aWebSocketImpl->AssertIsOnTargetThread();
   }
 
--- a/dom/base/nsPerformance.cpp
+++ b/dom/base/nsPerformance.cpp
@@ -1131,17 +1131,17 @@ PerformanceBase::NotifyObservers()
 }
 
 void
 PerformanceBase::CancelNotificationObservers()
 {
   mPendingNotificationObserversTask = false;
 }
 
-class NotifyObserversTask final : public nsCancelableRunnable
+class NotifyObserversTask final : public CancelableRunnable
 {
 public:
   explicit NotifyObserversTask(PerformanceBase* aPerformance)
     : mPerformance(aPerformance)
   {
     MOZ_ASSERT(mPerformance);
   }
 
--- a/dom/cache/CachePushStreamChild.cpp
+++ b/dom/cache/CachePushStreamChild.cpp
@@ -12,17 +12,17 @@
 #include "nsIThread.h"
 #include "nsStreamUtils.h"
 
 namespace mozilla {
 namespace dom {
 namespace cache {
 
 class CachePushStreamChild::Callback final : public nsIInputStreamCallback
-                                           , public nsCancelableRunnable
+                                           , public CancelableRunnable
 {
 public:
   explicit Callback(CachePushStreamChild* aActor)
     : mActor(aActor)
     , mOwningThread(NS_GetCurrentThread())
   {
     MOZ_ASSERT(mActor);
   }
@@ -84,17 +84,17 @@ private:
 
   CachePushStreamChild* mActor;
   nsCOMPtr<nsIThread> mOwningThread;
 
   NS_DECL_ISUPPORTS_INHERITED
 };
 
 NS_IMPL_ISUPPORTS_INHERITED(CachePushStreamChild::Callback,
-                            nsCancelableRunnable,
+                            CancelableRunnable,
                             nsIInputStreamCallback);
 
 CachePushStreamChild::CachePushStreamChild(Feature* aFeature,
                                            nsISupports* aParent,
                                            nsIAsyncInputStream* aStream)
   : mParent(aParent)
   , mStream(aStream)
   , mClosed(false)
--- a/dom/cache/ReadStream.cpp
+++ b/dom/cache/ReadStream.cpp
@@ -112,17 +112,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 nsCancelableRunnable
+class ReadStream::Inner::NoteClosedRunnable final : public CancelableRunnable
 {
 public:
   explicit NoteClosedRunnable(ReadStream::Inner* aStream)
     : mStream(aStream)
   { }
 
   NS_IMETHOD Run()
   {
@@ -147,17 +147,17 @@ private:
 
 // ----------------------------------------------------------------------------
 
 // Runnable to clear actors without reporting that the ReadStream has
 // 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 nsCancelableRunnable
+class ReadStream::Inner::ForgetRunnable final : public CancelableRunnable
 {
 public:
   explicit ForgetRunnable(ReadStream::Inner* aStream)
     : mStream(aStream)
   { }
 
   NS_IMETHOD Run()
   {
--- a/dom/canvas/WebGLContext.cpp
+++ b/dom/canvas/WebGLContext.cpp
@@ -1533,17 +1533,17 @@ WebGLContext::TryToRestoreContext()
 }
 
 void
 WebGLContext::RunContextLossTimer()
 {
     mContextLossHandler->RunTimer();
 }
 
-class UpdateContextLossStatusTask : public nsCancelableRunnable
+class UpdateContextLossStatusTask : public CancelableRunnable
 {
     RefPtr<WebGLContext> mWebGL;
 
 public:
     explicit UpdateContextLossStatusTask(WebGLContext* webgl)
         : mWebGL(webgl)
     {
     }
--- a/dom/canvas/WebGLContextLossHandler.cpp
+++ b/dom/canvas/WebGLContextLossHandler.cpp
@@ -33,17 +33,17 @@ public:
 
 protected:
     ~ContextLossWorkerEventTarget() {}
 
 private:
     nsCOMPtr<nsIEventTarget> mEventTarget;
 };
 
-class ContextLossWorkerRunnable final : public nsCancelableRunnable
+class ContextLossWorkerRunnable final : public CancelableRunnable
 {
 public:
     explicit ContextLossWorkerRunnable(nsIRunnable* aRunnable)
         : mRunnable(aRunnable)
     {
     }
 
     nsresult Cancel() override;
--- a/dom/crypto/WebCryptoTask.h
+++ b/dom/crypto/WebCryptoTask.h
@@ -52,17 +52,17 @@ Cleanup should execute regardless of wha
 
 #define MAYBE_EARLY_FAIL(rv) \
 if (NS_FAILED(rv)) { \
   FailWithError(rv); \
   Skip(); \
   return; \
 }
 
-class WebCryptoTask : public nsCancelableRunnable,
+class WebCryptoTask : public CancelableRunnable,
                       public nsNSSShutDownObject
 {
 public:
   virtual void DispatchWithPromise(Promise* aResultPromise);
 
   void Skip()
   {
     virtualDestroyNSSReference();
--- a/dom/events/AsyncEventDispatcher.h
+++ b/dom/events/AsyncEventDispatcher.h
@@ -20,17 +20,17 @@ namespace mozilla {
 
 /**
  * Use AsyncEventDispatcher to fire a DOM event that requires safe a stable DOM.
  * For example, you may need to fire an event from within layout, but
  * want to ensure that the event handler doesn't mutate the DOM at
  * the wrong time, in order to avoid resulting instability.
  */
 
-class AsyncEventDispatcher : public nsCancelableRunnable
+class AsyncEventDispatcher : public CancelableRunnable
 {
 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.
    */
--- a/dom/filesystem/FileSystemPermissionRequest.cpp
+++ b/dom/filesystem/FileSystemPermissionRequest.cpp
@@ -72,17 +72,17 @@ void
 PBackgroundInitializer::ActorCreated(mozilla::ipc::PBackgroundChild* aActor)
 {
   mTask->Start();
 }
 
 // This must be a CancelableRunnable because it can be dispatched to a worker
 // thread. But we don't care about the Cancel() because in that case, Run() is
 // not called and the task is deleted by the DTOR.
-class AsyncStartRunnable final : public nsCancelableRunnable
+class AsyncStartRunnable final : public CancelableRunnable
 {
 public:
   explicit AsyncStartRunnable(FileSystemTaskChildBase* aTask)
     : mTask(aTask)
   {
     MOZ_ASSERT(aTask);
   }
 
--- a/dom/filesystem/FileSystemTaskBase.cpp
+++ b/dom/filesystem/FileSystemTaskBase.cpp
@@ -73,17 +73,17 @@ DispatchToIOThread(nsIRunnable* aRunnabl
   MOZ_ASSERT(target);
 
   return target->Dispatch(aRunnable, NS_DISPATCH_NORMAL);
 }
 
 // This runnable is used when an error value is set before doing any real
 // operation on the I/O thread. In this case we skip all and we directly
 // communicate the error.
-class ErrorRunnable final : public nsCancelableRunnable
+class ErrorRunnable final : public CancelableRunnable
 {
 public:
   explicit ErrorRunnable(FileSystemTaskChildBase* aTask)
     : mTask(aTask)
   {
     MOZ_ASSERT(aTask);
   }
 
--- a/dom/html/HTMLCanvasElement.cpp
+++ b/dom/html/HTMLCanvasElement.cpp
@@ -1258,17 +1258,17 @@ HTMLCanvasElement::GetCompositorBackendT
 void
 HTMLCanvasElement::OnVisibilityChange()
 {
   if (OwnerDoc()->Hidden()) {
     return;
   }
 
   if (mOffscreenCanvas) {
-    class Runnable final : public nsCancelableRunnable
+    class Runnable final : public CancelableRunnable
     {
     public:
       explicit Runnable(AsyncCanvasRenderer* aRenderer)
         : mRenderer(aRenderer)
       {}
 
       NS_IMETHOD Run()
       {
@@ -1300,17 +1300,17 @@ HTMLCanvasElement::OnVisibilityChange()
     mCurrentContext->OnVisibilityChange();
   }
 }
 
 void
 HTMLCanvasElement::OnMemoryPressure()
 {
   if (mOffscreenCanvas) {
-    class Runnable final : public nsCancelableRunnable
+    class Runnable final : public CancelableRunnable
     {
     public:
       explicit Runnable(AsyncCanvasRenderer* aRenderer)
         : mRenderer(aRenderer)
       {}
 
       NS_IMETHOD Run()
       {
--- a/dom/indexedDB/ActorsChild.cpp
+++ b/dom/indexedDB/ActorsChild.cpp
@@ -2526,19 +2526,19 @@ BackgroundRequestChild::Recv__delete__(c
   return true;
 }
 
 /*******************************************************************************
  * BackgroundCursorChild
  ******************************************************************************/
 
 // Does not need to be threadsafe since this only runs on one thread, but
-// inheriting from nsCancelableRunnable is easy.
+// inheriting from CancelableRunnable is easy.
 class BackgroundCursorChild::DelayedActionRunnable final
-  : public nsCancelableRunnable
+  : public CancelableRunnable
 {
   using ActionFunc = void (BackgroundCursorChild::*)();
 
   BackgroundCursorChild* mActor;
   RefPtr<IDBRequest> mRequest;
   ActionFunc mActionFunc;
 
 public:
--- a/dom/indexedDB/IDBDatabase.cpp
+++ b/dom/indexedDB/IDBDatabase.cpp
@@ -62,17 +62,17 @@ using namespace mozilla::services;
 
 namespace {
 
 const char kCycleCollectionObserverTopic[] = "cycle-collector-end";
 const char kMemoryPressureObserverTopic[] = "memory-pressure";
 const char kWindowObserverTopic[] = "inner-window-destroyed";
 
 class CancelableRunnableWrapper final
-  : public nsCancelableRunnable
+  : public CancelableRunnable
 {
   nsCOMPtr<nsIRunnable> mRunnable;
 
 public:
   explicit
   CancelableRunnableWrapper(nsIRunnable* aRunnable)
     : mRunnable(aRunnable)
   {
--- a/dom/ipc/Blob.cpp
+++ b/dom/ipc/Blob.cpp
@@ -207,17 +207,17 @@ EventTargetIsOnCurrentThread(nsIEventTar
 
   bool current;
   MOZ_ALWAYS_SUCCEEDS(aEventTarget->IsOnCurrentThread(&current));
 
   return current;
 }
 
 class CancelableRunnableWrapper final
-  : public nsCancelableRunnable
+  : public CancelableRunnable
 {
   nsCOMPtr<nsIRunnable> mRunnable;
 #ifdef DEBUG
   nsCOMPtr<nsIEventTarget> mDEBUGEventTarget;
 #endif
 
 public:
   CancelableRunnableWrapper(nsIRunnable* aRunnable,
@@ -236,17 +236,17 @@ public:
 private:
   ~CancelableRunnableWrapper()
   { }
 
   NS_DECL_NSIRUNNABLE
   nsresult Cancel() override;
 };
 
-NS_IMPL_ISUPPORTS_INHERITED0(CancelableRunnableWrapper, nsCancelableRunnable)
+NS_IMPL_ISUPPORTS_INHERITED0(CancelableRunnableWrapper, CancelableRunnable)
 
 NS_IMETHODIMP
 CancelableRunnableWrapper::Run()
 {
   DebugOnly<bool> onTarget;
   MOZ_ASSERT(mDEBUGEventTarget);
   MOZ_ASSERT(NS_SUCCEEDED(mDEBUGEventTarget->IsOnCurrentThread(&onTarget)));
   MOZ_ASSERT(onTarget);
--- a/dom/messagechannel/MessagePort.cpp
+++ b/dom/messagechannel/MessagePort.cpp
@@ -43,17 +43,17 @@
 #undef PostMessage
 #endif
 
 using namespace mozilla::dom::workers;
 
 namespace mozilla {
 namespace dom {
 
-class PostMessageRunnable final : public nsCancelableRunnable
+class PostMessageRunnable final : public CancelableRunnable
 {
   friend class MessagePort;
 
 public:
   PostMessageRunnable(MessagePort* aPort, SharedMessagePortMessage* aData)
     : mPort(aPort)
     , mData(aData)
   {
--- a/dom/promise/PromiseDebugging.cpp
+++ b/dom/promise/PromiseDebugging.cpp
@@ -16,17 +16,17 @@
 #include "mozilla/dom/Promise.h"
 #include "mozilla/dom/PromiseBinding.h"
 #include "mozilla/dom/PromiseDebugging.h"
 #include "mozilla/dom/PromiseDebuggingBinding.h"
 
 namespace mozilla {
 namespace dom {
 
-class FlushRejections: public nsCancelableRunnable
+class FlushRejections: public CancelableRunnable
 {
 public:
   static void Init() {
     if (!sDispatched.init()) {
       MOZ_CRASH("Could not initialize FlushRejections::sDispatched");
     }
     sDispatched.set(false);
   }
--- a/gfx/src/gfxCrashReporterUtils.cpp
+++ b/gfx/src/gfxCrashReporterUtils.cpp
@@ -78,17 +78,17 @@ public:
     if (!observerService)
       return NS_OK;
     RefPtr<ObserverToDestroyFeaturesAlreadyReported> observer = new ObserverToDestroyFeaturesAlreadyReported;
     observerService->AddObserver(observer, "xpcom-shutdown", false);
     return NS_OK;
   }
 };
 
-class AppendAppNotesRunnable : public nsCancelableRunnable {
+class AppendAppNotesRunnable : public CancelableRunnable {
 public:
   explicit AppendAppNotesRunnable(const nsACString& aFeatureStr)
     : mFeatureString(aFeatureStr)
   {
   }
 
   NS_IMETHOD Run() override {
     CrashReporter::AppendAppNotesToCrashReport(mFeatureString);
--- a/ipc/glue/BackgroundImpl.cpp
+++ b/ipc/glue/BackgroundImpl.cpp
@@ -695,17 +695,17 @@ private:
           override;
 
   virtual void
   Failure() override;
 };
 
 // Must be cancelable in order to dispatch on active worker threads
 class ChildImpl::AlreadyCreatedCallbackRunnable final :
-  public nsCancelableRunnable
+  public CancelableRunnable
 {
 public:
   AlreadyCreatedCallbackRunnable()
   {
     // May be created on any thread!
   }
 
 protected:
--- a/ipc/glue/MessagePump.cpp
+++ b/ipc/glue/MessagePump.cpp
@@ -34,17 +34,17 @@ NS_DEFINE_NAMED_CID(NS_TIMER_CID);
 
 #ifdef DEBUG
 static MessagePump::Delegate* gFirstDelegate;
 #endif
 
 namespace mozilla {
 namespace ipc {
 
-class DoWorkRunnable final : public nsCancelableRunnable,
+class DoWorkRunnable final : public CancelableRunnable,
                              public nsITimerCallback
 {
 public:
   explicit DoWorkRunnable(MessagePump* aPump)
   : mPump(aPump)
   {
     MOZ_ASSERT(aPump);
   }
@@ -204,17 +204,17 @@ void
 MessagePump::DoDelayedWork(base::MessagePump::Delegate* aDelegate)
 {
   aDelegate->DoDelayedWork(&delayed_work_time_);
   if (!delayed_work_time_.is_null()) {
     ScheduleDelayedWork(delayed_work_time_);
   }
 }
 
-NS_IMPL_ISUPPORTS_INHERITED(DoWorkRunnable, nsCancelableRunnable,
+NS_IMPL_ISUPPORTS_INHERITED(DoWorkRunnable, CancelableRunnable,
 			    nsITimerCallback)
 
 NS_IMETHODIMP
 DoWorkRunnable::Run()
 {
   MessageLoop* loop = MessageLoop::current();
   MOZ_ASSERT(loop);
 
--- a/netwerk/protocol/websocket/WebSocketChannel.cpp
+++ b/netwerk/protocol/websocket/WebSocketChannel.cpp
@@ -686,17 +686,17 @@ private:
   nsCString mReason;
 };
 NS_IMPL_ISUPPORTS(CallOnServerClose, nsIRunnable)
 
 //-----------------------------------------------------------------------------
 // CallAcknowledge
 //-----------------------------------------------------------------------------
 
-class CallAcknowledge final : public nsCancelableRunnable
+class CallAcknowledge final : public CancelableRunnable
 {
 public:
   CallAcknowledge(WebSocketChannel* aChannel,
                   uint32_t aSize)
     : mChannel(aChannel),
       mListenerMT(mChannel->mListenerMT),
       mSize(aSize) {}
 
--- a/xpcom/base/DebuggerOnGCRunnable.h
+++ b/xpcom/base/DebuggerOnGCRunnable.h
@@ -10,17 +10,17 @@
 #include "nsThreadUtils.h"
 #include "js/GCAPI.h"
 #include "mozilla/Move.h"
 #include "mozilla/UniquePtr.h"
 
 namespace mozilla {
 
 // Runnable to fire the SpiderMonkey Debugger API's onGarbageCollection hook.
-class DebuggerOnGCRunnable : public nsCancelableRunnable
+class DebuggerOnGCRunnable : public CancelableRunnable
 {
   JS::dbg::GarbageCollectionEvent::Ptr mGCData;
 
   explicit DebuggerOnGCRunnable(JS::dbg::GarbageCollectionEvent::Ptr&& aGCData)
     : mGCData(Move(aGCData))
   { }
 
 public:
--- a/xpcom/base/nsCycleCollector.cpp
+++ b/xpcom/base/nsCycleCollector.cpp
@@ -1487,17 +1487,17 @@ struct CCGraphDescriber : public LinkedL
 
   nsCString mAddress;
   nsCString mName;
   nsCString mCompartmentOrToAddress;
   uint32_t mCnt;
   Type mType;
 };
 
-class LogStringMessageAsync : public nsCancelableRunnable
+class LogStringMessageAsync : public CancelableRunnable
 {
 public:
   explicit LogStringMessageAsync(const nsAString& aMsg) : mMsg(aMsg)
   {}
 
   NS_IMETHOD Run() override
   {
     nsCOMPtr<nsIConsoleService> cs =
--- a/xpcom/glue/nsThreadUtils.cpp
+++ b/xpcom/glue/nsThreadUtils.cpp
@@ -36,21 +36,21 @@ NS_IMPL_ISUPPORTS(nsRunnable, nsIRunnabl
 
 NS_IMETHODIMP
 nsRunnable::Run()
 {
   // Do nothing
   return NS_OK;
 }
 
-NS_IMPL_ISUPPORTS_INHERITED(nsCancelableRunnable, nsRunnable,
+NS_IMPL_ISUPPORTS_INHERITED(CancelableRunnable, nsRunnable,
                             nsICancelableRunnable)
 
 nsresult
-nsCancelableRunnable::Cancel()
+CancelableRunnable::Cancel()
 {
   // Do nothing
   return NS_OK;
 }
 
 #endif  // XPCOM_GLUE_AVOID_NSPR
 
 //-----------------------------------------------------------------------------
--- a/xpcom/glue/nsThreadUtils.h
+++ b/xpcom/glue/nsThreadUtils.h
@@ -228,28 +228,28 @@ public:
 
   nsRunnable() {}
 
 protected:
   virtual ~nsRunnable() {}
 };
 
 // This class is designed to be subclassed.
-class nsCancelableRunnable : public nsRunnable,
+class CancelableRunnable : public nsRunnable,
                              public nsICancelableRunnable
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   // nsICancelableRunnable
   virtual nsresult Cancel() override;
 
-  nsCancelableRunnable() {}
+  CancelableRunnable() {}
 
 protected:
-  virtual ~nsCancelableRunnable() {}
+  virtual ~CancelableRunnable() {}
 };
 
 // An event that can be used to call a C++11 functions or function objects,
 // including lambdas. The function must have no required arguments, and must
 // return void.
 template<typename Function>
 class nsRunnableFunction : public nsRunnable
 {
--- a/xpcom/io/nsStreamUtils.cpp
+++ b/xpcom/io/nsStreamUtils.cpp
@@ -25,17 +25,17 @@
 using namespace mozilla;
 
 //-----------------------------------------------------------------------------
 
 // This is a nsICancelableRunnable because we can dispatch it to Workers and
 // those can be shut down at any time, and in these cases, Cancel() is called
 // instead of Run().
 class nsInputStreamReadyEvent final
-  : public nsCancelableRunnable
+  : public CancelableRunnable
   , public nsIInputStreamCallback
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
 
   nsInputStreamReadyEvent(nsIInputStreamCallback* aCallback,
                           nsIEventTarget* aTarget)
     : mCallback(aCallback)
@@ -106,26 +106,26 @@ public:
   }
 
 private:
   nsCOMPtr<nsIAsyncInputStream>    mStream;
   nsCOMPtr<nsIInputStreamCallback> mCallback;
   nsCOMPtr<nsIEventTarget>         mTarget;
 };
 
-NS_IMPL_ISUPPORTS_INHERITED(nsInputStreamReadyEvent, nsCancelableRunnable,
+NS_IMPL_ISUPPORTS_INHERITED(nsInputStreamReadyEvent, CancelableRunnable,
                             nsIInputStreamCallback)
 
 //-----------------------------------------------------------------------------
 
 // This is a nsICancelableRunnable because we can dispatch it to Workers and
 // those can be shut down at any time, and in these cases, Cancel() is called
 // instead of Run().
 class nsOutputStreamReadyEvent final
-  : public nsCancelableRunnable
+  : public CancelableRunnable
   , public nsIOutputStreamCallback
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
 
   nsOutputStreamReadyEvent(nsIOutputStreamCallback* aCallback,
                            nsIEventTarget* aTarget)
     : mCallback(aCallback)
@@ -196,17 +196,17 @@ public:
   }
 
 private:
   nsCOMPtr<nsIAsyncOutputStream>    mStream;
   nsCOMPtr<nsIOutputStreamCallback> mCallback;
   nsCOMPtr<nsIEventTarget>          mTarget;
 };
 
-NS_IMPL_ISUPPORTS_INHERITED(nsOutputStreamReadyEvent, nsCancelableRunnable,
+NS_IMPL_ISUPPORTS_INHERITED(nsOutputStreamReadyEvent, CancelableRunnable,
                             nsIOutputStreamCallback)
 
 //-----------------------------------------------------------------------------
 
 already_AddRefed<nsIInputStreamCallback>
 NS_NewInputStreamReadyEvent(nsIInputStreamCallback* aCallback,
                             nsIEventTarget* aTarget)
 {
@@ -230,17 +230,17 @@ NS_NewOutputStreamReadyEvent(nsIOutputSt
 
 //-----------------------------------------------------------------------------
 // NS_AsyncCopy implementation
 
 // abstract stream copier...
 class nsAStreamCopier
   : public nsIInputStreamCallback
   , public nsIOutputStreamCallback
-  , public nsCancelableRunnable
+  , public CancelableRunnable
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
 
   nsAStreamCopier()
     : mLock("nsAStreamCopier.mLock")
     , mCallback(nullptr)
     , mProgressCallback(nullptr)
@@ -503,17 +503,17 @@ protected:
 
   // virtual since subclasses call superclass Release()
   virtual ~nsAStreamCopier()
   {
   }
 };
 
 NS_IMPL_ISUPPORTS_INHERITED(nsAStreamCopier,
-                            nsCancelableRunnable,
+                            CancelableRunnable,
                             nsIInputStreamCallback,
                             nsIOutputStreamCallback)
 
 class nsStreamCopierIB final : public nsAStreamCopier
 {
 public:
   nsStreamCopierIB() : nsAStreamCopier()
   {
--- a/xpcom/threads/TimerThread.cpp
+++ b/xpcom/threads/TimerThread.cpp
@@ -129,17 +129,17 @@ public:
   void Free(void* aPtr);
 };
 
 } // namespace
 
 // This is a nsICancelableRunnable because we can dispatch it to Workers and
 // those can be shut down at any time, and in these cases, Cancel() is called
 // instead of Run().
-class nsTimerEvent : public nsCancelableRunnable
+class nsTimerEvent : public CancelableRunnable
 {
 public:
   NS_IMETHOD Run() override;
 
   nsresult Cancel() override
   {
     // Since nsTimerImpl is not thread-safe, we should release |mTimer|
     // here in the target thread to avoid race condition. Otherwise,