Bug 1123844: Add MOZ_OVERRIDE annotations (and a few 'virtual' annotations) where appropriate, for headers used in widget/gtk. r=karlt
authorDaniel Holbert <dholbert@cs.stanford.edu>
Tue, 20 Jan 2015 11:52:56 -0800
changeset 361345 ff95162a9930a9a0d8ed832a26780d90c41acf35
parent 361344 1a2d140c416e2a415a0f1a37e4fc756f00147da7
child 361346 50dec32593c7aef81e3e02e5c0399b2c38f1c8c6
push id49926
push userdholbert@mozilla.com
push dateTue, 20 Jan 2015 19:53:47 +0000
treeherdertry@50dec32593c7 [default view] [failures only]
reviewerskarlt
bugs1123844
milestone38.0a1
Bug 1123844: Add MOZ_OVERRIDE annotations (and a few 'virtual' annotations) where appropriate, for headers used in widget/gtk. r=karlt
gfx/thebes/gfxPlatformGtk.h
gfx/thebes/gfxXlibSurface.h
widget/GfxInfoX11.h
widget/gtk/WakeLockListener.h
widget/gtk/nsDeviceContextSpecG.h
widget/gtk/nsDragService.h
widget/gtk/nsFilePicker.h
widget/gtk/nsIdleServiceGTK.h
widget/gtk/nsImageToPixbuf.h
widget/gtk/nsNativeThemeGTK.h
widget/gtk/nsPrintDialogGTK.h
widget/gtk/nsPrintSettingsGTK.h
widget/gtk/nsWindow.h
--- a/gfx/thebes/gfxPlatformGtk.h
+++ b/gfx/thebes/gfxPlatformGtk.h
@@ -27,57 +27,58 @@ public:
     static gfxPlatformGtk *GetPlatform() {
         return (gfxPlatformGtk*) gfxPlatform::GetPlatform();
     }
 
     virtual already_AddRefed<gfxASurface>
       CreateOffscreenSurface(const IntSize& size,
                              gfxContentType contentType) MOZ_OVERRIDE;
 
-    mozilla::TemporaryRef<mozilla::gfx::ScaledFont>
-      GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont);
+    virtual mozilla::TemporaryRef<mozilla::gfx::ScaledFont>
+      GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont) MOZ_OVERRIDE;
 
-    nsresult GetFontList(nsIAtom *aLangGroup,
-                         const nsACString& aGenericFamily,
-                         nsTArray<nsString>& aListOfFonts);
+    virtual nsresult GetFontList(nsIAtom *aLangGroup,
+                                 const nsACString& aGenericFamily,
+                                 nsTArray<nsString>& aListOfFonts) MOZ_OVERRIDE;
 
-    nsresult UpdateFontList();
-
-    nsresult GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName);
+    virtual nsresult UpdateFontList() MOZ_OVERRIDE;
 
-    gfxFontGroup *CreateFontGroup(const mozilla::FontFamilyList& aFontFamilyList,
-                                  const gfxFontStyle *aStyle,
-                                  gfxUserFontSet *aUserFontSet);
+    virtual nsresult GetStandardFamilyName(const nsAString& aFontName,
+                                           nsAString& aFamilyName) MOZ_OVERRIDE;
+
+    virtual gfxFontGroup* CreateFontGroup(const mozilla::FontFamilyList& aFontFamilyList,
+                                          const gfxFontStyle *aStyle,
+                                          gfxUserFontSet *aUserFontSet) MOZ_OVERRIDE;
 
     /**
      * Look up a local platform font using the full font face name (needed to
      * support @font-face src local() )
      */
     virtual gfxFontEntry* LookupLocalFont(const nsAString& aFontName,
                                           uint16_t aWeight,
                                           int16_t aStretch,
-                                          bool aItalic);
+                                          bool aItalic) MOZ_OVERRIDE;
 
     /**
      * Activate a platform font (needed to support @font-face src url() )
      *
      */
     virtual gfxFontEntry* MakePlatformFont(const nsAString& aFontName,
                                            uint16_t aWeight,
                                            int16_t aStretch,
                                            bool aItalic,
                                            const uint8_t* aFontData,
-                                           uint32_t aLength);
+                                           uint32_t aLength) MOZ_OVERRIDE;
 
     /**
      * Check whether format is supported on a platform or not (if unclear,
      * returns true).
      */
     virtual bool IsFontFormatSupported(nsIURI *aFontURI,
-                                         uint32_t aFormatFlags);
+                                         uint32_t aFormatFlags) MOZ_OVERRIDE;
 
 #if (MOZ_WIDGET_GTK == 2)
     static void SetGdkDrawable(cairo_surface_t *target,
                                GdkDrawable *drawable);
     static GdkDrawable *GetGdkDrawable(cairo_surface_t *target);
 #endif
 
     static int32_t GetDPI();
@@ -99,24 +100,25 @@ public:
         // since GTK2 theme rendering still requires xlib surfaces per se.
 #if (MOZ_WIDGET_GTK == 3)
         return gfxPrefs::UseImageOffscreenSurfaces();
 #else
         return false;
 #endif
     }
 
-    virtual gfxImageFormat GetOffscreenFormat();
+    virtual gfxImageFormat GetOffscreenFormat() MOZ_OVERRIDE;
 
-    virtual int GetScreenDepth() const;
+    virtual int GetScreenDepth() const MOZ_OVERRIDE;
 
 protected:
     static gfxFontconfigUtils *sFontconfigUtils;
 
 private:
-    virtual void GetPlatformCMSOutputProfile(void *&mem, size_t &size);
+    virtual void GetPlatformCMSOutputProfile(void *&mem,
+                                             size_t &size) MOZ_OVERRIDE;
 
 #ifdef MOZ_X11
     static bool sUseXRender;
 #endif
 };
 
 #endif /* GFX_PLATFORM_GTK_H */
