Bug 1194806 - part 2 - mark overrides as such in widget/android/; r=snorp
authorNathan Froyd <froydnj@mozilla.com>
Fri, 14 Aug 2015 22:06:20 -0400
changeset 292434 05efc89f31eedc28dee03ade6419c41e76037575
parent 292433 b5b88b211712c95f07ffe7c6bb202118a3a7b350
child 292435 b66c52c296858c0f3fd3f9032eec916be336b795
push id962
push userjlund@mozilla.com
push dateFri, 04 Dec 2015 23:28:54 +0000
treeherdermozilla-release@23a2d286e80f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerssnorp
bugs1194806
milestone43.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 1194806 - part 2 - mark overrides as such in widget/android/; r=snorp
widget/android/AndroidJavaWrappers.h
widget/android/GfxInfo.h
widget/android/nsAppShell.cpp
widget/android/nsAppShell.h
widget/android/nsDeviceContextAndroid.h
widget/android/nsIdleServiceAndroid.h
widget/android/nsScreenManagerAndroid.h
widget/android/nsWindow.cpp
widget/android/nsWindow.h
--- a/widget/android/AndroidJavaWrappers.h
+++ b/widget/android/AndroidJavaWrappers.h
@@ -366,26 +366,26 @@ enum {
     AMETA_META_MASK             = AMETA_META_LEFT_ON  | AMETA_META_RIGHT_ON  | AMETA_META_ON,
     AMETA_SHIFT_MASK            = AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON | AMETA_SHIFT_ON,
 };
 
 class nsAndroidDisplayport final : public nsIAndroidDisplayport
 {
 public:
     NS_DECL_ISUPPORTS
-    virtual nsresult GetLeft(float *aLeft) { *aLeft = mLeft; return NS_OK; }
-    virtual nsresult GetTop(float *aTop) { *aTop = mTop; return NS_OK; }
-    virtual nsresult GetRight(float *aRight) { *aRight = mRight; return NS_OK; }
-    virtual nsresult GetBottom(float *aBottom) { *aBottom = mBottom; return NS_OK; }
-    virtual nsresult GetResolution(float *aResolution) { *aResolution = mResolution; return NS_OK; }
-    virtual nsresult SetLeft(float aLeft) { mLeft = aLeft; return NS_OK; }
-    virtual nsresult SetTop(float aTop) { mTop = aTop; return NS_OK; }
-    virtual nsresult SetRight(float aRight) { mRight = aRight; return NS_OK; }
-    virtual nsresult SetBottom(float aBottom) { mBottom = aBottom; return NS_OK; }
-    virtual nsresult SetResolution(float aResolution) { mResolution = aResolution; return NS_OK; }
+    virtual nsresult GetLeft(float *aLeft) override { *aLeft = mLeft; return NS_OK; }
+    virtual nsresult GetTop(float *aTop) override { *aTop = mTop; return NS_OK; }
+    virtual nsresult GetRight(float *aRight) override { *aRight = mRight; return NS_OK; }
+    virtual nsresult GetBottom(float *aBottom) override { *aBottom = mBottom; return NS_OK; }
+    virtual nsresult GetResolution(float *aResolution) override { *aResolution = mResolution; return NS_OK; }
+    virtual nsresult SetLeft(float aLeft) override { mLeft = aLeft; return NS_OK; }
+    virtual nsresult SetTop(float aTop) override { mTop = aTop; return NS_OK; }
+    virtual nsresult SetRight(float aRight) override { mRight = aRight; return NS_OK; }
+    virtual nsresult SetBottom(float aBottom) override { mBottom = aBottom; return NS_OK; }
+    virtual nsresult SetResolution(float aResolution) override { mResolution = aResolution; return NS_OK; }
 
     nsAndroidDisplayport(AndroidRectF aRect, float aResolution):
         mLeft(aRect.Left()), mTop(aRect.Top()), mRight(aRect.Right()), mBottom(aRect.Bottom()), mResolution(aResolution) {}
 
 private:
     ~nsAndroidDisplayport() {}
     float mLeft, mTop, mRight, mBottom, mResolution;
 };
