--- a/image/imgLoader.cpp
+++ b/image/imgLoader.cpp
@@ -1061,17 +1061,17 @@ imgLoader::CreateNewProxyForRequest(imgR
 class imgCacheExpirationTracker final
   : public nsExpirationTracker<imgCacheEntry, 3>
 {
   enum { TIMEOUT_SECONDS = 10 };
 public:
   imgCacheExpirationTracker();
 
 protected:
-  void NotifyExpired(imgCacheEntry* entry);
+  void NotifyExpired(imgCacheEntry* entry) override;
 };
 
 imgCacheExpirationTracker::imgCacheExpirationTracker()
  : nsExpirationTracker<imgCacheEntry, 3>(TIMEOUT_SECONDS * 1000,
                                          "imgCacheExpirationTracker")
 { }
 
 void

--- a/image/imgRequestProxy.cpp
+++ b/image/imgRequestProxy.cpp
@@ -32,25 +32,25 @@ class ProxyBehaviour
   virtual void SetOwner(imgRequest* aOwner) = 0;
 };
 
 class RequestBehaviour : public ProxyBehaviour
 {
  public:
   RequestBehaviour() : mOwner(nullptr), mOwnerHasImage(false) {}
 
-  virtual already_AddRefed<mozilla::image::Image>GetImage() const override;
-  virtual bool HasImage() const override;
-  virtual already_AddRefed<ProgressTracker> GetProgressTracker() const override;
+  already_AddRefed<mozilla::image::Image>GetImage() const override;
+  bool HasImage() const override;
+  already_AddRefed<ProgressTracker> GetProgressTracker() const override;
 
-  virtual imgRequest* GetOwner() const override {
+  imgRequest* GetOwner() const override {
     return mOwner;
   }
 
-  virtual void SetOwner(imgRequest* aOwner) override {
+  void SetOwner(imgRequest* aOwner) override {
     mOwner = aOwner;
 
     if (mOwner) {
       RefPtr<ProgressTracker> ownerProgressTracker = GetProgressTracker();
       mOwnerHasImage = ownerProgressTracker && ownerProgressTracker->HasImage();
     } else {
       mOwnerHasImage = false;
     }
@@ -1022,36 +1022,36 @@ imgRequestProxy::GetOwner() const
 
 ////////////////// imgRequestProxyStatic methods
 
 class StaticBehaviour : public ProxyBehaviour
 {
 public:
   explicit StaticBehaviour(mozilla::image::Image* aImage) : mImage(aImage) {}
 
-  virtual already_AddRefed<mozilla::image::Image>
+  already_AddRefed<mozilla::image::Image>
   GetImage() const override {
     RefPtr<mozilla::image::Image> image = mImage;
     return image.forget();
   }
 
-  virtual bool HasImage() const override {
+  bool HasImage() const override {
     return mImage;
   }
 
-  virtual already_AddRefed<ProgressTracker> GetProgressTracker()
+  already_AddRefed<ProgressTracker> GetProgressTracker()
     const override  {
     return mImage->GetProgressTracker();
   }
 
-  virtual imgRequest* GetOwner() const override {
+  imgRequest* GetOwner() const override {
     return nullptr;
   }
 
-  virtual void SetOwner(imgRequest* aOwner) override {
+  void SetOwner(imgRequest* aOwner) override {
     MOZ_ASSERT(!aOwner,
                "We shouldn't be giving static requests a non-null owner.");
   }
 
 private:
   // Our image. We have to hold a strong reference here, because that's normally
   // the job of the underlying request.
   RefPtr<mozilla::image::Image> mImage;