--- a/gfx/thebes/gfxXlibSurface.h
+++ b/gfx/thebes/gfxXlibSurface.h
@@ -46,20 +46,21 @@ public:
                        Drawable relatedDrawable = None);
     static already_AddRefed<gfxXlibSurface>
     Create(Screen* screen, XRenderPictFormat *format, const gfxIntSize& size,
            Drawable relatedDrawable = None);
 
     virtual ~gfxXlibSurface();
 
     virtual already_AddRefed<gfxASurface>
-    CreateSimilarSurface(gfxContentType aType, const gfxIntSize& aSize);
+    CreateSimilarSurface(gfxContentType aType,
+                         const gfxIntSize& aSize) MOZ_OVERRIDE;
     virtual void Finish() MOZ_OVERRIDE;
 
-    virtual const gfxIntSize GetSize() const;
+    virtual const gfxIntSize GetSize() const MOZ_OVERRIDE;
 
     Display* XDisplay() { return mDisplay; }
     Screen* XScreen();
     Drawable XDrawable() { return mDrawable; }
     XRenderPictFormat* XRenderFormat();
 
     static int DepthOfVisual(const Screen* screen, const Visual* visual);
     static Visual* FindVisual(Screen* screen, gfxImageFormat format);
@@ -75,17 +76,17 @@ public:
     // on those created by a Create() factory method.
     Drawable ReleasePixmap();
 
     // Find a visual and colormap pair suitable for rendering to this surface.
     bool GetColormapAndVisual(Colormap* colormap, Visual **visual);
 
     // This surface is a wrapper around X pixmaps, which are stored in the X
     // server, not the main application.
-    virtual gfxMemoryLocation GetMemoryLocation() const;
+    virtual gfxMemoryLocation GetMemoryLocation() const MOZ_OVERRIDE;
 
 #if defined(GL_PROVIDER_GLX)
     GLXPixmap GetGLXPixmap();
 #endif
 
     // Return true if cairo will take its slow path when this surface is used
     // in a pattern with EXTEND_PAD.  As a workaround for XRender's RepeatPad
     // not being implemented correctly on old X servers, cairo avoids XRender