--- a/widget/android/GfxInfo.h
+++ b/widget/android/GfxInfo.h
@@ -23,63 +23,63 @@ class GfxInfo : public GfxInfoBase
 private:
   ~GfxInfo();
 
 public:
   GfxInfo();
 
   // We only declare the subset of nsIGfxInfo that we actually implement. The
   // rest is brought forward from GfxInfoBase.
-  NS_IMETHOD GetD2DEnabled(bool *aD2DEnabled);
-  NS_IMETHOD GetDWriteEnabled(bool *aDWriteEnabled);
-  NS_IMETHOD GetDWriteVersion(nsAString & aDwriteVersion);
-  NS_IMETHOD GetCleartypeParameters(nsAString & aCleartypeParams);
-  NS_IMETHOD GetAdapterDescription(nsAString & aAdapterDescription);
-  NS_IMETHOD GetAdapterDriver(nsAString & aAdapterDriver);
-  NS_IMETHOD GetAdapterVendorID(nsAString & aAdapterVendorID);
-  NS_IMETHOD GetAdapterDeviceID(nsAString & aAdapterDeviceID);
-  NS_IMETHOD GetAdapterSubsysID(nsAString & aAdapterSubsysID);
-  NS_IMETHOD GetAdapterRAM(nsAString & aAdapterRAM);
-  NS_IMETHOD GetAdapterDriverVersion(nsAString & aAdapterDriverVersion);
-  NS_IMETHOD GetAdapterDriverDate(nsAString & aAdapterDriverDate);
-  NS_IMETHOD GetAdapterDescription2(nsAString & aAdapterDescription);
-  NS_IMETHOD GetAdapterDriver2(nsAString & aAdapterDriver);
-  NS_IMETHOD GetAdapterVendorID2(nsAString & aAdapterVendorID);
-  NS_IMETHOD GetAdapterDeviceID2(nsAString & aAdapterDeviceID);
-  NS_IMETHOD GetAdapterSubsysID2(nsAString & aAdapterSubsysID);
-  NS_IMETHOD GetAdapterRAM2(nsAString & aAdapterRAM);
-  NS_IMETHOD GetAdapterDriverVersion2(nsAString & aAdapterDriverVersion);
-  NS_IMETHOD GetAdapterDriverDate2(nsAString & aAdapterDriverDate);
-  NS_IMETHOD GetIsGPU2Active(bool *aIsGPU2Active);
+  NS_IMETHOD GetD2DEnabled(bool *aD2DEnabled) override;
+  NS_IMETHOD GetDWriteEnabled(bool *aDWriteEnabled) override;
+  NS_IMETHOD GetDWriteVersion(nsAString & aDwriteVersion) override;
+  NS_IMETHOD GetCleartypeParameters(nsAString & aCleartypeParams) override;
+  NS_IMETHOD GetAdapterDescription(nsAString & aAdapterDescription) override;
+  NS_IMETHOD GetAdapterDriver(nsAString & aAdapterDriver) override;
+  NS_IMETHOD GetAdapterVendorID(nsAString & aAdapterVendorID) override;
+  NS_IMETHOD GetAdapterDeviceID(nsAString & aAdapterDeviceID) override;
+  NS_IMETHOD GetAdapterSubsysID(nsAString & aAdapterSubsysID) override;
+  NS_IMETHOD GetAdapterRAM(nsAString & aAdapterRAM) override;
+  NS_IMETHOD GetAdapterDriverVersion(nsAString & aAdapterDriverVersion) override;
+  NS_IMETHOD GetAdapterDriverDate(nsAString & aAdapterDriverDate) override;
+  NS_IMETHOD GetAdapterDescription2(nsAString & aAdapterDescription) override;
+  NS_IMETHOD GetAdapterDriver2(nsAString & aAdapterDriver) override;
+  NS_IMETHOD GetAdapterVendorID2(nsAString & aAdapterVendorID) override;
+  NS_IMETHOD GetAdapterDeviceID2(nsAString & aAdapterDeviceID) override;
+  NS_IMETHOD GetAdapterSubsysID2(nsAString & aAdapterSubsysID) override;
+  NS_IMETHOD GetAdapterRAM2(nsAString & aAdapterRAM) override;
+  NS_IMETHOD GetAdapterDriverVersion2(nsAString & aAdapterDriverVersion) override;
+  NS_IMETHOD GetAdapterDriverDate2(nsAString & aAdapterDriverDate) override;
+  NS_IMETHOD GetIsGPU2Active(bool *aIsGPU2Active) override;
   using GfxInfoBase::GetFeatureStatus;
   using GfxInfoBase::GetFeatureSuggestedDriverVersion;
   using GfxInfoBase::GetWebGLParameter;
 
   void EnsureInitialized();
 
