--- a/gfx/2d/DrawTargetSkia.cpp
+++ b/gfx/2d/DrawTargetSkia.cpp
@@ -1943,19 +1943,19 @@ DrawTargetSkia::PopClip()
 // Image filter that just passes the source through to the result unmodified.
 class CopyLayerImageFilter : public SkImageFilter
 {
 public:
   CopyLayerImageFilter()
     : SkImageFilter(nullptr, 0, nullptr)
   {}
 
-  virtual sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source,
-                                              const Context& ctx,
-                                              SkIPoint* offset) const override {
+  sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source,
+                                      const Context& ctx,
+                                      SkIPoint* offset) const override {
     offset->set(0, 0);
     return sk_ref_sp(source);
   }
 
   SK_TO_STRING_OVERRIDE()
   SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(CopyLayerImageFilter)
 };
 

--- a/gfx/2d/JobScheduler_posix.cpp
+++ b/gfx/2d/JobScheduler_posix.cpp
@@ -16,22 +16,22 @@ void* ThreadCallback(void* threadData);
 class WorkerThreadPosix : public WorkerThread {
 public:
   explicit WorkerThreadPosix(MultiThreadedJobQueue* aJobQueue)
   : WorkerThread(aJobQueue)
   {
     pthread_create(&mThread, nullptr, ThreadCallback, static_cast<WorkerThread*>(this));
   }
 
-  ~WorkerThreadPosix()
+  ~WorkerThreadPosix() override
   {
     pthread_join(mThread, nullptr);
   }
 
-  virtual void SetName(const char*) override
+  void SetName(const char*) override
   {
 // XXX - temporarily disabled, see bug 1209039
 //
 //    // Call this from the thread itself because of Mac.
 //#ifdef XP_MACOSX
 //    pthread_setname_np(aName);
 //#elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
 //    pthread_set_name_np(mThread, aName);

--- a/gfx/layers/LayerTreeInvalidation.cpp
+++ b/gfx/layers/LayerTreeInvalidation.cpp
@@ -152,31 +152,31 @@ struct LayerPropertiesBase : public Laye
     mTransform = GetTransformForInvalidation(aLayer);
   }
   LayerPropertiesBase()
     : mLayer(nullptr)
     , mMaskLayer(nullptr)
   {
     MOZ_COUNT_CTOR(LayerPropertiesBase);
   }
-  ~LayerPropertiesBase()
+  ~LayerPropertiesBase() override
   {
     MOZ_COUNT_DTOR(LayerPropertiesBase);
   }
 
 protected:
   LayerPropertiesBase(const LayerPropertiesBase& a) = delete;
   LayerPropertiesBase& operator=(const LayerPropertiesBase& a) = delete;
 
 public:
-  virtual nsIntRegion ComputeDifferences(Layer* aRoot,
-                                         NotifySubDocInvalidationFunc aCallback,
-                                         bool* aGeometryChanged);
+  nsIntRegion ComputeDifferences(Layer* aRoot,
+                                 NotifySubDocInvalidationFunc aCallback,
+                                 bool* aGeometryChanged) override;
 
-  virtual void MoveBy(const IntPoint& aOffset);
+  void MoveBy(const IntPoint& aOffset) override;
 
   nsIntRegion ComputeChange(NotifySubDocInvalidationFunc aCallback,
                             bool& aGeometryChanged)
   {
     // Bug 1251615: This canary is sometimes hit. We're still not sure why.
     mCanary.Check();
     bool transformChanged = !mTransform.FuzzyEqual(GetTransformForInvalidation(mLayer)) ||
                              mLayer->GetPostXScale() != mPostXScale ||
@@ -449,18 +449,18 @@ struct ColorLayerProperties : public Lay
     , mBounds(aLayer->GetBounds())
   { }
 
 protected:
   ColorLayerProperties(const ColorLayerProperties& a) = delete;
   ColorLayerProperties& operator=(const ColorLayerProperties& a) = delete;
 
 public:
-  virtual nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
-                                            bool& aGeometryChanged)
+  nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
+                                    bool& aGeometryChanged) override
   {
     ColorLayer* color = static_cast<ColorLayer*>(mLayer.get());
 
     if (mColor != color->GetColor()) {
       aGeometryChanged = true;
       return NewTransformedBounds();
     }
 
@@ -500,18 +500,18 @@ struct ImageLayerProperties : public Lay
     , mIsMask(aIsMask)
   {
     if (mImageHost) {
       mLastProducerID = mImageHost->GetLastProducerID();
       mLastFrameID = mImageHost->GetLastFrameID();
     }
   }
 
-  virtual nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
-                                            bool& aGeometryChanged)
+  nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
+                                    bool& aGeometryChanged) override
   {
     ImageLayer* imageLayer = static_cast<ImageLayer*>(mLayer.get());
 
     if (!imageLayer->GetLocalVisibleRegion().ToUnknownRegion().IsEqual(mVisibleRegion)) {
       aGeometryChanged = true;
       IntRect result = NewTransformedBounds();
       result = result.Union(OldTransformedBounds());
       return result;
@@ -561,18 +561,18 @@ struct CanvasLayerProperties : public La
 {
   explicit CanvasLayerProperties(CanvasLayer* aCanvas)
     : LayerPropertiesBase(aCanvas)
     , mImageHost(GetImageHost(aCanvas))
   {
     mFrameID = mImageHost ? mImageHost->GetFrameID() : -1;
   }
 
-  virtual nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
-                                            bool& aGeometryChanged)
+  nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
+                                    bool& aGeometryChanged) override
   {
     CanvasLayer* canvasLayer = static_cast<CanvasLayer*>(mLayer.get());
 
     ImageHost* host = GetImageHost(canvasLayer);
     if (host && host->GetFrameID() != mFrameID) {
       aGeometryChanged = true;
 
       return NewTransformedBounds();

--- a/gfx/layers/basic/BasicImageLayer.cpp
+++ b/gfx/layers/basic/BasicImageLayer.cpp
@@ -26,34 +26,34 @@ class BasicImageLayer : public ImageLaye
 public:
   explicit BasicImageLayer(BasicLayerManager* aLayerManager) :
     ImageLayer(aLayerManager, static_cast<BasicImplData*>(this)),
     mSize(-1, -1)
   {
     MOZ_COUNT_CTOR(BasicImageLayer);
   }
 protected:
-  virtual ~BasicImageLayer()
+  ~BasicImageLayer() override
   {
     MOZ_COUNT_DTOR(BasicImageLayer);
   }
 
 public:
-  virtual void SetVisibleRegion(const LayerIntRegion& aRegion) override
+  void SetVisibleRegion(const LayerIntRegion& aRegion) override
   {
     NS_ASSERTION(BasicManager()->InConstruction(),
                  "Can only set properties in construction phase");
     ImageLayer::SetVisibleRegion(aRegion);
   }
 
-  virtual void Paint(DrawTarget* aDT,
-                     const gfx::Point& aDeviceOffset,
-                     Layer* aMaskLayer) override;
+  void Paint(DrawTarget* aDT,
+             const gfx::Point& aDeviceOffset,
+             Layer* aMaskLayer) override;
 
-  virtual already_AddRefed<SourceSurface> GetAsSourceSurface() override;
+  already_AddRefed<SourceSurface> GetAsSourceSurface() override;
 
 protected:
   BasicLayerManager* BasicManager()
   {
     return static_cast<BasicLayerManager*>(mManager);
   }
 
   gfx::IntSize mSize;

--- a/gfx/thebes/gfxDrawable.cpp
+++ b/gfx/thebes/gfxDrawable.cpp
@@ -185,22 +185,22 @@ gfxPatternDrawable::~gfxPatternDrawable(
 
 class DrawingCallbackFromDrawable : public gfxDrawingCallback {
 public:
     explicit DrawingCallbackFromDrawable(gfxDrawable* aDrawable)
      : mDrawable(aDrawable) {
         NS_ASSERTION(aDrawable, "aDrawable is null!");
     }
 
-    virtual ~DrawingCallbackFromDrawable() = default;
+    ~DrawingCallbackFromDrawable() override = default;
 
-    virtual bool operator()(gfxContext* aContext,
-                              const gfxRect& aFillRect,
-                              const SamplingFilter aSamplingFilter,
-                              const gfxMatrix& aTransform = gfxMatrix())
+    bool operator()(gfxContext* aContext,
+                    const gfxRect& aFillRect,
+                    const SamplingFilter aSamplingFilter,
+                    const gfxMatrix& aTransform = gfxMatrix()) override
     {
         return mDrawable->Draw(aContext, aFillRect, ExtendMode::CLAMP,
                                aSamplingFilter, 1.0,
                                aTransform);
     }
 private:
     RefPtr<gfxDrawable> mDrawable;
 };

--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -190,21 +190,21 @@ public:
 /// very first critical message, and the latest capacity-1 messages are
 /// rotated through. Note that we don't expect the total number of times
 /// this gets called to be large - it is meant for critical errors only.
 
 class CrashStatsLogForwarder: public mozilla::gfx::LogForwarder
 {
 public:
   explicit CrashStatsLogForwarder(const char* aKey);
-  virtual void Log(const std::string& aString) override;
-  virtual void CrashAction(LogReason aReason) override;
-  virtual bool UpdateStringsVector(const std::string& aString) override;
-
-  virtual LoggingRecord LoggingRecordCopy() override;
+  void Log(const std::string& aString) override;
+  void CrashAction(LogReason aReason) override;
+  bool UpdateStringsVector(const std::string& aString) override;
+
+  LoggingRecord LoggingRecordCopy() override;
 
   void SetCircularBufferSize(uint32_t aCapacity);
 
 private:
   // Helper for the Log()
   void UpdateCrashReport();
 
 private:
@@ -302,17 +302,17 @@ void CrashStatsLogForwarder::UpdateCrash
   if (annotated != NS_OK) {
     printf("Crash Annotation %s: %s",
            mCrashCriticalKey.get(), message.str().c_str());
   }
 }
 
 class LogForwarderEvent : public Runnable
 {
-  virtual ~LogForwarderEvent() = default;
+  ~LogForwarderEvent() override = default;
 
   NS_DECL_ISUPPORTS_INHERITED
 
   explicit LogForwarderEvent(const nsCString& aMessage) : mMessage(aMessage) {}
 
   NS_IMETHOD Run() override {
     MOZ_ASSERT(NS_IsMainThread() && (XRE_IsContentProcess() || XRE_IsGPUProcess()));
 
@@ -356,17 +356,17 @@ void CrashStatsLogForwarder::Log(const s
       nsCOMPtr<nsIRunnable> r1 = new LogForwarderEvent(stringToSend);
       NS_DispatchToMainThread(r1);
     }
   }
 }
 
 class CrashTelemetryEvent : public Runnable
 {
-  virtual ~CrashTelemetryEvent() = default;
+  ~CrashTelemetryEvent() override = default;
 
   NS_DECL_ISUPPORTS_INHERITED
 
   explicit CrashTelemetryEvent(uint32_t aReason) : mReason(aReason) {}
 
   NS_IMETHOD Run() override {
     MOZ_ASSERT(NS_IsMainThread());
     Telemetry::Accumulate(Telemetry::GFX_CRASH, mReason);

--- a/gfx/thebes/gfxPlatformMac.cpp
+++ b/gfx/thebes/gfxPlatformMac.cpp
@@ -385,45 +385,45 @@ static CVReturn VsyncCallback(CVDisplayL
 
 class OSXVsyncSource final : public VsyncSource
 {
 public:
   OSXVsyncSource()
   {
   }
 
-  virtual Display& GetGlobalDisplay() override
+  Display& GetGlobalDisplay() override
   {
     return mGlobalDisplay;
   }
 
   class OSXDisplay final : public VsyncSource::Display
   {
   public:
     OSXDisplay()
       : mDisplayLink(nullptr)
     {
       MOZ_ASSERT(NS_IsMainThread());
       mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
     }
 
-    ~OSXDisplay()
+    ~OSXDisplay() override
     {
       MOZ_ASSERT(NS_IsMainThread());
     }
 
     static void RetryEnableVsync(nsITimer* aTimer, void* aOsxDisplay)
     {
       MOZ_ASSERT(NS_IsMainThread());
       OSXDisplay* osxDisplay = static_cast<OSXDisplay*>(aOsxDisplay);
       MOZ_ASSERT(osxDisplay);
       osxDisplay->EnableVsync();
     }
 
-    virtual void EnableVsync() override
+    void EnableVsync() override
     {
       MOZ_ASSERT(NS_IsMainThread());
       if (IsVsyncEnabled()) {
         return;
       }
 
       // Create a display link capable of being used with all active displays
       // TODO: See if we need to create an active DisplayLink for each monitor in multi-monitor
@@ -473,42 +473,42 @@ public:
         int64_t timeValue = vsyncRate.timeValue;
         int64_t timeScale = vsyncRate.timeScale;
         const int milliseconds = 1000;
         float rateInMs = ((double) timeValue / (double) timeScale) * milliseconds;
         mVsyncRate = TimeDuration::FromMilliseconds(rateInMs);
       }
     }
 
-    virtual void DisableVsync() override
+    void DisableVsync() override
     {
       MOZ_ASSERT(NS_IsMainThread());
       if (!IsVsyncEnabled()) {
         return;
       }
 
       // Release the display link
       if (mDisplayLink) {
         CVDisplayLinkRelease(mDisplayLink);
         mDisplayLink = nullptr;
       }
     }
 
-    virtual bool IsVsyncEnabled() override
+    bool IsVsyncEnabled() override
     {
       MOZ_ASSERT(NS_IsMainThread());
       return mDisplayLink != nullptr;
     }
 
-    virtual TimeDuration GetVsyncRate() override
+    TimeDuration GetVsyncRate() override
     {
       return mVsyncRate;
     }
 
-    virtual void Shutdown() override
+    void Shutdown() override
     {
       MOZ_ASSERT(NS_IsMainThread());
       mTimer->Cancel();
       mTimer = nullptr;
       DisableVsync();
     }
 
     // The vsync timestamps given by the CVDisplayLinkCallback are
@@ -521,17 +521,17 @@ public:
   private:
     // Manages the display link render thread
     CVDisplayLinkRef   mDisplayLink;
     RefPtr<nsITimer> mTimer;
     TimeDuration mVsyncRate;
   }; // OSXDisplay
 
 private:
-  virtual ~OSXVsyncSource() = default;
+  ~OSXVsyncSource() override = default;
 
   OSXDisplay mGlobalDisplay;
 }; // OSXVsyncSource
 
 static CVReturn VsyncCallback(CVDisplayLinkRef aDisplayLink,
                               const CVTimeStamp* aNow,
                               const CVTimeStamp* aOutputTime,
                               CVOptionFlags aFlagsIn,