--- a/widget/GfxInfoX11.h
+++ b/widget/GfxInfoX11.h
@@ -14,59 +14,59 @@ namespace mozilla {
 namespace widget {
 
 class GfxInfo MOZ_FINAL : public GfxInfoBase
 {
 public:
 
   // 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) MOZ_OVERRIDE;
+  NS_IMETHOD GetDWriteEnabled(bool *aDWriteEnabled) MOZ_OVERRIDE;
+  NS_IMETHOD GetDWriteVersion(nsAString & aDwriteVersion) MOZ_OVERRIDE;
+  NS_IMETHOD GetCleartypeParameters(nsAString & aCleartypeParams) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDescription(nsAString & aAdapterDescription) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDriver(nsAString & aAdapterDriver) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterVendorID(nsAString & aAdapterVendorID) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDeviceID(nsAString & aAdapterDeviceID) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterSubsysID(nsAString & aAdapterSubsysID) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterRAM(nsAString & aAdapterRAM) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDriverVersion(nsAString & aAdapterDriverVersion) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDriverDate(nsAString & aAdapterDriverDate) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDescription2(nsAString & aAdapterDescription) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDriver2(nsAString & aAdapterDriver) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterVendorID2(nsAString & aAdapterVendorID) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDeviceID2(nsAString & aAdapterDeviceID) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterSubsysID2(nsAString & aAdapterSubsysID) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterRAM2(nsAString & aAdapterRAM) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDriverVersion2(nsAString & aAdapterDriverVersion) MOZ_OVERRIDE;
+  NS_IMETHOD GetAdapterDriverDate2(nsAString & aAdapterDriverDate) MOZ_OVERRIDE;
+  NS_IMETHOD GetIsGPU2Active(bool *aIsGPU2Active) MOZ_OVERRIDE;
   using GfxInfoBase::GetFeatureStatus;
   using GfxInfoBase::GetFeatureSuggestedDriverVersion;
   using GfxInfoBase::GetWebGLParameter;
 
-  virtual nsresult Init();
+  virtual nsresult Init() MOZ_OVERRIDE;
   
-  NS_IMETHOD_(void) GetData();
+  NS_IMETHOD_(void) GetData() MOZ_OVERRIDE;
 
 #ifdef DEBUG
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIGFXINFODEBUG
 #endif
 
 protected:
   ~GfxInfo() {}
 
   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) MOZ_OVERRIDE;
+  virtual const nsTArray<GfxDriverInfo>& GetGfxDriverInfo() MOZ_OVERRIDE;
 
 private:
   nsCString mVendor;
   nsCString mRenderer;
   nsCString mVersion;
   nsCString mAdapterDescription;
   nsCString mOS;
   nsCString mOSRelease;
--- a/widget/gtk/WakeLockListener.h
+++ b/widget/gtk/WakeLockListener.h
@@ -25,17 +25,18 @@ class WakeLockTopic;
 class WakeLockListener MOZ_FINAL : public nsIDOMMozWakeLockListener
 {
 public:
   NS_DECL_ISUPPORTS;
 
   static WakeLockListener* GetSingleton(bool aCreate = true);
   static void Shutdown();
 
-  nsresult Callback(const nsAString& topic, const nsAString& state);
+  virtual nsresult Callback(const nsAString& topic,
+                            const nsAString& state) MOZ_OVERRIDE;
 
 private:
   WakeLockListener();
   ~WakeLockListener();
 
   static WakeLockListener* sSingleton;
 
   DBusConnection* mConnection;
--- a/widget/gtk/nsDeviceContextSpecG.h
+++ b/widget/gtk/nsDeviceContextSpecG.h
@@ -29,23 +29,25 @@ typedef enum
 
 class nsDeviceContextSpecGTK : public nsIDeviceContextSpec
 {
 public:
   nsDeviceContextSpecGTK();
 
   NS_DECL_ISUPPORTS
 
-  NS_IMETHOD GetSurfaceForPrinter(gfxASurface **surface);
+  NS_IMETHOD GetSurfaceForPrinter(gfxASurface **surface) MOZ_OVERRIDE;
 
-  NS_IMETHOD Init(nsIWidget *aWidget, nsIPrintSettings* aPS, bool aIsPrintPreview);
-  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; }
+  NS_IMETHOD Init(nsIWidget *aWidget, nsIPrintSettings* aPS,
+                  bool aIsPrintPreview) MOZ_OVERRIDE;
+  NS_IMETHOD BeginDocument(const nsAString& aTitle, char16_t * aPrintToFileName,
+                           int32_t aStartPage, int32_t aEndPage) MOZ_OVERRIDE;
+  NS_IMETHOD EndDocument() MOZ_OVERRIDE;
+  NS_IMETHOD BeginPage() MOZ_OVERRIDE { return NS_OK; }
+  NS_IMETHOD EndPage() MOZ_OVERRIDE { return NS_OK; }
 
   static nsresult GetPrintMethod(const char *aPrinter, PrintMethod &aMethod);
   
 protected:
   virtual ~nsDeviceContextSpecGTK();
   nsCOMPtr<nsIPrintSettings> mPrintSettings;
   bool mToPrinter : 1;      /* If true, print to printer */
   bool mIsPPreview : 1;     /* If true, is print preview */
--- a/widget/gtk/nsDragService.h
+++ b/widget/gtk/nsDragService.h
@@ -57,27 +57,28 @@ public:
     NS_DECL_ISUPPORTS_INHERITED
 
     NS_DECL_NSIOBSERVER
 
     // nsIDragService
     NS_IMETHOD InvokeDragSession (nsIDOMNode *aDOMNode,
                                   nsISupportsArray * anArrayTransferables,
                                   nsIScriptableRegion * aRegion,
-                                  uint32_t aActionType);
-    NS_IMETHOD StartDragSession();
-    NS_IMETHOD EndDragSession(bool aDoneDrag);
+                                  uint32_t aActionType) MOZ_OVERRIDE;
+    NS_IMETHOD StartDragSession() MOZ_OVERRIDE;
+    NS_IMETHOD EndDragSession(bool aDoneDrag) MOZ_OVERRIDE;
 
     // nsIDragSession
-    NS_IMETHOD SetCanDrop            (bool             aCanDrop);
-    NS_IMETHOD GetCanDrop            (bool            *aCanDrop);
-    NS_IMETHOD GetNumDropItems       (uint32_t * aNumItems);
+    NS_IMETHOD SetCanDrop            (bool             aCanDrop) MOZ_OVERRIDE;
+    NS_IMETHOD GetCanDrop            (bool            *aCanDrop) MOZ_OVERRIDE;
+    NS_IMETHOD GetNumDropItems       (uint32_t * aNumItems) MOZ_OVERRIDE;
     NS_IMETHOD GetData               (nsITransferable * aTransferable,
-                                      uint32_t aItemIndex);
-    NS_IMETHOD IsDataFlavorSupported (const char *aDataFlavor, bool *_retval);
+                                      uint32_t aItemIndex) MOZ_OVERRIDE;
+    NS_IMETHOD IsDataFlavorSupported (const char *aDataFlavor,
+                                      bool *_retval) MOZ_OVERRIDE;
 
     // Methods called from nsWindow to handle responding to GTK drag
     // destination signals
 
     static nsDragService* GetInstance();
 
     void TargetDataReceived          (GtkWidget         *aWidget,
                                       GdkDragContext    *aContext,
--- a/widget/gtk/nsFilePicker.h
+++ b/widget/gtk/nsFilePicker.h
@@ -19,32 +19,34 @@ class nsIFile;
 class nsFilePicker : public nsBaseFilePicker
 {
 public:
   nsFilePicker();
 
   NS_DECL_ISUPPORTS
 
   // nsIFilePicker (less what's in nsBaseFilePicker)
-  NS_IMETHOD Open(nsIFilePickerShownCallback *aCallback);
-  NS_IMETHODIMP AppendFilters(int32_t aFilterMask);
-  NS_IMETHODIMP AppendFilter(const nsAString& aTitle, const nsAString& aFilter);
-  NS_IMETHODIMP SetDefaultString(const nsAString& aString);
-  NS_IMETHODIMP GetDefaultString(nsAString& aString);
-  NS_IMETHODIMP SetDefaultExtension(const nsAString& aExtension);
-  NS_IMETHODIMP GetDefaultExtension(nsAString& aExtension);
-  NS_IMETHODIMP GetFilterIndex(int32_t *aFilterIndex);
-  NS_IMETHODIMP SetFilterIndex(int32_t aFilterIndex);
-  NS_IMETHODIMP GetFile(nsIFile **aFile);
-  NS_IMETHODIMP GetFileURL(nsIURI **aFileURL);
-  NS_IMETHODIMP GetFiles(nsISimpleEnumerator **aFiles);
-  NS_IMETHODIMP Show(int16_t *aReturn);
+  NS_IMETHOD Open(nsIFilePickerShownCallback *aCallback) MOZ_OVERRIDE;
+  NS_IMETHODIMP AppendFilters(int32_t aFilterMask) MOZ_OVERRIDE;
+  NS_IMETHODIMP AppendFilter(const nsAString& aTitle,
+                             const nsAString& aFilter) MOZ_OVERRIDE;
+  NS_IMETHODIMP SetDefaultString(const nsAString& aString) MOZ_OVERRIDE;
+  NS_IMETHODIMP GetDefaultString(nsAString& aString) MOZ_OVERRIDE;
+  NS_IMETHODIMP SetDefaultExtension(const nsAString& aExtension) MOZ_OVERRIDE;
+  NS_IMETHODIMP GetDefaultExtension(nsAString& aExtension) MOZ_OVERRIDE;
+  NS_IMETHODIMP GetFilterIndex(int32_t *aFilterIndex) MOZ_OVERRIDE;
+  NS_IMETHODIMP SetFilterIndex(int32_t aFilterIndex) MOZ_OVERRIDE;
+  NS_IMETHODIMP GetFile(nsIFile **aFile) MOZ_OVERRIDE;
+  NS_IMETHODIMP GetFileURL(nsIURI **aFileURL) MOZ_OVERRIDE;
+  NS_IMETHODIMP GetFiles(nsISimpleEnumerator **aFiles) MOZ_OVERRIDE;
+  NS_IMETHODIMP Show(int16_t *aReturn) MOZ_OVERRIDE;
 
   // nsBaseFilePicker
-  virtual void InitNative(nsIWidget *aParent, const nsAString& aTitle);
+  virtual void InitNative(nsIWidget *aParent,
+                          const nsAString& aTitle) MOZ_OVERRIDE;
 
   static void Shutdown();
 
 protected:
   virtual ~nsFilePicker();
 
   void ReadValuesFromFileChooser(GtkWidget *file_chooser);
 
--- a/widget/gtk/nsIdleServiceGTK.h
+++ b/widget/gtk/nsIdleServiceGTK.h
@@ -22,17 +22,17 @@ typedef struct {
     unsigned long event_mask;   // event stuff
 } XScreenSaverInfo;
 
 class nsIdleServiceGTK : public nsIdleService
 {
 public:
     NS_DECL_ISUPPORTS_INHERITED
 
-    bool PollIdleTime(uint32_t* aIdleTime);
+    virtual bool PollIdleTime(uint32_t* aIdleTime) MOZ_OVERRIDE;
 
     static already_AddRefed<nsIdleServiceGTK> GetInstance()
     {
         nsRefPtr<nsIdleServiceGTK> idleService =
             nsIdleService::GetInstance().downcast<nsIdleServiceGTK>();
         if (!idleService) {
             idleService = new nsIdleServiceGTK();
         }
@@ -41,12 +41,12 @@ public:
     }
 
 private:
     ~nsIdleServiceGTK();
     XScreenSaverInfo* mXssInfo;
 
 protected:
     nsIdleServiceGTK();
-    bool UsePollMode();
+    virtual bool UsePollMode() MOZ_OVERRIDE;
 };
 
 #endif // nsIdleServiceGTK_h__
--- a/widget/gtk/nsImageToPixbuf.h
+++ b/widget/gtk/nsImageToPixbuf.h
@@ -15,17 +15,17 @@ class SourceSurface;
 }
 }
 
 class nsImageToPixbuf MOZ_FINAL : public nsIImageToPixbuf {
     typedef mozilla::gfx::SourceSurface SourceSurface;
 
     public:
         NS_DECL_ISUPPORTS
-        NS_IMETHOD_(GdkPixbuf*) ConvertImageToPixbuf(imgIContainer* aImage);
+        NS_IMETHOD_(GdkPixbuf*) ConvertImageToPixbuf(imgIContainer* aImage) MOZ_OVERRIDE;
 
         // Friendlier version of ConvertImageToPixbuf for callers inside of
         // widget
         /**
          * The return value of all these, if not null, should be
          * released as needed by the caller using g_object_unref.
          */
         static GdkPixbuf* ImageToPixbuf(imgIContainer * aImage);
--- a/widget/gtk/nsNativeThemeGTK.h
+++ b/widget/gtk/nsNativeThemeGTK.h
@@ -22,52 +22,55 @@ public:
   NS_DECL_ISUPPORTS_INHERITED
 
   NS_DECL_NSIOBSERVER
 
   // The nsITheme interface.
   NS_IMETHOD DrawWidgetBackground(nsRenderingContext* aContext,
                                   nsIFrame* aFrame, uint8_t aWidgetType,
                                   const nsRect& aRect,
-                                  const nsRect& aDirtyRect);
+                                  const nsRect& aDirtyRect) MOZ_OVERRIDE;
 
   NS_IMETHOD GetWidgetBorder(nsDeviceContext* aContext, nsIFrame* aFrame,
-                             uint8_t aWidgetType, nsIntMargin* aResult);
+                             uint8_t aWidgetType,
+                             nsIntMargin* aResult) MOZ_OVERRIDE;
 
   virtual bool GetWidgetPadding(nsDeviceContext* aContext,
-                                              nsIFrame* aFrame,
-                                              uint8_t aWidgetType,
-                                              nsIntMargin* aResult);
+                                nsIFrame* aFrame,
+                                uint8_t aWidgetType,
+                                nsIntMargin* aResult) MOZ_OVERRIDE;
 
   virtual bool GetWidgetOverflow(nsDeviceContext* aContext,
-                                               nsIFrame* aFrame,
-                                               uint8_t aWidgetType,
-                                               nsRect* aOverflowRect);
+                                 nsIFrame* aFrame,
+                                 uint8_t aWidgetType,
+                                 nsRect* aOverflowRect) MOZ_OVERRIDE;
 
   NS_IMETHOD GetMinimumWidgetSize(nsPresContext* aPresContext,
                                   nsIFrame* aFrame, uint8_t aWidgetType,
-                                  nsIntSize* aResult, bool* aIsOverridable);
+                                  nsIntSize* aResult,
+                                  bool* aIsOverridable) MOZ_OVERRIDE;
 
   NS_IMETHOD WidgetStateChanged(nsIFrame* aFrame, uint8_t aWidgetType, 
-                                nsIAtom* aAttribute, bool* aShouldRepaint);
+                                nsIAtom* aAttribute,
+                                bool* aShouldRepaint) MOZ_OVERRIDE;
 