-  virtual nsString Model();
-  virtual nsString Hardware();
-  virtual nsString Product();
-  virtual nsString Manufacturer();
+  virtual nsString Model() override;
+  virtual nsString Hardware() override;
+  virtual nsString Product() override;
+  virtual nsString Manufacturer() override;
 
 #ifdef DEBUG
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIGFXINFODEBUG
 #endif
 
   virtual uint32_t OperatingSystemVersion() override;
 
 protected:
 
   virtual nsresult GetFeatureStatusImpl(int32_t aFeature, 
                                         int32_t *aStatus, 
                                         nsAString & aSuggestedDriverVersion, 
                                         const nsTArray<GfxDriverInfo>& aDriverInfo,
-                                        OperatingSystem* aOS = nullptr);
-  virtual const nsTArray<GfxDriverInfo>& GetGfxDriverInfo();
+                                        OperatingSystem* aOS = nullptr) override;
+  virtual const nsTArray<GfxDriverInfo>& GetGfxDriverInfo() override;
 
 private:
 
   void AddCrashReportAnnotations();
 
   bool mInitialized;
 
   class GLStrings;
--- a/widget/android/nsAppShell.cpp
+++ b/widget/android/nsAppShell.cpp
@@ -113,17 +113,17 @@ private:
 
 class WakeLockListener final : public nsIDOMMozWakeLockListener {
 private:
   ~WakeLockListener() {}
 
 public:
   NS_DECL_ISUPPORTS;
 
-  nsresult Callback(const nsAString& topic, const nsAString& state) {
+  nsresult Callback(const nsAString& topic, const nsAString& state) override {
     widget::GeckoAppShell::NotifyWakeLockChanged(topic, state);
     return NS_OK;
   }
 };
 
 NS_IMPL_ISUPPORTS(WakeLockListener, nsIDOMMozWakeLockListener)
 nsCOMPtr<nsIPowerManagerService> sPowerManagerService = nullptr;
 StaticRefPtr<WakeLockListener> sWakeLockListener;
--- a/widget/android/nsAppShell.h
+++ b/widget/android/nsAppShell.h
@@ -36,34 +36,34 @@ public:
 
     NS_DECL_ISUPPORTS_INHERITED
     NS_DECL_NSIOBSERVER
 
     nsresult Init();
 
     void NotifyNativeEvent();
 
-    virtual bool ProcessNextNativeEvent(bool mayWait);
+    virtual bool ProcessNextNativeEvent(bool mayWait) override;
 
     void PostEvent(mozilla::AndroidGeckoEvent *event);
     void OnResume();
 
     nsresult AddObserver(const nsAString &aObserverKey, nsIObserver *aObserver);
     void ResendLastResizeEvent(nsWindow* aDest);
 
     void SetBrowserApp(nsIAndroidBrowserApp* aBrowserApp) {
         mBrowserApp = aBrowserApp;
     }
 
     void GetBrowserApp(nsIAndroidBrowserApp* *aBrowserApp) {
         *aBrowserApp = mBrowserApp;
     }
 
 protected:
-    virtual void ScheduleNativeEventCallback();
+    virtual void ScheduleNativeEventCallback() override;
     virtual ~nsAppShell();
 
     Mutex mQueueLock;
     Mutex mCondLock;
     CondVar mQueueCond;
     mozilla::AndroidGeckoEvent *mQueuedViewportEvent;
     bool mAllowCoalescingTouches;
     nsTArray<mozilla::AndroidGeckoEvent *> mEventQueue;
--- a/widget/android/nsDeviceContextAndroid.h
+++ b/widget/android/nsDeviceContextAndroid.h
@@ -8,25 +8,25 @@
 class nsDeviceContextSpecAndroid final : public nsIDeviceContextSpec
 {
 private:
     ~nsDeviceContextSpecAndroid() {}
 
 public:
     NS_DECL_ISUPPORTS
 
-    NS_IMETHOD GetSurfaceForPrinter(gfxASurface** surface);
+    NS_IMETHOD GetSurfaceForPrinter(gfxASurface** surface) override;
 
     NS_IMETHOD Init(nsIWidget* aWidget,
                     nsIPrintSettings* aPS,
-                    bool aIsPrintPreview);
+                    bool aIsPrintPreview) override;
     NS_IMETHOD BeginDocument(const nsAString& aTitle,
                              char16_t* aPrintToFileName,
                              int32_t aStartPage,
-                             int32_t aEndPage);
-    NS_IMETHOD EndDocument();
-    NS_IMETHOD BeginPage() { return NS_OK; }
-    NS_IMETHOD EndPage() { return NS_OK; }
+                             int32_t aEndPage) override;
+    NS_IMETHOD EndDocument() override;
+    NS_IMETHOD BeginPage() override { return NS_OK; }
+    NS_IMETHOD EndPage() override { return NS_OK; }
 
 private:
     nsCOMPtr<nsIPrintSettings> mPrintSettings;
     nsCOMPtr<nsIFile> mTempFile;
 };
--- a/widget/android/nsIdleServiceAndroid.h
+++ b/widget/android/nsIdleServiceAndroid.h
@@ -10,27 +10,27 @@
 
 #include "nsIdleService.h"
 
 class nsIdleServiceAndroid : public nsIdleService
 {
 public:
     NS_DECL_ISUPPORTS_INHERITED
 
-    bool PollIdleTime(uint32_t* aIdleTime);
+    bool PollIdleTime(uint32_t* aIdleTime) override;
 
     static already_AddRefed<nsIdleServiceAndroid> GetInstance() 
     {
         nsRefPtr<nsIdleService> idleService = nsIdleService::GetInstance();
         if (!idleService) {
             idleService = new nsIdleServiceAndroid();
         }
         
         return idleService.forget().downcast<nsIdleServiceAndroid>();
     }
 
 protected:
     nsIdleServiceAndroid() { }
     virtual ~nsIdleServiceAndroid() { }
-    bool UsePollMode();
+    bool UsePollMode() override;
 };
 
 #endif // nsIdleServiceAndroid_h__
--- a/widget/android/nsScreenManagerAndroid.h
+++ b/widget/android/nsScreenManagerAndroid.h
@@ -13,21 +13,21 @@
 #include "WidgetUtils.h"
 
 class nsScreenAndroid final : public nsBaseScreen
 {
 public:
     nsScreenAndroid(void *nativeScreen);
     ~nsScreenAndroid();
 
-    NS_IMETHOD GetId(uint32_t* aId);
-    NS_IMETHOD GetRect(int32_t* aLeft, int32_t* aTop, int32_t* aWidth, int32_t* aHeight);
-    NS_IMETHOD GetAvailRect(int32_t* aLeft, int32_t* aTop, int32_t* aWidth, int32_t* aHeight);
-    NS_IMETHOD GetPixelDepth(int32_t* aPixelDepth);
-    NS_IMETHOD GetColorDepth(int32_t* aColorDepth);
+    NS_IMETHOD GetId(uint32_t* aId) override;
+    NS_IMETHOD GetRect(int32_t* aLeft, int32_t* aTop, int32_t* aWidth, int32_t* aHeight) override;
+    NS_IMETHOD GetAvailRect(int32_t* aLeft, int32_t* aTop, int32_t* aWidth, int32_t* aHeight) override;
+    NS_IMETHOD GetPixelDepth(int32_t* aPixelDepth) override;
+    NS_IMETHOD GetColorDepth(int32_t* aColorDepth) override;
 
 protected:
     virtual void ApplyMinimumBrightness(uint32_t aBrightness) override;
 };
 
 class nsScreenManagerAndroid final : public nsIScreenManager
 {
 private:
--- a/widget/android/nsWindow.cpp
+++ b/widget/android/nsWindow.cpp
@@ -93,17 +93,17 @@ class ContentCreationNotifier final : pu
 private:
     ~ContentCreationNotifier() {}
 
 public:
     NS_DECL_ISUPPORTS
 
     NS_IMETHOD Observe(nsISupports* aSubject,
                        const char* aTopic,
-                       const char16_t* aData)
+                       const char16_t* aData) override
     {
         if (!strcmp(aTopic, "ipc:content-created")) {
             nsCOMPtr<nsIObserver> cpo = do_QueryInterface(aSubject);
             ContentParent* cp = static_cast<ContentParent*>(cpo.get());
             unused << cp->SendScreenSizeChanged(gAndroidScreenBounds);
         } else if (!strcmp(aTopic, "xpcom-shutdown")) {
             nsCOMPtr<nsIObserverService> obs =
                 mozilla::services::GetObserverService();
--- a/widget/android/nsWindow.h
+++ b/widget/android/nsWindow.h
@@ -61,98 +61,98 @@ public:
 
     //
     // nsIWidget
     //
 
     NS_IMETHOD Create(nsIWidget *aParent,
                       nsNativeWidget aNativeParent,
                       const nsIntRect &aRect,
-                      nsWidgetInitData *aInitData);
-    NS_IMETHOD Destroy(void);
-    NS_IMETHOD ConfigureChildren(const nsTArray<nsIWidget::Configuration>&);
-    NS_IMETHOD SetParent(nsIWidget* aNewParent);
-    virtual nsIWidget *GetParent(void);
-    virtual float GetDPI();
-    virtual double GetDefaultScaleInternal();
-    NS_IMETHOD Show(bool aState);
-    NS_IMETHOD SetModal(bool aModal);
-    virtual bool IsVisible() const;
+                      nsWidgetInitData *aInitData) override;
+    NS_IMETHOD Destroy(void) override;
+    NS_IMETHOD ConfigureChildren(const nsTArray<nsIWidget::Configuration>&) override;
+    NS_IMETHOD SetParent(nsIWidget* aNewParent) override;
+    virtual nsIWidget *GetParent(void) override;
+    virtual float GetDPI() override;
+    virtual double GetDefaultScaleInternal() override;
+    NS_IMETHOD Show(bool aState) override;
+    NS_IMETHOD SetModal(bool aModal) override;
+    virtual bool IsVisible() const override;
     NS_IMETHOD ConstrainPosition(bool aAllowSlop,
                                  int32_t *aX,
-                                 int32_t *aY);
+                                 int32_t *aY) override;
     NS_IMETHOD Move(double aX,
-                    double aY);
+                    double aY) override;
     NS_IMETHOD Resize(double aWidth,
                       double aHeight,
-                      bool   aRepaint);
+                      bool   aRepaint) override;
     NS_IMETHOD Resize(double aX,
                       double aY,
                       double aWidth,
                       double aHeight,
-                      bool aRepaint);
-    void SetZIndex(int32_t aZIndex);
+                      bool aRepaint) override;
+    void SetZIndex(int32_t aZIndex) override;
     NS_IMETHOD PlaceBehind(nsTopLevelWidgetZPlacement aPlacement,
                            nsIWidget *aWidget,
-                           bool aActivate);
-    NS_IMETHOD SetSizeMode(int32_t aMode);
-    NS_IMETHOD Enable(bool aState);
-    virtual bool IsEnabled() const;
-    NS_IMETHOD Invalidate(const nsIntRect &aRect);
-    NS_IMETHOD SetFocus(bool aRaise = false);
-    NS_IMETHOD GetScreenBounds(nsIntRect &aRect);
-    virtual mozilla::LayoutDeviceIntPoint WidgetToScreenOffset();
+                           bool aActivate) override;
+    NS_IMETHOD SetSizeMode(int32_t aMode) override;
+    NS_IMETHOD Enable(bool aState) override;
+    virtual bool IsEnabled() const override;
+    NS_IMETHOD Invalidate(const nsIntRect &aRect) override;
+    NS_IMETHOD SetFocus(bool aRaise = false) override;
+    NS_IMETHOD GetScreenBounds(nsIntRect &aRect) override;
+    virtual mozilla::LayoutDeviceIntPoint WidgetToScreenOffset() override;
     NS_IMETHOD DispatchEvent(mozilla::WidgetGUIEvent* aEvent,
-                             nsEventStatus& aStatus);
+                             nsEventStatus& aStatus) override;
     nsEventStatus DispatchEvent(mozilla::WidgetGUIEvent* aEvent);