-  NS_IMETHOD ThemeChanged();
+  NS_IMETHOD ThemeChanged() MOZ_OVERRIDE;
 
   NS_IMETHOD_(bool) ThemeSupportsWidget(nsPresContext* aPresContext,
-                                          nsIFrame* aFrame,
-                                          uint8_t aWidgetType);
+                                        nsIFrame* aFrame,
+                                        uint8_t aWidgetType) MOZ_OVERRIDE;
 
-  NS_IMETHOD_(bool) WidgetIsContainer(uint8_t aWidgetType);
+  NS_IMETHOD_(bool) WidgetIsContainer(uint8_t aWidgetType) MOZ_OVERRIDE;
   
   NS_IMETHOD_(bool) ThemeDrawsFocusForWidget(uint8_t aWidgetType) MOZ_OVERRIDE;
 
-  bool ThemeNeedsComboboxDropmarker();
+  virtual bool ThemeNeedsComboboxDropmarker() MOZ_OVERRIDE;
 
   virtual Transparency GetWidgetTransparency(nsIFrame* aFrame,
-                                             uint8_t aWidgetType);
+                                             uint8_t aWidgetType) MOZ_OVERRIDE;
 
   nsNativeThemeGTK();
 
 protected:
   virtual ~nsNativeThemeGTK();
 
 private:
   gint GetTabMarginPixels(nsIFrame* aFrame);
--- a/widget/gtk/nsPrintDialogGTK.h
+++ b/widget/gtk/nsPrintDialogGTK.h
@@ -24,16 +24,16 @@ class nsPrintDialogServiceGTK : public n
 {
   virtual ~nsPrintDialogServiceGTK();
 
 public:
   nsPrintDialogServiceGTK();
 
   NS_DECL_ISUPPORTS
 
-  NS_IMETHODIMP Init();
+  NS_IMETHODIMP Init() MOZ_OVERRIDE;
   NS_IMETHODIMP Show(nsIDOMWindow *aParent, nsIPrintSettings *aSettings,
-                     nsIWebBrowserPrint *aWebBrowserPrint);
+                     nsIWebBrowserPrint *aWebBrowserPrint) MOZ_OVERRIDE;
   NS_IMETHODIMP ShowPageSetup(nsIDOMWindow *aParent,
-                              nsIPrintSettings *aSettings);
+                              nsIPrintSettings *aSettings) MOZ_OVERRIDE;
 };
 
 #endif
--- a/widget/gtk/nsPrintSettingsGTK.h
+++ b/widget/gtk/nsPrintSettingsGTK.h
@@ -43,89 +43,89 @@ public:
   GtkPrinter* GetGtkPrinter() { return mGTKPrinter; };
   void SetGtkPrinter(GtkPrinter *aPrinter);
 
   bool GetForcePrintSelectionOnly() { return mPrintSelectionOnly; };
   void SetForcePrintSelectionOnly(bool aPrintSelectionOnly) { mPrintSelectionOnly = aPrintSelectionOnly; };
 
   // If not printing the selection, this is stored in the GtkPrintSettings. Printing the
   // selection is stored as a protected boolean (mPrintSelectionOnly).
-  NS_IMETHOD GetPrintRange(int16_t *aPrintRange);
-  NS_IMETHOD SetPrintRange(int16_t aPrintRange);
+  NS_IMETHOD GetPrintRange(int16_t *aPrintRange) MOZ_OVERRIDE;
+  NS_IMETHOD SetPrintRange(int16_t aPrintRange) MOZ_OVERRIDE;
 
   // The page range is stored as as single range in the GtkPrintSettings object.
-  NS_IMETHOD GetStartPageRange(int32_t *aStartPageRange);
-  NS_IMETHOD SetStartPageRange(int32_t aStartPageRange);
-  NS_IMETHOD GetEndPageRange(int32_t *aEndPageRange);
-  NS_IMETHOD SetEndPageRange(int32_t aEndPageRange);
+  NS_IMETHOD GetStartPageRange(int32_t *aStartPageRange) MOZ_OVERRIDE;
+  NS_IMETHOD SetStartPageRange(int32_t aStartPageRange) MOZ_OVERRIDE;
+  NS_IMETHOD GetEndPageRange(int32_t *aEndPageRange) MOZ_OVERRIDE;
+  NS_IMETHOD SetEndPageRange(int32_t aEndPageRange) MOZ_OVERRIDE;
 
   // Reversed, color, orientation and file name are all stored in the GtkPrintSettings.
   // Orientation is also stored in the GtkPageSetup and its setting takes priority when getting the orientation.
-  NS_IMETHOD GetPrintReversed(bool *aPrintReversed);
-  NS_IMETHOD SetPrintReversed(bool aPrintReversed);
+  NS_IMETHOD GetPrintReversed(bool *aPrintReversed) MOZ_OVERRIDE;
+  NS_IMETHOD SetPrintReversed(bool aPrintReversed) MOZ_OVERRIDE;
 
-  NS_IMETHOD GetPrintInColor(bool *aPrintInColor);
-  NS_IMETHOD SetPrintInColor(bool aPrintInColor);
+  NS_IMETHOD GetPrintInColor(bool *aPrintInColor) MOZ_OVERRIDE;
+  NS_IMETHOD SetPrintInColor(bool aPrintInColor) MOZ_OVERRIDE;
 
-  NS_IMETHOD GetOrientation(int32_t *aOrientation);
-  NS_IMETHOD SetOrientation(int32_t aOrientation);
+  NS_IMETHOD GetOrientation(int32_t *aOrientation) MOZ_OVERRIDE;
+  NS_IMETHOD SetOrientation(int32_t aOrientation) MOZ_OVERRIDE;
 
-  NS_IMETHOD GetToFileName(char16_t * *aToFileName);
-  NS_IMETHOD SetToFileName(const char16_t * aToFileName);
+  NS_IMETHOD GetToFileName(char16_t * *aToFileName) MOZ_OVERRIDE;
+  NS_IMETHOD SetToFileName(const char16_t * aToFileName) MOZ_OVERRIDE;
 
   // Gets/Sets the printer name in the GtkPrintSettings. If no printer name is specified there,
   // you will get back the name of the current internal GtkPrinter.
-  NS_IMETHOD GetPrinterName(char16_t * *aPrinter);
-  NS_IMETHOD SetPrinterName(const char16_t * aPrinter);
+  NS_IMETHOD GetPrinterName(char16_t * *aPrinter) MOZ_OVERRIDE;
+  NS_IMETHOD SetPrinterName(const char16_t * aPrinter) MOZ_OVERRIDE;
 
   // Number of copies is stored/gotten from the GtkPrintSettings.
-  NS_IMETHOD GetNumCopies(int32_t *aNumCopies);
-  NS_IMETHOD SetNumCopies(int32_t aNumCopies);
+  NS_IMETHOD GetNumCopies(int32_t *aNumCopies) MOZ_OVERRIDE;
+  NS_IMETHOD SetNumCopies(int32_t aNumCopies) MOZ_OVERRIDE;
 