-    NS_IMETHOD MakeFullScreen(bool aFullScreen, nsIScreen* aTargetScreen = nullptr);
-    NS_IMETHOD SetWindowClass(const nsAString& xulWinType);
+    NS_IMETHOD MakeFullScreen(bool aFullScreen, nsIScreen* aTargetScreen = nullptr) override;
+    NS_IMETHOD SetWindowClass(const nsAString& xulWinType) override;
 
 
 
-    NS_IMETHOD SetCursor(nsCursor aCursor) { return NS_ERROR_NOT_IMPLEMENTED; }
+    NS_IMETHOD SetCursor(nsCursor aCursor) override { return NS_ERROR_NOT_IMPLEMENTED; }
     NS_IMETHOD SetCursor(imgIContainer* aCursor,
                          uint32_t aHotspotX,
-                         uint32_t aHotspotY) { return NS_ERROR_NOT_IMPLEMENTED; }
+                         uint32_t aHotspotY) override { return NS_ERROR_NOT_IMPLEMENTED; }
     NS_IMETHOD SetHasTransparentBackground(bool aTransparent) { return NS_OK; }
     NS_IMETHOD GetHasTransparentBackground(bool& aTransparent) { aTransparent = false; return NS_OK; }
-    NS_IMETHOD HideWindowChrome(bool aShouldHide) { return NS_ERROR_NOT_IMPLEMENTED; }
-    virtual void* GetNativeData(uint32_t aDataType);
-    NS_IMETHOD SetTitle(const nsAString& aTitle) { return NS_OK; }
-    NS_IMETHOD SetIcon(const nsAString& aIconSpec) { return NS_OK; }
-    NS_IMETHOD EnableDragDrop(bool aEnable) { return NS_OK; }
-    NS_IMETHOD CaptureMouse(bool aCapture) { return NS_ERROR_NOT_IMPLEMENTED; }
+    NS_IMETHOD HideWindowChrome(bool aShouldHide) override { return NS_ERROR_NOT_IMPLEMENTED; }
+    virtual void* GetNativeData(uint32_t aDataType) override;
+    NS_IMETHOD SetTitle(const nsAString& aTitle) override { return NS_OK; }
+    NS_IMETHOD SetIcon(const nsAString& aIconSpec) override { return NS_OK; }
+    NS_IMETHOD EnableDragDrop(bool aEnable) override { return NS_OK; }
+    NS_IMETHOD CaptureMouse(bool aCapture) override { return NS_ERROR_NOT_IMPLEMENTED; }
     NS_IMETHOD CaptureRollupEvents(nsIRollupListener *aListener,
-                                   bool aDoCapture) { return NS_ERROR_NOT_IMPLEMENTED; }
+                                   bool aDoCapture) override { return NS_ERROR_NOT_IMPLEMENTED; }
 