-  NS_IMETHOD GetScaling(double *aScaling);
-  NS_IMETHOD SetScaling(double aScaling);
+  NS_IMETHOD GetScaling(double *aScaling) MOZ_OVERRIDE;
+  NS_IMETHOD SetScaling(double aScaling) MOZ_OVERRIDE;
 
   // A name recognised by GTK is strongly advised here, as this is used to create a GtkPaperSize.
-  NS_IMETHOD GetPaperName(char16_t * *aPaperName);
-  NS_IMETHOD SetPaperName(const char16_t * aPaperName);
+  NS_IMETHOD GetPaperName(char16_t * *aPaperName) MOZ_OVERRIDE;
+  NS_IMETHOD SetPaperName(const char16_t * aPaperName) MOZ_OVERRIDE;
 
-  NS_IMETHOD SetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin);
-  NS_IMETHOD SetUnwriteableMarginTop(double aUnwriteableMarginTop);
-  NS_IMETHOD SetUnwriteableMarginLeft(double aUnwriteableMarginLeft);
-  NS_IMETHOD SetUnwriteableMarginBottom(double aUnwriteableMarginBottom);
-  NS_IMETHOD SetUnwriteableMarginRight(double aUnwriteableMarginRight);
+  NS_IMETHOD SetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin) MOZ_OVERRIDE;
+  NS_IMETHOD SetUnwriteableMarginTop(double aUnwriteableMarginTop) MOZ_OVERRIDE;
+  NS_IMETHOD SetUnwriteableMarginLeft(double aUnwriteableMarginLeft) MOZ_OVERRIDE;
+  NS_IMETHOD SetUnwriteableMarginBottom(double aUnwriteableMarginBottom) MOZ_OVERRIDE;
+  NS_IMETHOD SetUnwriteableMarginRight(double aUnwriteableMarginRight) MOZ_OVERRIDE;
 
-  NS_IMETHOD GetPaperWidth(double *aPaperWidth);
-  NS_IMETHOD SetPaperWidth(double aPaperWidth);
+  NS_IMETHOD GetPaperWidth(double *aPaperWidth) MOZ_OVERRIDE;
+  NS_IMETHOD SetPaperWidth(double aPaperWidth) MOZ_OVERRIDE;
 
-  NS_IMETHOD GetPaperHeight(double *aPaperHeight);
-  NS_IMETHOD SetPaperHeight(double aPaperHeight);
+  NS_IMETHOD GetPaperHeight(double *aPaperHeight) MOZ_OVERRIDE;
+  NS_IMETHOD SetPaperHeight(double aPaperHeight) MOZ_OVERRIDE;
 
-  NS_IMETHOD SetPaperSizeUnit(int16_t aPaperSizeUnit);
+  NS_IMETHOD SetPaperSizeUnit(int16_t aPaperSizeUnit) MOZ_OVERRIDE;
 
-  NS_IMETHOD GetEffectivePageSize(double *aWidth, double *aHeight);
+  NS_IMETHOD GetEffectivePageSize(double *aWidth, double *aHeight) MOZ_OVERRIDE;
 
-  NS_IMETHOD SetupSilentPrinting();
+  NS_IMETHOD SetupSilentPrinting() MOZ_OVERRIDE;
 
-  NS_IMETHOD GetPageRanges(nsTArray<int32_t> &aPages);
+  NS_IMETHOD GetPageRanges(nsTArray<int32_t> &aPages) MOZ_OVERRIDE;
 
-  NS_IMETHOD GetResolution(int32_t *aResolution);
-  NS_IMETHOD SetResolution(int32_t aResolution);
+  NS_IMETHOD GetResolution(int32_t *aResolution) MOZ_OVERRIDE;
+  NS_IMETHOD SetResolution(int32_t aResolution) MOZ_OVERRIDE;
 
-  NS_IMETHOD GetDuplex(int32_t *aDuplex);
-  NS_IMETHOD SetDuplex(int32_t aDuplex);
+  NS_IMETHOD GetDuplex(int32_t *aDuplex) MOZ_OVERRIDE;
+  NS_IMETHOD SetDuplex(int32_t aDuplex) MOZ_OVERRIDE;
 
 protected:
   virtual ~nsPrintSettingsGTK();
 
   nsPrintSettingsGTK(const nsPrintSettingsGTK& src);
   nsPrintSettingsGTK& operator=(const nsPrintSettingsGTK& rhs);
 
-  virtual nsresult _Clone(nsIPrintSettings **_retval);
-  virtual nsresult _Assign(nsIPrintSettings *aPS);
+  virtual nsresult _Clone(nsIPrintSettings **_retval) MOZ_OVERRIDE;
+  virtual nsresult _Assign(nsIPrintSettings *aPS) MOZ_OVERRIDE;
 
   GtkUnit GetGTKUnit(int16_t aGeckoUnit);
   void SaveNewPageSize();
 
   /**
    * Re-initialize mUnwriteableMargin with values from mPageSetup.
    * Should be called whenever mPageSetup is initialized or overwritten.
    */
--- a/widget/gtk/nsWindow.h
+++ b/widget/gtk/nsWindow.h
@@ -75,84 +75,85 @@ public:
 
     static void ReleaseGlobals();
 
     NS_DECL_ISUPPORTS_INHERITED
     
     void CommonCreate(nsIWidget *aParent, bool aListenForResizes);
     
     virtual nsresult DispatchEvent(mozilla::WidgetGUIEvent* aEvent,
-                                   nsEventStatus& aStatus);
+                                   nsEventStatus& aStatus) MOZ_OVERRIDE;
     
     // called when we are destroyed
-    void OnDestroy(void);
+    virtual void OnDestroy(void) MOZ_OVERRIDE;
 
     // called to check and see if a widget's dimensions are sane
     bool AreBoundsSane(void);
 
     // nsIWidget
     NS_IMETHOD         Create(nsIWidget        *aParent,
                               nsNativeWidget   aNativeParent,
                               const nsIntRect  &aRect,
                               nsDeviceContext *aContext,
-                              nsWidgetInitData *aInitData);
-    NS_IMETHOD         Destroy(void);
-    virtual nsIWidget *GetParent();
-    virtual float      GetDPI();
-    virtual nsresult   SetParent(nsIWidget* aNewParent);
-    NS_IMETHOD         SetModal(bool aModal);
-    virtual bool       IsVisible() const;
+                              nsWidgetInitData *aInitData) MOZ_OVERRIDE;
+    NS_IMETHOD         Destroy(void) MOZ_OVERRIDE;
+    virtual nsIWidget *GetParent() MOZ_OVERRIDE;
+    virtual float      GetDPI() MOZ_OVERRIDE;
+    virtual nsresult   SetParent(nsIWidget* aNewParent) MOZ_OVERRIDE;
+    NS_IMETHOD         SetModal(bool aModal) MOZ_OVERRIDE;
+    virtual bool       IsVisible() const MOZ_OVERRIDE;
     NS_IMETHOD         ConstrainPosition(bool aAllowSlop,
                                          int32_t *aX,
-                                         int32_t *aY);
-    virtual void       SetSizeConstraints(const SizeConstraints& aConstraints);
+                                         int32_t *aY) MOZ_OVERRIDE;
+    virtual void       SetSizeConstraints(const SizeConstraints& aConstraints) MOZ_OVERRIDE;
     NS_IMETHOD         Move(double aX,
-                            double aY);
-    NS_IMETHOD         Show             (bool aState);
+                            double aY) MOZ_OVERRIDE;
+    NS_IMETHOD         Show             (bool aState) MOZ_OVERRIDE;
     NS_IMETHOD         Resize           (double aWidth,
                                          double aHeight,
-                                         bool   aRepaint);
+                                         bool   aRepaint) MOZ_OVERRIDE;
     NS_IMETHOD         Resize           (double aX,
                                          double aY,
                                          double aWidth,
                                          double aHeight,
-                                         bool   aRepaint);
-    virtual bool       IsEnabled() const;
+                                         bool   aRepaint) MOZ_OVERRIDE;
+    virtual bool       IsEnabled() const MOZ_OVERRIDE;
 
 
     NS_IMETHOD         PlaceBehind(nsTopLevelWidgetZPlacement  aPlacement,
                                    nsIWidget                  *aWidget,
-                                   bool                        aActivate);
-    void               SetZIndex(int32_t aZIndex);
-    NS_IMETHOD         SetSizeMode(int32_t aMode);
-    NS_IMETHOD         Enable(bool aState);
-    NS_IMETHOD         SetFocus(bool aRaise = false);
-    NS_IMETHOD         GetScreenBounds(nsIntRect &aRect);
-    NS_IMETHOD         GetClientBounds(nsIntRect &aRect);
-    virtual nsIntPoint GetClientOffset();
-    NS_IMETHOD         SetCursor(nsCursor aCursor);
+                                   bool                        aActivate) MOZ_OVERRIDE;
+    void               SetZIndex(int32_t aZIndex) MOZ_OVERRIDE;
+    NS_IMETHOD         SetSizeMode(int32_t aMode) MOZ_OVERRIDE;
+    NS_IMETHOD         Enable(bool aState) MOZ_OVERRIDE;
+    NS_IMETHOD         SetFocus(bool aRaise = false) MOZ_OVERRIDE;
+    NS_IMETHOD         GetScreenBounds(nsIntRect &aRect) MOZ_OVERRIDE;
+    NS_IMETHOD         GetClientBounds(nsIntRect &aRect) MOZ_OVERRIDE;
+    virtual nsIntPoint GetClientOffset() MOZ_OVERRIDE;
+    NS_IMETHOD         SetCursor(nsCursor aCursor) MOZ_OVERRIDE;
     NS_IMETHOD         SetCursor(imgIContainer* aCursor,
-                                 uint32_t aHotspotX, uint32_t aHotspotY);
-    NS_IMETHOD         Invalidate(const nsIntRect &aRect);
-    virtual void*      GetNativeData(uint32_t aDataType);
-    NS_IMETHOD         SetTitle(const nsAString& aTitle);
-    NS_IMETHOD         SetIcon(const nsAString& aIconSpec);
-    NS_IMETHOD         SetWindowClass(const nsAString& xulWinType);
-    virtual nsIntPoint WidgetToScreenOffset();
-    NS_IMETHOD         EnableDragDrop(bool aEnable);
-    NS_IMETHOD         CaptureMouse(bool aCapture);
+                                 uint32_t aHotspotX, uint32_t aHotspotY) MOZ_OVERRIDE;
+    NS_IMETHOD         Invalidate(const nsIntRect &aRect) MOZ_OVERRIDE;
+    virtual void*      GetNativeData(uint32_t aDataType) MOZ_OVERRIDE;
+    NS_IMETHOD         SetTitle(const nsAString& aTitle) MOZ_OVERRIDE;
+    NS_IMETHOD         SetIcon(const nsAString& aIconSpec) MOZ_OVERRIDE;
+    NS_IMETHOD         SetWindowClass(const nsAString& xulWinType) MOZ_OVERRIDE;
+    virtual nsIntPoint WidgetToScreenOffset() MOZ_OVERRIDE;
+    NS_IMETHOD         EnableDragDrop(bool aEnable) MOZ_OVERRIDE;
+    NS_IMETHOD         CaptureMouse(bool aCapture) MOZ_OVERRIDE;
     NS_IMETHOD         CaptureRollupEvents(nsIRollupListener *aListener,
-                                           bool aDoCapture);
-    NS_IMETHOD         GetAttention(int32_t aCycleCount);
+                                           bool aDoCapture) MOZ_OVERRIDE;
+    NS_IMETHOD         GetAttention(int32_t aCycleCount) MOZ_OVERRIDE;
     virtual nsresult   SetWindowClipRegion(const nsTArray<nsIntRect>& aRects,
                                            bool aIntersectWithExisting) MOZ_OVERRIDE;