-    NS_IMETHOD GetAttention(int32_t aCycleCount) { return NS_ERROR_NOT_IMPLEMENTED; }
+    NS_IMETHOD GetAttention(int32_t aCycleCount) override { return NS_ERROR_NOT_IMPLEMENTED; }
     NS_IMETHOD BeginResizeDrag(mozilla::WidgetGUIEvent* aEvent,
                                int32_t aHorizontal,
-                               int32_t aVertical)
+                               int32_t aVertical) override
     {
         return NS_ERROR_NOT_IMPLEMENTED;
     }
 
     NS_IMETHOD_(void) SetInputContext(const InputContext& aContext,
-                                      const InputContextAction& aAction);
-    NS_IMETHOD_(InputContext) GetInputContext();
+                                      const InputContextAction& aAction) override;
+    NS_IMETHOD_(InputContext) GetInputContext() override;
 
     nsresult NotifyIMEOfTextChange(const IMENotification& aIMENotification);
-    virtual nsIMEUpdatePreference GetIMEUpdatePreference();
+    virtual nsIMEUpdatePreference GetIMEUpdatePreference() override;
 
     LayerManager* GetLayerManager (PLayerTransactionChild* aShadowManager = nullptr,
                                    LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
                                    LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT,
-                                   bool* aAllowRetaining = nullptr);
+                                   bool* aAllowRetaining = nullptr) override;
 