-    virtual bool       HasPendingInputEvent();
+    virtual bool       HasPendingInputEvent() MOZ_OVERRIDE;
 
-    NS_IMETHOD         MakeFullScreen(bool aFullScreen, nsIScreen* aTargetScreen = nullptr);
-    NS_IMETHOD         HideWindowChrome(bool aShouldHide);
+    NS_IMETHOD         MakeFullScreen(bool aFullScreen,
+                                      nsIScreen* aTargetScreen = nullptr) MOZ_OVERRIDE;
+    NS_IMETHOD         HideWindowChrome(bool aShouldHide) MOZ_OVERRIDE;
 
     /**
      * GetLastUserInputTime returns a timestamp for the most recent user input
      * event.  This is intended for pointer grab requests (including drags).
      */
     static guint32     GetLastUserInputTime();
 
     // utility method, -1 if no change should be made, otherwise returns a
@@ -233,18 +234,18 @@ public:
 #ifdef MOZ_X11
     Window             mOldFocusWindow;
 #endif /* MOZ_X11 */
 
     static guint32     sLastButtonPressTime;
 
     NS_IMETHOD         BeginResizeDrag(mozilla::WidgetGUIEvent* aEvent,
                                        int32_t aHorizontal,
-                                       int32_t aVertical);
-    NS_IMETHOD         BeginMoveDrag(mozilla::WidgetMouseEvent* aEvent);
+                                       int32_t aVertical) MOZ_OVERRIDE;
+    NS_IMETHOD         BeginMoveDrag(mozilla::WidgetMouseEvent* aEvent) MOZ_OVERRIDE;
 
     MozContainer*      GetMozContainer() { return mContainer; }
     // GetMozContainerWidget returns the MozContainer even for undestroyed
     // descendant windows
     GtkWidget*         GetMozContainerWidget();
     GdkWindow*         GetGdkWindow() { return mGdkWindow; }
     bool               IsDestroyed() { return mIsDestroyed; }
 
@@ -255,56 +256,57 @@ public:
                                          nsIDragService *aDragService);
     // If this dispatched the keydown event actually, this returns TRUE,
     // otherwise, FALSE.
     bool               DispatchKeyDownEvent(GdkEventKey *aEvent,
                                             bool *aIsCancelled);
 
     NS_IMETHOD NotifyIME(const IMENotification& aIMENotification) MOZ_OVERRIDE;
     NS_IMETHOD_(void) SetInputContext(const InputContext& aContext,
-                                      const InputContextAction& aAction);
-    NS_IMETHOD_(InputContext) GetInputContext();
-    virtual nsIMEUpdatePreference GetIMEUpdatePreference();
+                                      const InputContextAction& aAction) MOZ_OVERRIDE;
+    NS_IMETHOD_(InputContext) GetInputContext() MOZ_OVERRIDE;
+    virtual nsIMEUpdatePreference GetIMEUpdatePreference() MOZ_OVERRIDE;
     bool ExecuteNativeKeyBindingRemapped(
                         NativeKeyBindingsType aType,
                         const mozilla::WidgetKeyboardEvent& aEvent,
                         DoCommandCallback aCallback,
                         void* aCallbackData,
                         uint32_t aGeckoKeyCode,
                         uint32_t aNativeKeyCode);
     NS_IMETHOD_(bool) ExecuteNativeKeyBinding(
                         NativeKeyBindingsType aType,
                         const mozilla::WidgetKeyboardEvent& aEvent,
                         DoCommandCallback aCallback,
                         void* aCallbackData) MOZ_OVERRIDE;
-    NS_IMETHOD GetToggledKeyState(uint32_t aKeyCode, bool* aLEDState);
+    NS_IMETHOD GetToggledKeyState(uint32_t aKeyCode,
+                                  bool* aLEDState) MOZ_OVERRIDE;
 
     // These methods are for toplevel windows only.
     void               ResizeTransparencyBitmap();
     void               ApplyTransparencyBitmap();
     void               ClearTransparencyBitmap();
 
-   virtual void        SetTransparencyMode(nsTransparencyMode aMode);
-   virtual nsTransparencyMode GetTransparencyMode();
-   virtual nsresult    ConfigureChildren(const nsTArray<Configuration>& aConfigurations);
+   virtual void        SetTransparencyMode(nsTransparencyMode aMode) MOZ_OVERRIDE;
+   virtual nsTransparencyMode GetTransparencyMode() MOZ_OVERRIDE;
+   virtual nsresult    ConfigureChildren(const nsTArray<Configuration>& aConfigurations) MOZ_OVERRIDE;
    nsresult            UpdateTranslucentWindowAlphaInternal(const nsIntRect& aRect,
                                                             uint8_t* aAlphas, int32_t aStride);
     virtual gfxASurface *GetThebesSurface();
 
 #if (MOZ_WIDGET_GTK == 2)
     static already_AddRefed<gfxASurface> GetSurfaceForGdkDrawable(GdkDrawable* aDrawable,
                                                                   const nsIntSize& aSize);
 #endif
-    NS_IMETHOD         ReparentNativeWidget(nsIWidget* aNewParent);
+    NS_IMETHOD         ReparentNativeWidget(nsIWidget* aNewParent) MOZ_OVERRIDE;
 
     virtual nsresult SynthesizeNativeMouseEvent(nsIntPoint aPoint,
                                                 uint32_t aNativeMessage,
-                                                uint32_t aModifierFlags);
+                                                uint32_t aModifierFlags) MOZ_OVERRIDE;
 
-    virtual nsresult SynthesizeNativeMouseMove(nsIntPoint aPoint)
+    virtual nsresult SynthesizeNativeMouseMove(nsIntPoint aPoint) MOZ_OVERRIDE
     { return SynthesizeNativeMouseEvent(aPoint, GDK_MOTION_NOTIFY, 0); }
 
 protected:
     virtual ~nsWindow();
 
     // event handling code
     void DispatchActivateEvent(void);
     void DispatchDeactivateEvent(void);