-    NS_IMETHOD ReparentNativeWidget(nsIWidget* aNewParent);
+    NS_IMETHOD ReparentNativeWidget(nsIWidget* aNewParent) override;
 
-    virtual bool NeedsPaint();
-    virtual void DrawWindowUnderlay(LayerManagerComposite* aManager, nsIntRect aRect);
-    virtual void DrawWindowOverlay(LayerManagerComposite* aManager, nsIntRect aRect);
+    virtual bool NeedsPaint() override;
+    virtual void DrawWindowUnderlay(LayerManagerComposite* aManager, nsIntRect aRect) override;
+    virtual void DrawWindowOverlay(LayerManagerComposite* aManager, nsIntRect aRect) override;
 
     virtual mozilla::layers::CompositorParent* NewCompositorParent(int aSurfaceWidth, int aSurfaceHeight) override;
 
     static void SetCompositor(mozilla::layers::LayerManager* aLayerManager,
                               mozilla::layers::CompositorParent* aCompositorParent,
                               mozilla::layers::CompositorChild* aCompositorChild);
     static bool IsCompositionPaused();
     static void InvalidateAndScheduleComposite();
@@ -160,17 +160,17 @@ public:
     static void ScheduleResumeComposition();
     static void ScheduleResumeComposition(int width, int height);
     static void ForceIsFirstPaint();
     static float ComputeRenderIntegrity();
     static mozilla::layers::APZCTreeManager* GetAPZCTreeManager();
     /* RootLayerTreeId() can only be called when GetAPZCTreeManager() returns non-null */
     static uint64_t RootLayerTreeId();
 
-    virtual bool WidgetPaintsBackground();
+    virtual bool WidgetPaintsBackground() override;
 
     virtual uint32_t GetMaxTouchPoints() const override;
 
 protected:
     void BringToFront();
     nsWindow *FindTopLevel();
     bool IsTopLevel();