Bug 1015664. Part 1: Remove NS_HIDDEN_() usage. r=bsmedberg
authorRobert O'Callahan <robert@ocallahan.org>
Tue, 03 Jun 2014 00:08:21 +1200
changeset 186156 58a202b281976f42fa7dab286fedaa482c3dce56
parent 186155 a4957e3ceafb87f5097d34525e6652e3990d8e6d
child 186157 4e200260a4535784c254b0c142574f7cf3bcf777
push id26879
push userryanvm@gmail.com
push dateMon, 02 Jun 2014 21:20:13 +0000
treeherdermozilla-central@99137ca57770 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbsmedberg
bugs1015664
milestone32.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 1015664. Part 1: Remove NS_HIDDEN_() usage. r=bsmedberg
browser/components/shell/src/nsGNOMEShellService.h
content/base/public/Element.h
content/base/public/nsXMLNameSpaceMap.h
content/base/src/nsContentList.h
content/base/src/nsContentSink.h
content/base/src/nsDocument.h
content/base/src/nsFrameLoader.h
content/base/src/nsPropertyTable.cpp
content/base/src/nsPropertyTable.h
content/html/content/src/HTMLInputElement.cpp
content/html/content/src/HTMLObjectElement.h
content/html/content/src/HTMLSharedObjectElement.h
content/html/content/src/nsGenericHTMLElement.h
content/html/document/src/nsHTMLDocument.h
content/xul/document/src/XULDocument.h
dom/base/nsGlobalWindow.h
dom/base/nsPIDOMWindow.h
dom/xbl/nsBindingManager.h
gfx/thebes/gfxFont.h
image/decoders/icon/android/nsIconChannel.h
image/decoders/icon/gtk/nsIconChannel.h
image/decoders/icon/qt/nsIconChannel.h
intl/locale/src/nsLanguageAtomService.h
layout/base/RestyleManager.h
layout/base/nsFrameManager.cpp
layout/base/nsFrameManager.h
layout/base/nsFrameManagerBase.h
layout/base/nsIPresShell.h
layout/base/nsPresArena.cpp
layout/base/nsPresArena.h
layout/base/nsPresContext.h
layout/base/nsPresShell.h
layout/base/nsStyleSheetService.h
layout/forms/nsFieldSetFrame.h
layout/generic/nsIFrame.h
layout/xul/nsBox.h
layout/xul/nsBoxFrame.h
layout/xul/nsMenuFrame.h
modules/libjar/zipwriter/src/StreamFunctions.cpp
modules/libjar/zipwriter/src/StreamFunctions.h
netwerk/base/public/nsNetStrings.h
netwerk/base/public/nsNetUtil.h
netwerk/base/src/nsIOService.h
netwerk/base/src/nsInputStreamPump.h
netwerk/base/src/nsNetStrings.cpp
netwerk/base/src/nsPACMan.h
netwerk/base/src/nsProtocolProxyService.h
netwerk/base/src/nsTransportUtils.h
netwerk/base/src/nsURLHelper.h
netwerk/build/nsNetModule.cpp
netwerk/protocol/data/nsDataHandler.h
netwerk/protocol/viewsource/nsViewSourceChannel.h
parser/htmlparser/public/nsScannerString.h
storage/src/FileSystemModule.h
storage/src/SQLCollations.h
storage/src/mozStorageSQLFunctions.h
toolkit/components/typeaheadfind/nsTypeAheadFind.h
toolkit/profile/nsToolkitProfileService.cpp
toolkit/system/gnome/nsGConfService.h
toolkit/system/gnome/nsGSettingsService.h
toolkit/system/gnome/nsGnomeVFSService.h
toolkit/xre/nsAppRunner.h
toolkit/xre/nsUpdateDriver.h
uriloader/base/nsURILoader.h
uriloader/exthandler/android/nsMIMEInfoAndroid.h
uriloader/exthandler/android/nsOSHelperAppService.h
uriloader/exthandler/gonk/nsOSHelperAppService.cpp
uriloader/exthandler/gonk/nsOSHelperAppService.h
uriloader/exthandler/mac/nsMIMEInfoMac.h
uriloader/exthandler/nsExternalHelperAppService.h
uriloader/exthandler/nsLocalHandlerApp.h
uriloader/exthandler/nsMIMEInfoImpl.h
uriloader/exthandler/unix/nsMIMEInfoUnix.h
uriloader/exthandler/win/nsMIMEInfoWin.h
widget/gtk/nsNativeThemeGTK.h
xpcom/base/nsMemoryImpl.h
xpcom/ds/TimeStamp.h
xpcom/ds/nsMathUtils.h
xpcom/threads/TimerThread.h
xpcom/threads/nsTimerImpl.h
xpfe/appshell/src/nsXULWindow.h
--- a/browser/components/shell/src/nsGNOMEShellService.h
+++ b/browser/components/shell/src/nsGNOMEShellService.h
@@ -18,19 +18,19 @@ public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSISHELLSERVICE
 
   nsresult Init() NS_HIDDEN;
 
 private:
   ~nsGNOMEShellService() {}
 
-  NS_HIDDEN_(bool) KeyMatchesAppName(const char *aKeyValue) const;
-  NS_HIDDEN_(bool) CheckHandlerMatchesAppName(const nsACString& handler) const;
+  bool KeyMatchesAppName(const char *aKeyValue) const;
+  bool CheckHandlerMatchesAppName(const nsACString& handler) const;
 
-  NS_HIDDEN_(bool) GetAppPathFromLauncher();
+  bool GetAppPathFromLauncher();
   bool mCheckedThisSession;
   bool mUseLocaleFilenames;
   nsCString    mAppPath;
   bool mAppIsInPath;
 };
 
 #endif // nsgnomeshellservice_h____
--- a/content/base/public/Element.h
+++ b/content/base/public/Element.h
@@ -944,30 +944,30 @@ public:
   /**
    * Helper method for NS_IMPL_BOOL_ATTR macro.
    * Gets value of boolean attribute. Only works for attributes in null
    * namespace.
    *
    * @param aAttr    name of attribute.
    * @param aValue   Boolean value of attribute.
    */
-  NS_HIDDEN_(bool) GetBoolAttr(nsIAtom* aAttr) const
+  bool GetBoolAttr(nsIAtom* aAttr) const
   {
     return HasAttr(kNameSpaceID_None, aAttr);
   }
 
   /**
    * Helper method for NS_IMPL_BOOL_ATTR macro.
    * Sets value of boolean attribute by removing attribute or setting it to
    * the empty string. Only works for attributes in null namespace.
    *
    * @param aAttr    name of attribute.
    * @param aValue   Boolean value of attribute.
    */
-  NS_HIDDEN_(nsresult) SetBoolAttr(nsIAtom* aAttr, bool aValue);
+  nsresult SetBoolAttr(nsIAtom* aAttr, bool aValue);
 
   /**
    * Retrieve the ratio of font-size-inflated text font size to computed font
    * size for this element. This will query the element for its primary frame,
    * and then use this to get font size inflation information about the frame.
    *
    * @returns The font size inflation ratio (inflated font size to uninflated
    *          font size) for the primary frame of this element. Returns 1.0
--- a/content/base/public/nsXMLNameSpaceMap.h
+++ b/content/base/public/nsXMLNameSpaceMap.h
@@ -26,47 +26,47 @@ struct nsNameSpaceEntry
  */
 class nsXMLNameSpaceMap
 {
 public:
   /**
    * Allocates a new nsXMLNameSpaceMap (with new()) and if aForXML is
    * true initializes it with the xmlns and xml namespaces.
    */
-  static NS_HIDDEN_(nsXMLNameSpaceMap*) Create(bool aForXML);
+  static nsXMLNameSpaceMap* Create(bool aForXML);
 
   /**
    * Add a prefix and its corresponding namespace ID to the map.
    * Passing a null |aPrefix| corresponds to the default namespace, which may
    * be set to something other than kNameSpaceID_None.
    */
-  NS_HIDDEN_(nsresult) AddPrefix(nsIAtom *aPrefix, int32_t aNameSpaceID);
+  nsresult AddPrefix(nsIAtom *aPrefix, int32_t aNameSpaceID);
 
   /**
    * Add a prefix and a namespace URI to the map.  The URI will be converted
    * to its corresponding namespace ID.
    */
-  NS_HIDDEN_(nsresult) AddPrefix(nsIAtom *aPrefix, nsString &aURI);
+  nsresult AddPrefix(nsIAtom *aPrefix, nsString &aURI);
 
   /*
    * Returns the namespace ID for the given prefix, if it is in the map.
    * If |aPrefix| is null and is not in the map, then a null namespace
    * (kNameSpaceID_None) is returned.  If |aPrefix| is non-null and is not in
    * the map, then kNameSpaceID_Unknown is returned.
    */
-  NS_HIDDEN_(int32_t) FindNameSpaceID(nsIAtom *aPrefix) const;
+  int32_t FindNameSpaceID(nsIAtom *aPrefix) const;
 
   /**
    * If the given namespace ID is in the map, then the first prefix which
    * maps to that namespace is returned.  Otherwise, null is returned.
    */
-  NS_HIDDEN_(nsIAtom*) FindPrefix(int32_t aNameSpaceID) const;
+  nsIAtom* FindPrefix(int32_t aNameSpaceID) const;
 
   /* Removes all prefix mappings. */
-  NS_HIDDEN_(void) Clear();
+  void Clear();
 
   ~nsXMLNameSpaceMap() { Clear(); }
 
 private:
   nsXMLNameSpaceMap() NS_HIDDEN;  // use Create() to create new instances
 
   nsTArray<nsNameSpaceEntry> mNameSpaces;
 };
--- a/content/base/src/nsContentList.h
+++ b/content/base/src/nsContentList.h
@@ -279,19 +279,19 @@ public:
     mozilla::dom::Element* item = NamedItem(aName, true);
     aFound = !!item;
     return item;
   }
   virtual void GetSupportedNames(unsigned aFlags,
                                  nsTArray<nsString>& aNames) MOZ_OVERRIDE;
 
   // nsContentList public methods
-  NS_HIDDEN_(uint32_t) Length(bool aDoFlush);
-  NS_HIDDEN_(nsIContent*) Item(uint32_t aIndex, bool aDoFlush);
-  NS_HIDDEN_(mozilla::dom::Element*)
+  uint32_t Length(bool aDoFlush);
+  nsIContent* Item(uint32_t aIndex, bool aDoFlush);
+  mozilla::dom::Element*
   NamedItem(const nsAString& aName, bool aDoFlush);
 
   // nsIMutationObserver
   NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
   NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
--- a/content/base/src/nsContentSink.h
+++ b/content/base/src/nsContentSink.h
@@ -87,23 +87,23 @@ class nsContentSink : public nsICSSLoade
 
   // nsICSSLoaderObserver
   NS_IMETHOD StyleSheetLoaded(nsCSSStyleSheet* aSheet, bool aWasAlternate,
                               nsresult aStatus) MOZ_OVERRIDE;
 
   virtual nsresult ProcessMETATag(nsIContent* aContent);
 
   // nsIContentSink implementation helpers
-  NS_HIDDEN_(nsresult) WillParseImpl(void);
-  NS_HIDDEN_(nsresult) WillInterruptImpl(void);
-  NS_HIDDEN_(nsresult) WillResumeImpl(void);
-  NS_HIDDEN_(nsresult) DidProcessATokenImpl(void);
-  NS_HIDDEN_(void) WillBuildModelImpl(void);
-  NS_HIDDEN_(void) DidBuildModelImpl(bool aTerminated);
-  NS_HIDDEN_(void) DropParserAndPerfHint(void);
+  nsresult WillParseImpl(void);
+  nsresult WillInterruptImpl(void);
+  nsresult WillResumeImpl(void);
+  nsresult DidProcessATokenImpl(void);
+  void WillBuildModelImpl(void);
+  void DidBuildModelImpl(bool aTerminated);
+  void DropParserAndPerfHint(void);
   bool IsScriptExecutingImpl();
 
   void NotifyAppend(nsIContent* aContent, uint32_t aStartIndex);
 
   // nsIDocumentObserver
   NS_DECL_NSIDOCUMENTOBSERVER_BEGINUPDATE
   NS_DECL_NSIDOCUMENTOBSERVER_ENDUPDATE
 
--- a/content/base/src/nsDocument.h
+++ b/content/base/src/nsDocument.h
@@ -964,63 +964,63 @@ public:
   NS_DECL_NSIDOMXPATHEVALUATOR
 
   virtual nsresult Init();
 
   virtual nsresult CreateElem(const nsAString& aName, nsIAtom *aPrefix,
                               int32_t aNamespaceID,
                               nsIContent **aResult) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(void) Sanitize();
+  virtual void Sanitize();
 
-  virtual NS_HIDDEN_(void) EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
+  virtual void EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
                                                  void *aData);
 
-  virtual NS_HIDDEN_(bool) CanSavePresentation(nsIRequest *aNewRequest);
-  virtual NS_HIDDEN_(void) Destroy();
-  virtual NS_HIDDEN_(void) RemovedFromDocShell();
-  virtual NS_HIDDEN_(already_AddRefed<nsILayoutHistoryState>) GetLayoutHistoryState() const;
+  virtual bool CanSavePresentation(nsIRequest *aNewRequest);
+  virtual void Destroy();
+  virtual void RemovedFromDocShell();
+  virtual already_AddRefed<nsILayoutHistoryState> GetLayoutHistoryState() const;
 
-  virtual NS_HIDDEN_(void) BlockOnload();
-  virtual NS_HIDDEN_(void) UnblockOnload(bool aFireSync);
+  virtual void BlockOnload();
+  virtual void UnblockOnload(bool aFireSync);
 
-  virtual NS_HIDDEN_(void) AddStyleRelevantLink(mozilla::dom::Link* aLink);
-  virtual NS_HIDDEN_(void) ForgetLink(mozilla::dom::Link* aLink);
+  virtual void AddStyleRelevantLink(mozilla::dom::Link* aLink);
+  virtual void ForgetLink(mozilla::dom::Link* aLink);
 
-  NS_HIDDEN_(void) ClearBoxObjectFor(nsIContent* aContent);
+  void ClearBoxObjectFor(nsIContent* aContent);
   already_AddRefed<nsIBoxObject> GetBoxObjectFor(mozilla::dom::Element* aElement,
                                                  mozilla::ErrorResult& aRv) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(Element*)
+  virtual Element*
     GetAnonymousElementByAttribute(nsIContent* aElement,
                                    nsIAtom* aAttrName,
                                    const nsAString& aAttrValue) const;
 
-  virtual NS_HIDDEN_(Element*) ElementFromPointHelper(float aX, float aY,
+  virtual Element* ElementFromPointHelper(float aX, float aY,
                                                       bool aIgnoreRootScrollFrame,
                                                       bool aFlushLayout);
 
-  virtual NS_HIDDEN_(nsresult) NodesFromRectHelper(float aX, float aY,
+  virtual nsresult NodesFromRectHelper(float aX, float aY,
                                                    float aTopSize, float aRightSize,
                                                    float aBottomSize, float aLeftSize,
                                                    bool aIgnoreRootScrollFrame,
                                                    bool aFlushLayout,
                                                    nsIDOMNodeList** aReturn);
 
-  virtual NS_HIDDEN_(void) FlushSkinBindings();
+  virtual void FlushSkinBindings();
 
-  virtual NS_HIDDEN_(nsresult) InitializeFrameLoader(nsFrameLoader* aLoader);
-  virtual NS_HIDDEN_(nsresult) FinalizeFrameLoader(nsFrameLoader* aLoader);
-  virtual NS_HIDDEN_(void) TryCancelFrameLoaderInitialization(nsIDocShell* aShell);
-  virtual NS_HIDDEN_(bool) FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell);
-  virtual NS_HIDDEN_(nsIDocument*)
+  virtual nsresult InitializeFrameLoader(nsFrameLoader* aLoader);
+  virtual nsresult FinalizeFrameLoader(nsFrameLoader* aLoader);
+  virtual void TryCancelFrameLoaderInitialization(nsIDocShell* aShell);
+  virtual bool FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell);
+  virtual nsIDocument*
     RequestExternalResource(nsIURI* aURI,
                             nsINode* aRequestingNode,
                             ExternalResourceLoad** aPendingLoad);
-  virtual NS_HIDDEN_(void)
+  virtual void
     EnumerateExternalResources(nsSubDocEnumFunc aCallback, void* aData);
 
   nsTArray<nsCString> mHostObjectURIs;
 
   // Returns our (lazily-initialized) animation controller.
   // If HasAnimationController is true, this is guaranteed to return non-null.
   nsSMILAnimationController* GetAnimationController() MOZ_OVERRIDE;
 
@@ -1094,19 +1094,19 @@ public:
 
   virtual Element *GetElementById(const nsAString& aElementId) MOZ_OVERRIDE;
   virtual const nsSmallVoidArray* GetAllElementsForId(const nsAString& aElementId) const MOZ_OVERRIDE;
 
   virtual Element *LookupImageElement(const nsAString& aElementId) MOZ_OVERRIDE;
   virtual void MozSetImageElement(const nsAString& aImageElementId,
                                   Element* aElement) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(nsresult) AddImage(imgIRequest* aImage);
-  virtual NS_HIDDEN_(nsresult) RemoveImage(imgIRequest* aImage, uint32_t aFlags);
-  virtual NS_HIDDEN_(nsresult) SetImageLockingState(bool aLocked);
+  virtual nsresult AddImage(imgIRequest* aImage);
+  virtual nsresult RemoveImage(imgIRequest* aImage, uint32_t aFlags);
+  virtual nsresult SetImageLockingState(bool aLocked);
 
   // AddPlugin adds a plugin-related element to mPlugins when the element is
   // added to the tree.
   virtual nsresult AddPlugin(nsIObjectLoadingContent* aPlugin) MOZ_OVERRIDE;
   // RemovePlugin removes a plugin-related element to mPlugins when the
   // element is removed from the tree.
   virtual void RemovePlugin(nsIObjectLoadingContent* aPlugin) MOZ_OVERRIDE;
   // GetPlugins returns the plugin-related elements from
--- a/content/base/src/nsFrameLoader.h
+++ b/content/base/src/nsFrameLoader.h
@@ -169,17 +169,17 @@ public:
   static nsFrameLoader* Create(mozilla::dom::Element* aOwner,
                                bool aNetworkCreated);
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsFrameLoader, nsIFrameLoader)
   NS_DECL_NSIFRAMELOADER
   NS_DECL_NSICONTENTVIEWMANAGER
   NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
-  NS_HIDDEN_(nsresult) CheckForRecursiveLoad(nsIURI* aURI);
+  nsresult CheckForRecursiveLoad(nsIURI* aURI);
   nsresult ReallyStartLoading();
   void Finalize();
   nsIDocShell* GetExistingDocShell() { return mDocShell; }
   mozilla::dom::EventTarget* GetTabChildGlobalAsEventTarget();
   nsresult CreateStaticClone(nsIFrameLoader* aDest);
 
   /**
    * MessageManagerCallback methods that we override.
@@ -367,17 +367,17 @@ private:
   nsresult MaybeCreateDocShell();
   nsresult EnsureMessageManager();
 
   // Properly retrieves documentSize of any subdocument type.
   nsresult GetWindowDimensions(nsRect& aRect);
 
   // Updates the subdocument position and size. This gets called only
   // when we have our own in-process DocShell.
-  NS_HIDDEN_(nsresult) UpdateBaseWindowPositionAndSize(nsSubDocumentFrame *aIFrame);
+  nsresult UpdateBaseWindowPositionAndSize(nsSubDocumentFrame *aIFrame);
   nsresult CheckURILoad(nsIURI* aURI);
   void FireErrorEvent();
   nsresult ReallyStartLoadingInternal();
 
   // Return true if remote browser created; nothing else to do
   bool TryRemoteBrowser();
 
   // Tell the remote browser that it's now "virtually visible"
--- a/content/base/src/nsPropertyTable.cpp
+++ b/content/base/src/nsPropertyTable.cpp
@@ -40,22 +40,22 @@ public:
   PropertyList(nsIAtom*           aName,
                NSPropertyDtorFunc aDtorFunc,
                void*              aDtorData,
                bool               aTransfer) NS_HIDDEN;
   ~PropertyList() NS_HIDDEN;
 
   // Removes the property associated with the given object, and destroys
   // the property value
-  NS_HIDDEN_(bool) DeletePropertyFor(nsPropertyOwner aObject);
+  bool DeletePropertyFor(nsPropertyOwner aObject);
 
   // Destroy all remaining properties (without removing them)
-  NS_HIDDEN_(void) Destroy();
+  void Destroy();
 
-  NS_HIDDEN_(bool) Equals(nsIAtom *aPropertyName)
+  bool Equals(nsIAtom *aPropertyName)
   {
     return mName == aPropertyName;
   }
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
 
   nsCOMPtr<nsIAtom>  mName;           // property name
   PLDHashTable       mObjectValueMap; // map of object/value pairs
--- a/content/base/src/nsPropertyTable.h
+++ b/content/base/src/nsPropertyTable.h
@@ -88,33 +88,33 @@ class nsPropertyTable
    * it will contain the old value after the function returns (the destructor
    * for the old value will not be run in that case). If |aTransfer| is true
    * the property will be transfered to the new table when the property table
    * for |aObject| changes (currently the tables for nodes are owned by their
    * ownerDocument, so if the ownerDocument for a node changes, its property
    * table changes too). If |aTransfer| is false the property will just be
    * deleted instead.
    */
-  NS_HIDDEN_(nsresult) SetProperty(nsPropertyOwner     aObject,
+  nsresult SetProperty(nsPropertyOwner     aObject,
                                    nsIAtom            *aPropertyName,
                                    void               *aPropertyValue,
                                    NSPropertyDtorFunc  aDtor,
                                    void               *aDtorData,
                                    bool                aTransfer = false,
                                    void              **aOldValue = nullptr)
   {
     return SetPropertyInternal(aObject, aPropertyName, aPropertyValue,
                                aDtor, aDtorData, aTransfer, aOldValue);
   }
 
   /**
    * Delete the property |aPropertyName| in the global category for object
    * |aObject|. The property's destructor function will be called.
    */
-  NS_HIDDEN_(nsresult) DeleteProperty(nsPropertyOwner aObject,
+  nsresult DeleteProperty(nsPropertyOwner aObject,
                                       nsIAtom    *aPropertyName);
 
   /**
    * Unset the property |aPropertyName| in the global category for object
    * |aObject|, but do not call the property's destructor function.  The
    * property value is returned.
    */
   void* UnsetProperty(nsPropertyOwner aObject,
@@ -123,49 +123,49 @@ class nsPropertyTable
   {
     return GetPropertyInternal(aObject, aPropertyName, true, aStatus);
   }
 
   /**
    * Deletes all of the properties for object |aObject|, calling the
    * destructor function for each property.
    */
-  NS_HIDDEN_(void) DeleteAllPropertiesFor(nsPropertyOwner aObject);
+  void DeleteAllPropertiesFor(nsPropertyOwner aObject);
 
   /**
    * Transfers all properties for object |aObject| that were set with the
    * |aTransfer| argument as true to |aTable|. Deletes the other properties
    * for object |aObject|, calling the destructor function for each property.
    * If transfering a property fails, this deletes all the properties for
    * object |aObject|.
    */
-  NS_HIDDEN_(nsresult)
+  nsresult
     TransferOrDeleteAllPropertiesFor(nsPropertyOwner aObject,
                                      nsPropertyTable *aOtherTable);
 
   /**
    * Enumerate the properties for object |aObject|.
    * For every property |aCallback| will be called with as arguments |aObject|,
    * the property name, the property value and |aData|.
    */
-  NS_HIDDEN_(void) Enumerate(nsPropertyOwner aObject,
+  void Enumerate(nsPropertyOwner aObject,
                              NSPropertyFunc aCallback, void *aData);
 
   /**
    * Enumerate all the properties.
    * For every property |aCallback| will be called with arguments the owner,
    * the property name, the property value and |aData|.
    */
-  NS_HIDDEN_(void) EnumerateAll(NSPropertyFunc aCallback, void *aData);
+  void EnumerateAll(NSPropertyFunc aCallback, void *aData);
 
   /**
    * Deletes all of the properties for all objects in the property
    * table, calling the destructor function for each property.
    */
-  NS_HIDDEN_(void) DeleteAllProperties();
+  void DeleteAllProperties();
 
   nsPropertyTable() : mPropertyList(nullptr) {}  
   ~nsPropertyTable() {
     DeleteAllProperties();
   }
 
   /**
    * Function useable as destructor function for property data that is
@@ -176,23 +176,23 @@ class nsPropertyTable
                                void *aPropertyValue, void *aData);
 
   class PropertyList;
 
   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
  private:
-  NS_HIDDEN_(void) DestroyPropertyList();
-  NS_HIDDEN_(PropertyList*) GetPropertyListFor(nsIAtom *aPropertyName) const;
-  NS_HIDDEN_(void*) GetPropertyInternal(nsPropertyOwner aObject,
+  void DestroyPropertyList();
+  PropertyList* GetPropertyListFor(nsIAtom *aPropertyName) const;
+  void* GetPropertyInternal(nsPropertyOwner aObject,
                                         nsIAtom    *aPropertyName,
                                         bool        aRemove,
                                         nsresult   *aStatus);
-  NS_HIDDEN_(nsresult) SetPropertyInternal(nsPropertyOwner     aObject,
+  nsresult SetPropertyInternal(nsPropertyOwner     aObject,
                                            nsIAtom            *aPropertyName,
                                            void               *aPropertyValue,
                                            NSPropertyDtorFunc  aDtor,
                                            void               *aDtorData,
                                            bool                aTransfer,
                                            void              **aOldValue);
 
   PropertyList *mPropertyList;
--- a/content/html/content/src/HTMLInputElement.cpp
+++ b/content/html/content/src/HTMLInputElement.cpp
@@ -114,17 +114,17 @@
 NS_IMPL_NS_NEW_HTML_ELEMENT_CHECK_PARSER(Input)
 
 // XXX align=left, hspace, vspace, border? other nav4 attrs
 
 static NS_DEFINE_CID(kXULControllersCID,  NS_XULCONTROLLERS_CID);
 
 // This must come outside of any namespace, or else it won't overload with the
 // double based version in nsMathUtils.h
-inline NS_HIDDEN_(mozilla::Decimal)
+inline mozilla::Decimal
 NS_floorModulo(mozilla::Decimal x, mozilla::Decimal y)
 {
   return (x - y * (x / y).floor());
 }
 
 namespace mozilla {
 namespace dom {
 
--- a/content/html/content/src/HTMLObjectElement.h
+++ b/content/html/content/src/HTMLObjectElement.h
@@ -220,17 +220,17 @@ public:
   {
     return GetContentDocument();
   }
 
 private:
   /**
    * Calls LoadObject with the correct arguments to start the plugin load.
    */
-  NS_HIDDEN_(void) StartObjectLoad(bool aNotify);
+  void StartObjectLoad(bool aNotify);
 
   /**
    * Returns if the element is currently focusable regardless of it's tabindex
    * value. This is used to know the default tabindex value.
    */
   bool IsFocusableForTabIndex();
   
   virtual void GetItemValueText(nsAString& text) MOZ_OVERRIDE;
--- a/content/html/content/src/HTMLSharedObjectElement.h
+++ b/content/html/content/src/HTMLSharedObjectElement.h
@@ -187,17 +187,17 @@ public:
   {
     return GetContentDocument();
   }
 
 private:
   /**
    * Calls LoadObject with the correct arguments to start the plugin load.
    */
-  NS_HIDDEN_(void) StartObjectLoad(bool aNotify);
+  void StartObjectLoad(bool aNotify);
 
   nsIAtom *URIAttrName() const
   {
     return mNodeInfo->Equals(nsGkAtoms::applet) ?
            nsGkAtoms::code :
            nsGkAtoms::src;
   }
 
--- a/content/html/content/src/nsGenericHTMLElement.h
+++ b/content/html/content/src/nsGenericHTMLElement.h
@@ -820,17 +820,17 @@ public:
    * @see GetAttributeMappingFunction
    */
   static void MapScrollingAttributeInto(const nsMappedAttributes* aAttributes,
                                         nsRuleData* aData);
   /**
    * Get the presentation context for this content node.
    * @return the presentation context
    */
-  NS_HIDDEN_(nsPresContext*) GetPresContext();
+  nsPresContext* GetPresContext();
 
   // Form Helper Routines
   /**
    * Find an ancestor of this content node which is a form (could be null)
    * @param aCurrentForm the current form for this node.  If this is
    *        non-null, and no ancestor form is found, and the current form is in
    *        a connected subtree with the node, the current form will be
    *        returned.  This is needed to handle cases when HTML elements have a
@@ -846,30 +846,30 @@ public:
    * See if the document being tested has nav-quirks mode enabled.
    * @param doc the document
    */
   static bool InNavQuirksMode(nsIDocument* aDoc);
 
   /**
    * Locate an nsIEditor rooted at this content node, if there is one.
    */
-  NS_HIDDEN_(nsresult) GetEditor(nsIEditor** aEditor);
+  nsresult GetEditor(nsIEditor** aEditor);
 
   /**
    * Helper method for NS_IMPL_URI_ATTR macro.
    * Gets the absolute URI value of an attribute, by resolving any relative
    * URIs in the attribute against the baseuri of the element. If the attribute
    * isn't a relative URI the value of the attribute is returned as is. Only
    * works for attributes in null namespace.
    *
    * @param aAttr      name of attribute.
    * @param aBaseAttr  name of base attribute.
    * @param aResult    result value [out]
    */
-  NS_HIDDEN_(void) GetURIAttr(nsIAtom* aAttr, nsIAtom* aBaseAttr, nsAString& aResult) const;
+  void GetURIAttr(nsIAtom* aAttr, nsIAtom* aBaseAttr, nsAString& aResult) const;
 
   /**
    * Gets the absolute URI values of an attribute, by resolving any relative
    * URIs in the attribute against the baseuri of the element. If a substring
    * isn't a relative URI, the substring is returned as is. Only works for
    * attributes in null namespace.
    */
   bool GetURIAttr(nsIAtom* aAttr, nsIAtom* aBaseAttr, nsIURI** aURI) const;
@@ -1028,38 +1028,38 @@ protected:
    * Helper method for NS_IMPL_STRING_ATTR macro.
    * Sets the value of an attribute, returns specified default value if the
    * attribute isn't set. Only works for attributes in null namespace.
    *
    * @param aAttr    name of attribute.
    * @param aDefault default-value to return if attribute isn't set.
    * @param aResult  result value [out]
    */
-  NS_HIDDEN_(nsresult) SetAttrHelper(nsIAtom* aAttr, const nsAString& aValue);
+  nsresult SetAttrHelper(nsIAtom* aAttr, const nsAString& aValue);
 
   /**
    * Helper method for NS_IMPL_INT_ATTR macro.
    * Gets the integer-value of an attribute, returns specified default value
    * if the attribute isn't set or isn't set to an integer. Only works for
    * attributes in null namespace.
    *
    * @param aAttr    name of attribute.
    * @param aDefault default-value to return if attribute isn't set.
    */
-  NS_HIDDEN_(int32_t) GetIntAttr(nsIAtom* aAttr, int32_t aDefault) const;
+  int32_t GetIntAttr(nsIAtom* aAttr, int32_t aDefault) const;
 
   /**
    * Helper method for NS_IMPL_INT_ATTR macro.
    * Sets value of attribute to specified integer. Only works for attributes
    * in null namespace.
    *
    * @param aAttr    name of attribute.
    * @param aValue   Integer value of attribute.
    */
-  NS_HIDDEN_(nsresult) SetIntAttr(nsIAtom* aAttr, int32_t aValue);
+  nsresult SetIntAttr(nsIAtom* aAttr, int32_t aValue);
 
   /**
    * Helper method for NS_IMPL_UINT_ATTR macro.
    * Gets the unsigned integer-value of an attribute, returns specified default
    * value if the attribute isn't set or isn't set to an integer. Only works for
    * attributes in null namespace.
    *
    * @param aAttr    name of attribute.
@@ -1106,43 +1106,43 @@ protected:
    * Gets the absolute URI values of an attribute, by resolving any relative
    * URIs in the attribute against the baseuri of the element. If a substring
    * isn't a relative URI, the substring is returned as is. Only works for
    * attributes in null namespace.
    *
    * @param aAttr    name of attribute.
    * @param aResult  result value [out]
    */
-  NS_HIDDEN_(nsresult) GetURIListAttr(nsIAtom* aAttr, nsAString& aResult);
+  nsresult GetURIListAttr(nsIAtom* aAttr, nsAString& aResult);
 
   /**
    * Helper method for NS_IMPL_ENUM_ATTR_DEFAULT_VALUE.
    * Gets the enum value string of an attribute and using a default value if
    * the attribute is missing or the string is an invalid enum value.
    *
    * @param aType     the name of the attribute.
    * @param aDefault  the default value if the attribute is missing or invalid.
    * @param aResult   string corresponding to the value [out].
    */
-  NS_HIDDEN_(void) GetEnumAttr(nsIAtom* aAttr,
+  void GetEnumAttr(nsIAtom* aAttr,
                                const char* aDefault,
                                nsAString& aResult) const;
 
   /**
    * Helper method for NS_IMPL_ENUM_ATTR_DEFAULT_MISSING_INVALID_VALUES.
    * Gets the enum value string of an attribute and using the default missing
    * value if the attribute is missing or the default invalid value if the
    * string is an invalid enum value.
    *
    * @param aType            the name of the attribute.
    * @param aDefaultMissing  the default value if the attribute is missing.
    * @param aDefaultInvalid  the default value if the attribute is invalid.
    * @param aResult          string corresponding to the value [out].
    */
-  NS_HIDDEN_(void) GetEnumAttr(nsIAtom* aAttr,
+  void GetEnumAttr(nsIAtom* aAttr,
                                const char* aDefaultMissing,
                                const char* aDefaultInvalid,
                                nsAString& aResult) const;
 
   /**
    * Locates the nsIEditor associated with this node.  In general this is
    * equivalent to GetEditorInternal(), but for designmode or contenteditable,
    * this may need to get an editor that's not actually on this element's
@@ -1178,17 +1178,17 @@ protected:
   };
 
   /**
    * Returns eTrue if the element has a contentEditable attribute and its value
    * is "true" or an empty string. Returns eFalse if the element has a
    * contentEditable attribute and its value is "false". Otherwise returns
    * eInherit.
    */
-  NS_HIDDEN_(ContentEditableTristate) GetContentEditableValue() const
+  ContentEditableTristate GetContentEditableValue() const
   {
     static const nsIContent::AttrValuesArray values[] =
       { &nsGkAtoms::_false, &nsGkAtoms::_true, &nsGkAtoms::_empty, nullptr };
 
     if (!MayHaveContentEditableAttr())
       return eInherit;
 
     int32_t value = FindAttrValueIn(kNameSpaceID_None,
--- a/content/html/document/src/nsHTMLDocument.h
+++ b/content/html/document/src/nsHTMLDocument.h
@@ -75,19 +75,19 @@ public:
   // nsIHTMLDocument
   virtual void SetCompatibilityMode(nsCompatibility aMode) MOZ_OVERRIDE;
 
   virtual bool IsWriting() MOZ_OVERRIDE
   {
     return mWriteLevel != uint32_t(0);
   }
 
-  virtual NS_HIDDEN_(nsContentList*) GetForms();
+  virtual nsContentList* GetForms();
  
-  virtual NS_HIDDEN_(nsContentList*) GetFormControls();
+  virtual nsContentList* GetFormControls();
  
   // nsIDOMDocument interface
   using nsDocument::CreateElement;
   using nsDocument::CreateElementNS;
   NS_FORWARD_NSIDOMDOCUMENT(nsDocument::)
 
   // And explicitly import the things from nsDocument that we just shadowed
   using nsDocument::GetImplementation;
@@ -150,17 +150,17 @@ public:
   friend class nsAutoEditingState;
 
   void EndUpdate(nsUpdateType aUpdateType) MOZ_OVERRIDE;
 
   virtual nsresult SetEditingState(EditingState aState) MOZ_OVERRIDE;
 
   virtual nsresult Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(void) RemovedFromDocShell() MOZ_OVERRIDE;
+  virtual void RemovedFromDocShell() MOZ_OVERRIDE;
 
   virtual mozilla::dom::Element *GetElementById(const nsAString& aElementId)
   {
     return nsDocument::GetElementById(aElementId);
   }
 
   virtual void DocAddSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const MOZ_OVERRIDE;
   // DocAddSizeOfIncludingThis is inherited from nsIDocument.
--- a/content/xul/document/src/XULDocument.h
+++ b/content/xul/document/src/XULDocument.h
@@ -276,17 +276,17 @@ protected:
     BroadcastAttributeChangeFromOverlay(nsIContent* aNode,
                                         int32_t aNameSpaceID,
                                         nsIAtom* aAttribute,
                                         nsIAtom* aPrefix,
                                         const nsAString& aValue);
 
     already_AddRefed<nsPIWindowRoot> GetWindowRoot();
 
-    static NS_HIDDEN_(void) DirectionChanged(const char* aPrefName, void* aData);
+    static void DirectionChanged(const char* aPrefName, void* aData);
 
     // pseudo constants
     static int32_t gRefCnt;
 
     static nsIAtom** kIdentityAttrs[];
 
     static nsIRDFService* gRDFService;
     static nsIRDFResource* kNC_persist;
--- a/dom/base/nsGlobalWindow.h
+++ b/dom/base/nsGlobalWindow.h
@@ -424,77 +424,77 @@ public:
 
   // nsITouchEventReceiver
   NS_DECL_NSITOUCHEVENTRECEIVER
 
   // nsIInlineEventHandlers
   NS_DECL_NSIINLINEEVENTHANDLERS
 
   // nsPIDOMWindow
-  virtual NS_HIDDEN_(nsPIDOMWindow*) GetPrivateRoot();
+  virtual nsPIDOMWindow* GetPrivateRoot();
 
   // Outer windows only.
-  virtual NS_HIDDEN_(void) ActivateOrDeactivate(bool aActivate);
-  virtual NS_HIDDEN_(void) SetActive(bool aActive);
-  virtual NS_HIDDEN_(void) SetIsBackground(bool aIsBackground);
-  virtual NS_HIDDEN_(void) SetChromeEventHandler(mozilla::dom::EventTarget* aChromeEventHandler);
+  virtual void ActivateOrDeactivate(bool aActivate);
+  virtual void SetActive(bool aActive);
+  virtual void SetIsBackground(bool aIsBackground);
+  virtual void SetChromeEventHandler(mozilla::dom::EventTarget* aChromeEventHandler);
 
   // Outer windows only.
-  virtual NS_HIDDEN_(void) SetInitialPrincipalToSubject();
+  virtual void SetInitialPrincipalToSubject();
 
-  virtual NS_HIDDEN_(PopupControlState) PushPopupControlState(PopupControlState state, bool aForce) const;
-  virtual NS_HIDDEN_(void) PopPopupControlState(PopupControlState state) const;
-  virtual NS_HIDDEN_(PopupControlState) GetPopupControlState() const;
+  virtual PopupControlState PushPopupControlState(PopupControlState state, bool aForce) const;
+  virtual void PopPopupControlState(PopupControlState state) const;
+  virtual PopupControlState GetPopupControlState() const;
 
   virtual already_AddRefed<nsISupports> SaveWindowState();
-  virtual NS_HIDDEN_(nsresult) RestoreWindowState(nsISupports *aState);
-  virtual NS_HIDDEN_(void) SuspendTimeouts(uint32_t aIncrease = 1,
+  virtual nsresult RestoreWindowState(nsISupports *aState);
+  virtual void SuspendTimeouts(uint32_t aIncrease = 1,
                                            bool aFreezeChildren = true);
-  virtual NS_HIDDEN_(nsresult) ResumeTimeouts(bool aThawChildren = true);
-  virtual NS_HIDDEN_(uint32_t) TimeoutSuspendCount();
-  virtual NS_HIDDEN_(nsresult) FireDelayedDOMEvents();
-  virtual NS_HIDDEN_(bool) IsFrozen() const
+  virtual nsresult ResumeTimeouts(bool aThawChildren = true);
+  virtual uint32_t TimeoutSuspendCount();
+  virtual nsresult FireDelayedDOMEvents();
+  virtual bool IsFrozen() const
   {
     return mIsFrozen;
   }
-  virtual NS_HIDDEN_(bool) IsRunningTimeout() { return mTimeoutFiringDepth > 0; }
+  virtual bool IsRunningTimeout() { return mTimeoutFiringDepth > 0; }
 
   // Outer windows only.
-  virtual NS_HIDDEN_(bool) WouldReuseInnerWindow(nsIDocument* aNewDocument);
+  virtual bool WouldReuseInnerWindow(nsIDocument* aNewDocument);
 
-  virtual NS_HIDDEN_(void) SetDocShell(nsIDocShell* aDocShell);
+  virtual void SetDocShell(nsIDocShell* aDocShell);
   virtual void DetachFromDocShell();
-  virtual NS_HIDDEN_(nsresult) SetNewDocument(nsIDocument *aDocument,
+  virtual nsresult SetNewDocument(nsIDocument *aDocument,
                                               nsISupports *aState,
                                               bool aForceReuseInnerWindow);
 
   // Outer windows only.
   void DispatchDOMWindowCreated();
 
-  virtual NS_HIDDEN_(void) SetOpenerWindow(nsIDOMWindow* aOpener,
+  virtual void SetOpenerWindow(nsIDOMWindow* aOpener,
                                            bool aOriginalOpener);
 
   // Outer windows only.
-  virtual NS_HIDDEN_(void) EnsureSizeUpToDate();
+  virtual void EnsureSizeUpToDate();
 
-  virtual NS_HIDDEN_(void) EnterModalState();
-  virtual NS_HIDDEN_(void) LeaveModalState();
+  virtual void EnterModalState();
+  virtual void LeaveModalState();
 
   // Outer windows only.
-  virtual NS_HIDDEN_(bool) CanClose();
-  virtual NS_HIDDEN_(void) ForceClose();
+  virtual bool CanClose();
+  virtual void ForceClose();
 
-  virtual NS_HIDDEN_(void) MaybeUpdateTouchState();
-  virtual NS_HIDDEN_(void) UpdateTouchState();
-  virtual NS_HIDDEN_(bool) DispatchCustomEvent(const char *aEventName);
-  virtual NS_HIDDEN_(bool) DispatchResizeEvent(const nsIntSize& aSize);
-  virtual NS_HIDDEN_(void) RefreshCompartmentPrincipal();
-  virtual NS_HIDDEN_(nsresult) SetFullScreenInternal(bool aIsFullScreen, bool aRequireTrust);
+  virtual void MaybeUpdateTouchState();
+  virtual void UpdateTouchState();
+  virtual bool DispatchCustomEvent(const char *aEventName);
+  virtual bool DispatchResizeEvent(const nsIntSize& aSize);
+  virtual void RefreshCompartmentPrincipal();
+  virtual nsresult SetFullScreenInternal(bool aIsFullScreen, bool aRequireTrust);
 
-  virtual NS_HIDDEN_(void) SetHasGamepadEventListener(bool aHasGamepad = true);
+  virtual void SetHasGamepadEventListener(bool aHasGamepad = true);
 
   // nsIInterfaceRequestor
   NS_DECL_NSIINTERFACEREQUESTOR
 
   // WebIDL interface.
   already_AddRefed<nsIDOMWindow> IndexedGetter(uint32_t aIndex, bool& aFound);
 
   void GetSupportedNames(nsTArray<nsString>& aNames);
@@ -630,20 +630,20 @@ public:
                                                                    nsIDOMEventTarget)
 
 #ifdef DEBUG
   // Call Unlink on this window. This may cause bad things to happen, so use
   // with caution.
   void RiskyUnlink();
 #endif
 
-  virtual NS_HIDDEN_(JSObject*)
+  virtual JSObject*
     GetCachedXBLPrototypeHandler(nsXBLPrototypeHandler* aKey);
 
-  virtual NS_HIDDEN_(void)
+  virtual void
     CacheXBLPrototypeHandler(nsXBLPrototypeHandler* aKey,
                              JS::Handle<JSObject*> aHandler);
 
   virtual bool TakeFocus(bool aFocus, uint32_t aFocusMethod);
   virtual void SetReadyForFocus();
   virtual void PageHidden();
   virtual nsresult DispatchAsyncHashchange(nsIURI *aOldURI, nsIURI *aNewURI);
   virtual nsresult DispatchSyncPopState();
@@ -1149,17 +1149,17 @@ protected:
    * @param aExtraArgument Another way to pass arguments in.  This is mutually
    *        exclusive with the argv/argc approach.
    *
    * @param aJSCallerContext The calling script's context. This must be null
    *        when aCalledNoScript is true.
    *
    * @param aReturn [out] The window that was opened, if any.
    */
-  NS_HIDDEN_(nsresult) OpenInternal(const nsAString& aUrl,
+  nsresult OpenInternal(const nsAString& aUrl,
                                     const nsAString& aName,
                                     const nsAString& aOptions,
                                     bool aDialog,
                                     bool aContentModal,
                                     bool aCalledNoScript,
                                     bool aDoJSFixups,
                                     bool aNavigate,
                                     nsIArray *argv,
--- a/dom/base/nsPIDOMWindow.h
+++ b/dom/base/nsPIDOMWindow.h
@@ -183,17 +183,17 @@ public:
   nsIDocument* GetDoc()
   {
     if (!mDoc) {
       MaybeCreateDoc();
     }
     return mDoc;
   }
 
-  virtual NS_HIDDEN_(bool) IsRunningTimeout() = 0;
+  virtual bool IsRunningTimeout() = 0;
 
   // Audio API
   bool GetAudioMuted() const;
   void SetAudioMuted(bool aMuted);
 
   float GetAudioVolume() const;
   nsresult SetAudioVolume(float aVolume);
 
--- a/dom/xbl/nsBindingManager.h
+++ b/dom/xbl/nsBindingManager.h
@@ -113,17 +113,17 @@ public:
    * the characteristics of the medium, and return whether this rule
    * processor's rules have changed (e.g., because of media queries).
    */
   nsresult MediumFeaturesChanged(nsPresContext* aPresContext,
                                  bool* aRulesChanged);
 
   void AppendAllSheets(nsTArray<nsCSSStyleSheet*>& aArray);
 
-  NS_HIDDEN_(void) Traverse(nsIContent *aContent,
+  void Traverse(nsIContent *aContent,
                             nsCycleCollectionTraversalCallback &cb);
 
   NS_DECL_CYCLE_COLLECTION_CLASS(nsBindingManager)
 
   // Notify the binding manager when an outermost update begins and
   // ends.  The end method can execute script.
   void BeginOutermostUpdate();
   void EndOutermostUpdate();
--- a/gfx/thebes/gfxFont.h
+++ b/gfx/thebes/gfxFont.h
@@ -3773,11 +3773,11 @@ protected:
 
     static bool FontResolverProc(const nsAString& aName, void *aClosure);
 
     static bool FindPlatformFont(const nsAString& aName,
                                    const nsACString& aGenericName,
                                    bool aUseFontSet,
                                    void *closure);
 
-    static NS_HIDDEN_(nsILanguageAtomService*) gLangService;
+    static nsILanguageAtomService* gLangService;
 };
 #endif
--- a/image/decoders/icon/android/nsIconChannel.h
+++ b/image/decoders/icon/android/nsIconChannel.h
@@ -27,17 +27,17 @@ class nsIconChannel MOZ_FINAL : public n
     nsIconChannel() {}
     ~nsIconChannel() {}
 
     /**
      * Called by nsIconProtocolHandler after it creates this channel.
      * Must be called before calling any other function on this object.
      * If this method fails, no other function must be called on this object.
      */
-    NS_HIDDEN_(nsresult) Init(nsIURI* aURI);
+    nsresult Init(nsIURI* aURI);
   private:
     /**
      * The channel to the temp icon file (e.g. to /tmp/2qy9wjqw.html).
      * Will always be non-null after a successful Init.
      */
     nsCOMPtr<nsIChannel> mRealChannel;
 };
 
--- a/image/decoders/icon/gtk/nsIconChannel.h
+++ b/image/decoders/icon/gtk/nsIconChannel.h
@@ -29,17 +29,17 @@ class nsIconChannel MOZ_FINAL : public n
 
     static void Shutdown();
 
     /**
      * Called by nsIconProtocolHandler after it creates this channel.
      * Must be called before calling any other function on this object.
      * If this method fails, no other function must be called on this object.
      */
-    NS_HIDDEN_(nsresult) Init(nsIURI* aURI);
+    nsresult Init(nsIURI* aURI);
   private:
     /**
      * The channel to the temp icon file (e.g. to /tmp/2qy9wjqw.html).
      * Will always be non-null after a successful Init.
      */
     nsCOMPtr<nsIChannel> mRealChannel;
 
     /**
--- a/image/decoders/icon/qt/nsIconChannel.h
+++ b/image/decoders/icon/qt/nsIconChannel.h
@@ -28,17 +28,17 @@ class nsIconChannel MOZ_FINAL : public n
     nsIconChannel() {}
     ~nsIconChannel() {}
 
     /**
      * Called by nsIconProtocolHandler after it creates this channel.
      * Must be called before calling any other function on this object.
      * If this method fails, no other function must be called on this object.
      */
-    NS_HIDDEN_(nsresult) Init(nsIURI* aURI);
+    nsresult Init(nsIURI* aURI);
   private:
     /**
      * The channel to the temp icon file (e.g. to /tmp/2qy9wjqw.html).
      * Will always be non-null after a successful Init.
      */
     nsCOMPtr<nsIChannel> mRealChannel;
 };
 
--- a/intl/locale/src/nsLanguageAtomService.h
+++ b/intl/locale/src/nsLanguageAtomService.h
@@ -14,31 +14,31 @@
   {0xB7C65853, 0x2996, 0x435E, {0x96, 0x54, 0xDC, 0xC1, 0x78, 0xAA, 0xB4, 0x8C}}
 
 class nsLanguageAtomService MOZ_FINAL : public nsILanguageAtomService
 {
 public:
   NS_DECL_ISUPPORTS
 
   // nsILanguageAtomService
-  virtual NS_HIDDEN_(nsIAtom*)
+  virtual nsIAtom*
     LookupLanguage(const nsACString &aLanguage, nsresult *aError);
 
-  virtual NS_HIDDEN_(already_AddRefed<nsIAtom>)
+  virtual already_AddRefed<nsIAtom>
     LookupCharSet(const nsACString& aCharSet);
 
-  virtual NS_HIDDEN_(nsIAtom*) GetLocaleLanguage(nsresult *aError);
+  virtual nsIAtom* GetLocaleLanguage(nsresult *aError);
 
-  virtual NS_HIDDEN_(nsIAtom*) GetLanguageGroup(nsIAtom *aLanguage,
+  virtual nsIAtom* GetLanguageGroup(nsIAtom *aLanguage,
                                                 nsresult *aError);
 
   nsLanguageAtomService() NS_HIDDEN;
 
 private:
   NS_HIDDEN ~nsLanguageAtomService() { }
 
 protected:
-  NS_HIDDEN_(nsresult) InitLangGroupTable();
+  nsresult InitLangGroupTable();
 
   nsInterfaceHashtable<nsISupportsHashKey, nsIAtom> mLangToGroup;
   nsCOMPtr<nsIStringBundle> mLangGroups;
   nsCOMPtr<nsIAtom> mLocaleLanguage;
 };
--- a/layout/base/RestyleManager.h
+++ b/layout/base/RestyleManager.h
@@ -89,35 +89,35 @@ public:
   /**
    * Reparent the style contexts of this frame subtree.  The parent frame of
    * aFrame must be changed to the new parent before this function is called;
    * the new parent style context will be automatically computed based on the
    * new position in the frame tree.
    *
    * @param aFrame the root of the subtree to reparent.  Must not be null.
    */
-  NS_HIDDEN_(nsresult) ReparentStyleContext(nsIFrame* aFrame);
+  nsresult ReparentStyleContext(nsIFrame* aFrame);
 
   /**
    * Re-resolve the style contexts for a frame tree, building
    * aChangeList based on the resulting style changes, plus aMinChange
    * applied to aFrame.
    */
-  NS_HIDDEN_(void)
+  void
     ComputeStyleChangeFor(nsIFrame* aFrame,
                           nsStyleChangeList* aChangeList,
                           nsChangeHint aMinChange,
                           RestyleTracker& aRestyleTracker,
                           bool aRestyleDescendants);
 
 #ifdef DEBUG
   /**
    * DEBUG ONLY method to verify integrity of style tree versus frame tree
    */
-  NS_HIDDEN_(void) DebugVerifyStyleTree(nsIFrame* aFrame);
+  void DebugVerifyStyleTree(nsIFrame* aFrame);
 #endif
 
   // Note: It's the caller's responsibility to make sure to wrap a
   // ProcessRestyledFrames call in a view update batch and a script blocker.
   // This function does not call ProcessAttachedQueue() on the binding manager.
   // If the caller wants that to happen synchronously, it needs to handle that
   // itself.
   nsresult ProcessRestyledFrames(nsStyleChangeList& aRestyleArray);
--- a/layout/base/nsFrameManager.cpp
+++ b/layout/base/nsFrameManager.cpp
@@ -82,37 +82,37 @@ static const PLDHashTableOps Placeholder
 // XXXldb This seems too complicated for what I think it's doing, and it
 // should also be using pldhash rather than plhash to use less memory.
 
 class nsFrameManagerBase::UndisplayedMap {
 public:
   UndisplayedMap(uint32_t aNumBuckets = 16) NS_HIDDEN;
   ~UndisplayedMap(void) NS_HIDDEN;
 
-  NS_HIDDEN_(UndisplayedNode*) GetFirstNode(nsIContent* aParentContent);
+  UndisplayedNode* GetFirstNode(nsIContent* aParentContent);
 
-  NS_HIDDEN_(nsresult) AddNodeFor(nsIContent* aParentContent,
+  nsresult AddNodeFor(nsIContent* aParentContent,
                                   nsIContent* aChild, nsStyleContext* aStyle);
 
-  NS_HIDDEN_(void) RemoveNodeFor(nsIContent* aParentContent,
+  void RemoveNodeFor(nsIContent* aParentContent,
                                  UndisplayedNode* aNode);
 
-  NS_HIDDEN_(void) RemoveNodesFor(nsIContent* aParentContent);
+  void RemoveNodesFor(nsIContent* aParentContent);
 
   // Removes all entries from the hash table
-  NS_HIDDEN_(void)  Clear(void);
+  void  Clear(void);
 
 protected:
   /**
    * Gets the entry for the provided parent content. If the content
    * is a <xbl:children> element, |**aParentContent| is set to
    * the parent of the children element.
    */
-  NS_HIDDEN_(PLHashEntry**) GetEntryFor(nsIContent** aParentContent);
-  NS_HIDDEN_(void)          AppendNodeFor(UndisplayedNode* aNode,
+  PLHashEntry** GetEntryFor(nsIContent** aParentContent);
+  void          AppendNodeFor(UndisplayedNode* aNode,
                                           nsIContent* aParentContent);
 
   PLHashTable*  mTable;
   PLHashEntry** mLastLookup;
 };
 
 //----------------------------------------------------------------------
 
--- a/layout/base/nsFrameManager.h
+++ b/layout/base/nsFrameManager.h
@@ -84,82 +84,82 @@ public:
   }
   ~nsFrameManager() NS_HIDDEN;
 
   /*
    * After Destroy is called, it is an error to call any FrameManager methods.
    * Destroy should be called when the frame tree managed by the frame
    * manager is no longer being displayed.
    */
-  NS_HIDDEN_(void) Destroy();
+  void Destroy();
 
   // Placeholder frame functions
-  NS_HIDDEN_(nsPlaceholderFrame*) GetPlaceholderFrameFor(const nsIFrame* aFrame);
-  NS_HIDDEN_(nsresult)
+  nsPlaceholderFrame* GetPlaceholderFrameFor(const nsIFrame* aFrame);
+  nsresult
     RegisterPlaceholderFrame(nsPlaceholderFrame* aPlaceholderFrame);
 
-  NS_HIDDEN_(void)
+  void
     UnregisterPlaceholderFrame(nsPlaceholderFrame* aPlaceholderFrame);
 
-  NS_HIDDEN_(void)      ClearPlaceholderFrameMap();
+  void      ClearPlaceholderFrameMap();
 
   // Mapping undisplayed content
-  NS_HIDDEN_(nsStyleContext*) GetUndisplayedContent(nsIContent* aContent);
-  NS_HIDDEN_(mozilla::UndisplayedNode*)
+  nsStyleContext* GetUndisplayedContent(nsIContent* aContent);
+  mozilla::UndisplayedNode*
     GetAllUndisplayedContentIn(nsIContent* aParentContent);
-  NS_HIDDEN_(void) SetUndisplayedContent(nsIContent* aContent,
+  void SetUndisplayedContent(nsIContent* aContent,
                                          nsStyleContext* aStyleContext);
-  NS_HIDDEN_(void) ChangeUndisplayedContent(nsIContent* aContent,
+  void ChangeUndisplayedContent(nsIContent* aContent,
                                             nsStyleContext* aStyleContext);
-  NS_HIDDEN_(void) ClearUndisplayedContentIn(nsIContent* aContent,
+  void ClearUndisplayedContentIn(nsIContent* aContent,
                                              nsIContent* aParentContent);
-  NS_HIDDEN_(void) ClearAllUndisplayedContentIn(nsIContent* aParentContent);
+  void ClearAllUndisplayedContentIn(nsIContent* aParentContent);
 
   // Functions for manipulating the frame model
-  NS_HIDDEN_(void) AppendFrames(nsContainerFrame* aParentFrame,
-                                ChildListID       aListID,
-                                nsFrameList&      aFrameList);
+  void AppendFrames(nsContainerFrame* aParentFrame,
+                    ChildListID       aListID,
+                    nsFrameList&      aFrameList);
 
-  NS_HIDDEN_(void) InsertFrames(nsContainerFrame* aParentFrame,
-                                ChildListID       aListID,
-                                nsIFrame*         aPrevFrame,
-                                nsFrameList&      aFrameList);
+  void InsertFrames(nsContainerFrame* aParentFrame,
+                    ChildListID       aListID,
+                    nsIFrame*         aPrevFrame,
+                    nsFrameList&      aFrameList);
 
-  NS_HIDDEN_(void) RemoveFrame(ChildListID     aListID,
-                               nsIFrame*       aOldFrame);
+  void RemoveFrame(ChildListID     aListID,
+                   nsIFrame*       aOldFrame);
 
   /*
    * Notification that a frame is about to be destroyed. This allows any
    * outstanding references to the frame to be cleaned up.
    */
-  NS_HIDDEN_(void)     NotifyDestroyingFrame(nsIFrame* aFrame);
+  void     NotifyDestroyingFrame(nsIFrame* aFrame);
 
   /*
    * Capture/restore frame state for the frame subtree rooted at aFrame.
    * aState is the document state storage object onto which each frame
    * stores its state.  Callers of CaptureFrameState are responsible for
    * traversing next continuations of special siblings of aFrame as
    * needed; this method will only work with actual frametree descendants
    * of aFrame.
    */
 
-  NS_HIDDEN_(void) CaptureFrameState(nsIFrame*              aFrame,
+  void CaptureFrameState(nsIFrame*              aFrame,
                                      nsILayoutHistoryState* aState);
 
-  NS_HIDDEN_(void) RestoreFrameState(nsIFrame*              aFrame,
+  void RestoreFrameState(nsIFrame*              aFrame,
                                      nsILayoutHistoryState* aState);
 
   /*
    * Add/restore state for one frame
    */
-  NS_HIDDEN_(void) CaptureFrameStateFor(nsIFrame*              aFrame,
+  void CaptureFrameStateFor(nsIFrame*              aFrame,
                                         nsILayoutHistoryState* aState);
 
-  NS_HIDDEN_(void) RestoreFrameStateFor(nsIFrame*              aFrame,
+  void RestoreFrameStateFor(nsIFrame*              aFrame,
                                         nsILayoutHistoryState* aState);
 
-  NS_HIDDEN_(nsIPresShell*) GetPresShell() const { return mPresShell; }
-  NS_HIDDEN_(nsPresContext*) GetPresContext() const {
+  nsIPresShell* GetPresShell() const { return mPresShell; }
+  nsPresContext* GetPresContext() const {
     return mPresShell->GetPresContext();
   }
 };
 
 #endif
--- a/layout/base/nsFrameManagerBase.h
+++ b/layout/base/nsFrameManagerBase.h
@@ -41,18 +41,18 @@ public:
 
   bool IsDestroyingFrames() { return mIsDestroyingFrames; }
 
   /*
    * Gets and sets the root frame (typically the viewport). The lifetime of the
    * root frame is controlled by the frame manager. When the frame manager is
    * destroyed, it destroys the entire frame hierarchy.
    */
-  NS_HIDDEN_(nsIFrame*) GetRootFrame() const { return mRootFrame; }
-  NS_HIDDEN_(void)      SetRootFrame(nsIFrame* aRootFrame)
+  nsIFrame* GetRootFrame() const { return mRootFrame; }
+  void      SetRootFrame(nsIFrame* aRootFrame)
   {
     NS_ASSERTION(!mRootFrame, "already have a root frame");
     mRootFrame = aRootFrame;
   }
 
   static uint32_t GetGlobalGenerationNumber() { return sGlobalGenerationNumber; }
 
 protected:
--- a/layout/base/nsIPresShell.h
+++ b/layout/base/nsIPresShell.h
@@ -186,31 +186,31 @@ protected:
 public:
   /**
    * All callers are responsible for calling |Destroy| after calling
    * |EndObservingDocument|.  It needs to be separate only because form
    * controls incorrectly store their data in the frames rather than the
    * content model and printing calls |EndObservingDocument| multiple
    * times to make form controls behave nicely when printed.
    */
-  virtual NS_HIDDEN_(void) Destroy() = 0;
+  virtual void Destroy() = 0;
 
   bool IsDestroying() { return mIsDestroying; }
 
   /**
    * Make a one-way transition into a "zombie" state.  In this state,
    * no reflow is done, no painting is done, and no refresh driver
    * ticks are processed.  This is a dangerous state: it can leave
    * areas of the composition target unpainted if callers aren't
    * careful.  (Don't let your zombie presshell out of the shed.)
    *
    * This is used in cases where a presshell is created for reasons
    * other than reflow/painting.
    */
-  virtual NS_HIDDEN_(void) MakeZombie() = 0;
+  virtual void MakeZombie() = 0;
 
   /**
    * All frames owned by the shell are allocated from an arena.  They
    * are also recycled using free lists.  Separate free lists are
    * maintained for each frame type (aID), which must always correspond
    * to the same aSize value.  AllocateFrame returns zero-filled memory.
    * AllocateFrame is infallible and will abort on out-of-memory.
    */
@@ -322,66 +322,66 @@ public:
 
 #endif
 
   /* Enable/disable author style level. Disabling author style disables the entire
    * author level of the cascade, including the HTML preshint level.
    */
   // XXX these could easily be inlined, but there is a circular #include
   // problem with nsStyleSet.
-  NS_HIDDEN_(void) SetAuthorStyleDisabled(bool aDisabled);
-  NS_HIDDEN_(bool) GetAuthorStyleDisabled() const;
+  void SetAuthorStyleDisabled(bool aDisabled);
+  bool GetAuthorStyleDisabled() const;
 
   /*
    * Called when stylesheets are added/removed/enabled/disabled to rebuild
    * all style data for a given pres shell without necessarily reconstructing
    * all of the frames.  This will not reconstruct style synchronously; if
    * you need to do that, call FlushPendingNotifications to flush out style
    * reresolves.
    * // XXXbz why do we have this on the interface anyway?  The only consumer
    * is calling AddOverrideStyleSheet/RemoveOverrideStyleSheet, and I think
    * those should just handle reconstructing style data...
    */
-  virtual NS_HIDDEN_(void) ReconstructStyleDataExternal();
-  NS_HIDDEN_(void) ReconstructStyleDataInternal();
+  virtual void ReconstructStyleDataExternal();
+  void ReconstructStyleDataInternal();
 #ifdef MOZILLA_INTERNAL_API
   void ReconstructStyleData() { ReconstructStyleDataInternal(); }
 #else
   void ReconstructStyleData() { ReconstructStyleDataExternal(); }
 #endif
 
   /** Setup all style rules required to implement preferences
    * - used for background/text/link colors and link underlining
    *    may be extended for any prefs that are implemented via style rules
    * - aForceReflow argument is used to force a full reframe to make the rules show
    *   (only used when the current page needs to reflect changed pref rules)
    *
    * - initially created for bugs 31816, 20760, 22963
    */
-  virtual NS_HIDDEN_(nsresult) SetPreferenceStyleRules(bool aForceReflow) = 0;
+  virtual nsresult SetPreferenceStyleRules(bool aForceReflow) = 0;
 
   /**
    * FrameSelection will return the Frame based selection API.
    * You cannot go back and forth anymore with QI between nsIDOM sel and
    * nsIFrame sel.
    */
   already_AddRefed<nsFrameSelection> FrameSelection();
 
   /**
    * ConstFrameSelection returns an object which methods are safe to use for
    * example in nsIFrame code.
    */
   const nsFrameSelection* ConstFrameSelection() const { return mSelection; }
 
   // Make shell be a document observer.  If called after Destroy() has
   // been called on the shell, this will be ignored.
-  virtual NS_HIDDEN_(void) BeginObservingDocument() = 0;
+  virtual void BeginObservingDocument() = 0;
 
   // Make shell stop being a document observer
-  virtual NS_HIDDEN_(void) EndObservingDocument() = 0;
+  virtual void EndObservingDocument() = 0;
 
   /**
    * Return whether Initialize() was previously called.
    */
   bool DidInitialize() const { return mDidInitialize; }
 
   /**
    * Perform initialization. Constructs the frame for the root content
@@ -389,49 +389,49 @@ public:
    * specified width and height.
    *
    * The coordinates for aWidth and aHeight must be in standard nscoords.
    *
    * Callers of this method must hold a reference to this shell that
    * is guaranteed to survive through arbitrary script execution.
    * Calling Initialize can execute arbitrary script.
    */
-  virtual NS_HIDDEN_(nsresult) Initialize(nscoord aWidth, nscoord aHeight) = 0;
+  virtual nsresult Initialize(nscoord aWidth, nscoord aHeight) = 0;
 
   /**
    * Reflow the frame model into a new width and height.  The
    * coordinates for aWidth and aHeight must be in standard nscoord's.
    */
-  virtual NS_HIDDEN_(nsresult) ResizeReflow(nscoord aWidth, nscoord aHeight) = 0;
+  virtual nsresult ResizeReflow(nscoord aWidth, nscoord aHeight) = 0;
   /**
    * Reflow, and also change presshell state so as to only permit
    * reflowing off calls to ResizeReflowOverride() in the future.
    * ResizeReflow() calls are ignored after ResizeReflowOverride().
    */
-  virtual NS_HIDDEN_(nsresult) ResizeReflowOverride(nscoord aWidth, nscoord aHeight) = 0;
+  virtual nsresult ResizeReflowOverride(nscoord aWidth, nscoord aHeight) = 0;
 
   /**
    * Returns true if ResizeReflowOverride has been called.
    */
   virtual bool GetIsViewportOverridden() = 0;
 
   /**
    * Return true if the presshell expects layout flush.
    */
   virtual bool IsLayoutFlushObserver() = 0;
 
   /**
    * Called when document load completes.
    */
-  virtual NS_HIDDEN_(void) LoadComplete() = 0;
+  virtual void LoadComplete() = 0;
 
   /**
    * This calls through to the frame manager to get the root frame.
    */
-  virtual NS_HIDDEN_(nsIFrame*) GetRootFrameExternal() const;
+  virtual nsIFrame* GetRootFrameExternal() const;
   nsIFrame* GetRootFrame() const {
 #ifdef MOZILLA_INTERNAL_API
     return mFrameManager->GetRootFrame();
 #else
     return GetRootFrameExternal();
 #endif
   }
 
@@ -460,47 +460,47 @@ public:
    */
   enum ScrollDirection { eHorizontal, eVertical, eEither };
   nsIScrollableFrame* GetFrameToScrollAsScrollable(ScrollDirection aDirection);
 
   /**
    * Returns the page sequence frame associated with the frame hierarchy.
    * Returns nullptr if not a paginated view.
    */
-  virtual NS_HIDDEN_(nsIPageSequenceFrame*) GetPageSequenceFrame() const = 0;
+  virtual nsIPageSequenceFrame* GetPageSequenceFrame() const = 0;
 
   /**
    * Gets the real primary frame associated with the content object.
    *
    * In the case of absolutely positioned elements and floated elements,
    * the real primary frame is the frame that is out of the flow and not the
    * placeholder frame.
    */
-  virtual NS_HIDDEN_(nsIFrame*) GetRealPrimaryFrameFor(nsIContent* aContent) const = 0;
+  virtual nsIFrame* GetRealPrimaryFrameFor(nsIContent* aContent) const = 0;
 
   /**
    * Gets the placeholder frame associated with the specified frame. This is
    * a helper frame that forwards the request to the frame manager.
    */
-  virtual NS_HIDDEN_(nsIFrame*) GetPlaceholderFrameFor(nsIFrame* aFrame) const = 0;
+  virtual nsIFrame* GetPlaceholderFrameFor(nsIFrame* aFrame) const = 0;
 
   /**
    * Tell the pres shell that a frame needs to be marked dirty and needs
    * Reflow.  It's OK if this is an ancestor of the frame needing reflow as
    * long as the ancestor chain between them doesn't cross a reflow root.  The
    * bit to add should be either NS_FRAME_IS_DIRTY or
    * NS_FRAME_HAS_DIRTY_CHILDREN (but not both!).
    */
   enum IntrinsicDirty {
     // XXXldb eResize should be renamed
     eResize,     // don't mark any intrinsic widths dirty
     eTreeChange, // mark intrinsic widths dirty on aFrame and its ancestors
     eStyleChange // Do eTreeChange, plus all of aFrame's descendants
   };
-  virtual NS_HIDDEN_(void) FrameNeedsReflow(nsIFrame *aFrame,
+  virtual void FrameNeedsReflow(nsIFrame *aFrame,
                                             IntrinsicDirty aIntrinsicDirty,
                                             nsFrameState aBitToAdd) = 0;
 
   /**
    * Calls FrameNeedsReflow on all fixed position children of the root frame.
    */
   virtual void MarkFixedFramesForReflow(IntrinsicDirty aIntrinsicDirty);
 
@@ -510,88 +510,88 @@ public:
    * to the nearest ancestor with a dirty subtree, or to the reflow root
    * currently being reflowed if no such ancestor exists (inclusive).  This is
    * to be done immediately after reflow of the current reflow root completes.
    * This method must only be called during reflow, and the frame it's being
    * called on must be in the process of being reflowed when it's called.  This
    * method doesn't mark any intrinsic widths dirty and doesn't add any bits
    * other than NS_FRAME_HAS_DIRTY_CHILDREN.
    */
-  virtual NS_HIDDEN_(void) FrameNeedsToContinueReflow(nsIFrame *aFrame) = 0;
+  virtual void FrameNeedsToContinueReflow(nsIFrame *aFrame) = 0;
 
-  virtual NS_HIDDEN_(void) CancelAllPendingReflows() = 0;
+  virtual void CancelAllPendingReflows() = 0;
 
   /**
    * Recreates the frames for a node
    */
-  virtual NS_HIDDEN_(nsresult) RecreateFramesFor(nsIContent* aContent) = 0;
+  virtual nsresult RecreateFramesFor(nsIContent* aContent) = 0;
 
   void PostRecreateFramesFor(mozilla::dom::Element* aElement);
   void RestyleForAnimation(mozilla::dom::Element* aElement,
                            nsRestyleHint aHint);
 
   // ShadowRoot has APIs that can change styles so we only
   // want to restyle elements in the ShadowRoot and not the whole
   // document.
   virtual void RestyleShadowRoot(mozilla::dom::ShadowRoot* aShadowRoot) = 0;
 
   /**
    * Determine if it is safe to flush all pending notifications
    * @param aIsSafeToFlush true if it is safe, false otherwise.
    *
    */
-  virtual NS_HIDDEN_(bool) IsSafeToFlush() const = 0;
+  virtual bool IsSafeToFlush() const = 0;
 
   /**
    * Flush pending notifications of the type specified.  This method
    * will not affect the content model; it'll just affect style and
    * frames. Callers that actually want up-to-date presentation (other
    * than the document itself) should probably be calling
    * nsIDocument::FlushPendingNotifications.
    *
    * @param aType the type of notifications to flush
    */
-  virtual NS_HIDDEN_(void) FlushPendingNotifications(mozFlushType aType) = 0;
-  virtual NS_HIDDEN_(void) FlushPendingNotifications(mozilla::ChangesToFlush aType) = 0;
+  virtual void FlushPendingNotifications(mozFlushType aType) = 0;
+  virtual void FlushPendingNotifications(mozilla::ChangesToFlush aType) = 0;
 
   /**
    * Callbacks will be called even if reflow itself fails for
    * some reason.
    */
-  virtual NS_HIDDEN_(nsresult) PostReflowCallback(nsIReflowCallback* aCallback) = 0;
-  virtual NS_HIDDEN_(void) CancelReflowCallback(nsIReflowCallback* aCallback) = 0;
+  virtual nsresult PostReflowCallback(nsIReflowCallback* aCallback) = 0;
+  virtual void CancelReflowCallback(nsIReflowCallback* aCallback) = 0;
 
-  virtual NS_HIDDEN_(void) ClearFrameRefs(nsIFrame* aFrame) = 0;
+  virtual void ClearFrameRefs(nsIFrame* aFrame) = 0;
 
   /**
    * Get a reference rendering context. This is a context that should not
    * be rendered to, but is suitable for measuring text and performing
    * other non-rendering operations. Guaranteed to return non-null.
    */
   virtual already_AddRefed<nsRenderingContext> CreateReferenceRenderingContext() = 0;
 
   /**
    * Informs the pres shell that the document is now at the anchor with
    * the given name.  If |aScroll| is true, scrolls the view of the
    * document so that the anchor with the specified name is displayed at
    * the top of the window.  If |aAnchorName| is empty, then this informs
    * the pres shell that there is no current target, and |aScroll| must
    * be false.
    */
-  virtual NS_HIDDEN_(nsresult) GoToAnchor(const nsAString& aAnchorName, bool aScroll) = 0;
+  virtual nsresult GoToAnchor(const nsAString& aAnchorName, bool aScroll) = 0;
 
   /**
    * Tells the presshell to scroll again to the last anchor scrolled to by
    * GoToAnchor, if any. This scroll only happens if the scroll
    * position has not changed since the last GoToAnchor. This is called
    * by nsDocumentViewer::LoadComplete. This clears the last anchor
    * scrolled to by GoToAnchor (we don't want to keep it alive if it's
    * removed from the DOM), so don't call this more than once.
    */
-  virtual NS_HIDDEN_(nsresult) ScrollToAnchor() = 0;
+  virtual nsresult ScrollToAnchor() = 0;
 
   enum {
     SCROLL_TOP     = 0,
     SCROLL_BOTTOM  = 100,
     SCROLL_LEFT    = 0,
     SCROLL_RIGHT   = 100,
     SCROLL_CENTER  = 50,
     SCROLL_MINIMUM = -1
@@ -664,17 +664,17 @@ public:
    *                  If SCROLL_OVERFLOW_HIDDEN is set then we may scroll in a
    *                  direction even if overflow:hidden is specified in that
    *                  direction; otherwise we will not scroll in that direction
    *                  when overflow:hidden is set for that direction.
    *                  If SCROLL_NO_PARENT_FRAMES is set then we only scroll
    *                  nodes in this document, not in any parent documents which
    *                  contain this document in a iframe or the like.
    */
-  virtual NS_HIDDEN_(nsresult) ScrollContentIntoView(nsIContent* aContent,
+  virtual nsresult ScrollContentIntoView(nsIContent* aContent,
                                                      ScrollAxis  aVertical,
                                                      ScrollAxis  aHorizontal,
                                                      uint32_t    aFlags) = 0;
 
   enum {
     SCROLL_FIRST_ANCESTOR_ONLY = 0x01,
     SCROLL_OVERFLOW_HIDDEN = 0x02,
     SCROLL_NO_PARENT_FRAMES = 0x04
@@ -721,36 +721,36 @@ public:
   virtual nsRectVisibility GetRectVisibility(nsIFrame *aFrame,
                                              const nsRect &aRect,
                                              nscoord aMinTwips) const = 0;
 
   /**
    * Suppress notification of the frame manager that frames are
    * being destroyed.
    */
-  virtual NS_HIDDEN_(void) SetIgnoreFrameDestruction(bool aIgnore) = 0;
+  virtual void SetIgnoreFrameDestruction(bool aIgnore) = 0;
 
   /**
    * Notification sent by a frame informing the pres shell that it is about to
    * be destroyed.
    * This allows any outstanding references to the frame to be cleaned up
    */
-  virtual NS_HIDDEN_(void) NotifyDestroyingFrame(nsIFrame* aFrame) = 0;
+  virtual void NotifyDestroyingFrame(nsIFrame* aFrame) = 0;
 
   /**
    * Get the caret, if it exists. AddRefs it.
    */
-  virtual NS_HIDDEN_(already_AddRefed<nsCaret>) GetCaret() const = 0;
+  virtual already_AddRefed<nsCaret> GetCaret() const = 0;
 
   /**
    * Invalidate the caret's current position if it's outside of its frame's
    * boundaries. This function is useful if you're batching selection
    * notifications and might remove the caret's frame out from under it.
    */
-  virtual NS_HIDDEN_(void) MaybeInvalidateCaretPosition() = 0;
+  virtual void MaybeInvalidateCaretPosition() = 0;
 
   /**
    * Set the current caret to a new caret. To undo this, call RestoreCaret.
    */
   virtual void SetCaret(nsCaret *aNewCaret) = 0;
 
   /**
    * Restore the caret to the original caret that this pres shell was created
@@ -776,55 +776,55 @@ public:
   int16_t GetSelectionFlags() const { return mSelectionFlags; }
 
   virtual mozilla::dom::Selection* GetCurrentSelection(SelectionType aType) = 0;
 
   /**
     * Interface to dispatch events via the presshell
     * @note The caller must have a strong reference to the PresShell.
     */
-  virtual NS_HIDDEN_(nsresult) HandleEventWithTarget(
+  virtual nsresult HandleEventWithTarget(
                                  mozilla::WidgetEvent* aEvent,
                                  nsIFrame* aFrame,
                                  nsIContent* aContent,
                                  nsEventStatus* aStatus) = 0;
 
   /**
    * Dispatch event to content only (NOT full processing)
    * @note The caller must have a strong reference to the PresShell.
    */
-  virtual NS_HIDDEN_(nsresult) HandleDOMEventWithTarget(
+  virtual nsresult HandleDOMEventWithTarget(
                                  nsIContent* aTargetContent,
                                  mozilla::WidgetEvent* aEvent,
                                  nsEventStatus* aStatus) = 0;
 
   /**
    * Dispatch event to content only (NOT full processing)
    * @note The caller must have a strong reference to the PresShell.
    */
-  virtual NS_HIDDEN_(nsresult) HandleDOMEventWithTarget(nsIContent* aTargetContent,
+  virtual nsresult HandleDOMEventWithTarget(nsIContent* aTargetContent,
                                                         nsIDOMEvent* aEvent,
                                                         nsEventStatus* aStatus) = 0;
 
   /**
     * Gets the current target event frame from the PresShell
     */
-  virtual NS_HIDDEN_(nsIFrame*) GetEventTargetFrame() = 0;
+  virtual nsIFrame* GetEventTargetFrame() = 0;
 
   /**
     * Gets the current target event frame from the PresShell
     */
-  virtual NS_HIDDEN_(already_AddRefed<nsIContent>) GetEventTargetContent(
+  virtual already_AddRefed<nsIContent> GetEventTargetContent(
                                                      mozilla::WidgetEvent* aEvent) = 0;
 
   /**
    * Get and set the history state for the current document
    */
 
-  virtual NS_HIDDEN_(nsresult) CaptureHistoryState(nsILayoutHistoryState** aLayoutHistoryState) = 0;
+  virtual nsresult CaptureHistoryState(nsILayoutHistoryState** aLayoutHistoryState) = 0;
 
   /**
    * Determine if reflow is currently locked
    * returns true if reflow is locked, false otherwise
    */
   bool IsReflowLocked() const { return mIsReflowing; }
 
   /**
@@ -846,17 +846,17 @@ public:
    * presentations. This may not have the desired effect if this pres shell
    * has its own refresh driver.
    */
   virtual void ResumePainting() = 0;
 
   /**
    * Unsuppress painting.
    */
-  virtual NS_HIDDEN_(void) UnsuppressPainting() = 0;
+  virtual void UnsuppressPainting() = 0;
 
   /**
    * Called to disable nsITheme support in a specific presshell.
    */
   void DisableThemeSupport()
   {
     // Doesn't have to be dynamic.  Just set the bool.
     mIsThemeSupportDisabled = true;
@@ -910,25 +910,25 @@ public:
   /**
    * Set the verify-reflow enable flag.
    */
   static void SetVerifyReflowEnable(bool aEnabled);
 
   virtual nsIFrame* GetAbsoluteContainingBlock(nsIFrame* aFrame);
 
 #ifdef MOZ_REFLOW_PERF
-  virtual NS_HIDDEN_(void) DumpReflows() = 0;
-  virtual NS_HIDDEN_(void) CountReflows(const char * aName, nsIFrame * aFrame) = 0;
-  virtual NS_HIDDEN_(void) PaintCount(const char * aName,
+  virtual void DumpReflows() = 0;
+  virtual void CountReflows(const char * aName, nsIFrame * aFrame) = 0;
+  virtual void PaintCount(const char * aName,
                                       nsRenderingContext* aRenderingContext,
                                       nsPresContext * aPresContext,
                                       nsIFrame * aFrame,
                                       const nsPoint& aOffset,
                                       uint32_t aColor) = 0;
-  virtual NS_HIDDEN_(void) SetPaintFrameCount(bool aOn) = 0;
+  virtual void SetPaintFrameCount(bool aOn) = 0;
   virtual bool IsPaintingFrameCounts() = 0;
 #endif
 
 #ifdef DEBUG
   // Debugging hooks
   virtual void ListStyleContexts(nsIFrame *aRootFrame, FILE *out,
                                  int32_t aIndent = 0) = 0;
 
@@ -1011,17 +1011,17 @@ public:
     RENDER_IS_UNTRUSTED = 0x01,
     RENDER_IGNORE_VIEWPORT_SCROLLING = 0x02,
     RENDER_CARET = 0x04,
     RENDER_USE_WIDGET_LAYERS = 0x08,
     RENDER_ASYNC_DECODE_IMAGES = 0x10,
     RENDER_DOCUMENT_RELATIVE = 0x20,
     RENDER_DRAWWINDOW_NOT_FLUSHING = 0x40
   };
-  virtual NS_HIDDEN_(nsresult) RenderDocument(const nsRect& aRect, uint32_t aFlags,
+  virtual nsresult RenderDocument(const nsRect& aRect, uint32_t aFlags,
                                               nscolor aBackgroundColor,
                                               gfxContext* aRenderedContext) = 0;
 
   /**
    * Renders a node aNode to a surface and returns it. The aRegion may be used
    * to clip the rendering. This region is measured in CSS pixels from the
    * edge of the presshell area. The aPoint, aScreenRect and aSurface
    * arguments function in a similar manner as RenderSelection.
@@ -1082,17 +1082,17 @@ public:
 
   /**
    * Stop or restart non synthetic test mouse event handling on *all*
    * presShells.
    *
    * @param aDisable If true, disable all non synthetic test mouse
    * events on all presShells.  Otherwise, enable them.
    */
-  virtual NS_HIDDEN_(void) DisableNonTestMouseEvents(bool aDisable) = 0;
+  virtual void DisableNonTestMouseEvents(bool aDisable) = 0;
 
   /**
    * Record the background color of the most recently drawn canvas. This color
    * is composited on top of the user's default background color and then used
    * to draw the background color of the canvas. See PresShell::Paint,
    * PresShell::PaintDefaultBackground, and nsDocShell::SetupNewViewer;
    * bug 488242, bug 476557 and other bugs mentioned there.
    */
--- a/layout/base/nsPresArena.cpp
+++ b/layout/base/nsPresArena.cpp
@@ -35,17 +35,17 @@ nsPresArena::nsPresArena()
 nsPresArena::~nsPresArena()
 {
 #if defined(MOZ_HAVE_MEM_CHECKS)
   mFreeLists.EnumerateEntries(UnpoisonFreeList, nullptr);
 #endif
   PL_FinishArenaPool(&mPool);
 }
 
-NS_HIDDEN_(void*)
+void*
 nsPresArena::Allocate(uint32_t aCode, size_t aSize)
 {
   NS_ABORT_IF_FALSE(aSize > 0, "PresArena cannot allocate zero bytes");
 
   // We only hand out aligned sizes
   aSize = PL_ARENA_ALIGN(&mPool, aSize);
 
   // If there is no free-list entry for this type already, we have
@@ -93,17 +93,17 @@ nsPresArena::Allocate(uint32_t aCode, si
   list->mEntriesEverAllocated++;
   PL_ARENA_ALLOCATE(result, &mPool, aSize);
   if (!result) {
     NS_RUNTIMEABORT("out of memory");
   }
   return result;
 }
 
-NS_HIDDEN_(void)
+void
 nsPresArena::Free(uint32_t aCode, void* aPtr)
 {
   // Try to recycle this entry.
   FreeList* list = mFreeLists.GetEntry(aCode);
   NS_ABORT_IF_FALSE(list, "no free list for pres arena object");
   NS_ABORT_IF_FALSE(list->mEntrySize > 0, "PresArena cannot free zero bytes");
 
   mozWritePoison(aPtr, list->mEntrySize);
--- a/layout/base/nsPresArena.h
+++ b/layout/base/nsPresArena.h
@@ -41,61 +41,61 @@ public:
      * whether enumeration constants are signed.
      */
     NON_OBJECT_MARKER = 0x40000000
   };
 
   /**
    * Pool allocation with recycler lists indexed by object size, aSize.
    */
-  NS_HIDDEN_(void*) AllocateBySize(size_t aSize)
+  void* AllocateBySize(size_t aSize)
   {
     return Allocate(uint32_t(aSize) | uint32_t(NON_OBJECT_MARKER), aSize);
   }
-  NS_HIDDEN_(void) FreeBySize(size_t aSize, void* aPtr)
+  void FreeBySize(size_t aSize, void* aPtr)
   {
     Free(uint32_t(aSize) | uint32_t(NON_OBJECT_MARKER), aPtr);
   }
 
   /**
    * Pool allocation with recycler lists indexed by frame-type ID.
    * Every aID must always be used with the same object size, aSize.
    */
-  NS_HIDDEN_(void*) AllocateByFrameID(nsQueryFrame::FrameIID aID, size_t aSize)
+  void* AllocateByFrameID(nsQueryFrame::FrameIID aID, size_t aSize)
   {
     return Allocate(aID, aSize);
   }
-  NS_HIDDEN_(void) FreeByFrameID(nsQueryFrame::FrameIID aID, void* aPtr)
+  void FreeByFrameID(nsQueryFrame::FrameIID aID, void* aPtr)
   {
     Free(aID, aPtr);
   }
 
   /**
    * Pool allocation with recycler lists indexed by object-type ID (see above).
    * Every aID must always be used with the same object size, aSize.
    */
-  NS_HIDDEN_(void*) AllocateByObjectID(ObjectID aID, size_t aSize)
+  void* AllocateByObjectID(ObjectID aID, size_t aSize)
   {
     return Allocate(aID, aSize);
   }
-  NS_HIDDEN_(void) FreeByObjectID(ObjectID aID, void* aPtr)
+  void FreeByObjectID(ObjectID aID, void* aPtr)
   {
     Free(aID, aPtr);
   }
 
   /**
    * Increment aArenaStats with sizes of interesting objects allocated in this
    * arena and its mOther field with the size of everything else.
    */
   void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
                               nsArenaMemoryStats* aArenaStats);
 
 private:
-  NS_HIDDEN_(void*) Allocate(uint32_t aCode, size_t aSize);
-  NS_HIDDEN_(void) Free(uint32_t aCode, void* aPtr);
+  void* Allocate(uint32_t aCode, size_t aSize);
+  void Free(uint32_t aCode, void* aPtr);
 
   // All keys to this hash table fit in 32 bits (see below) so we do not
   // bother actually hashing them.
   class FreeList : public PLDHashEntryHdr
   {
   public:
     typedef uint32_t KeyType;
     nsTArray<void *> mEntries;
--- a/layout/base/nsPresContext.h
+++ b/layout/base/nsPresContext.h
@@ -155,26 +155,26 @@ public:
     eAlwaysRebuildStyle
   };
 
   nsPresContext(nsIDocument* aDocument, nsPresContextType aType) NS_HIDDEN;
 
   /**
    * Initialize the presentation context from a particular device.
    */
-  NS_HIDDEN_(nsresult) Init(nsDeviceContext* aDeviceContext);
+  nsresult Init(nsDeviceContext* aDeviceContext);
 
   /**
    * Set the presentation shell that this context is bound to.
    * A presentation context may only be bound to a single shell.
    */
-  NS_HIDDEN_(void) SetShell(nsIPresShell* aShell);
+  void SetShell(nsIPresShell* aShell);
 
 
-  NS_HIDDEN_(nsPresContextType) Type() const { return mType; }
+  nsPresContextType Type() const { return mType; }
 
   /**
    * Get the PresentationShell that this context is bound to.
    */
   nsIPresShell* PresShell() const
   {
     NS_ASSERTION(mShell, "Null pres shell");
     return mShell;
@@ -255,17 +255,17 @@ public:
    * Just like RebuildAllStyleData, except (1) asynchronous and (2) it
    * doesn't rebuild the user font set.
    */
   void PostRebuildAllStyleDataEvent(nsChangeHint aExtraHint);
 
   void MediaFeatureValuesChanged(StyleRebuildType aShouldRebuild,
                                  nsChangeHint aChangeHint = nsChangeHint(0));
   void PostMediaFeatureValuesChangedEvent();
-  NS_HIDDEN_(void) HandleMediaFeatureValuesChangedEvent();
+  void HandleMediaFeatureValuesChangedEvent();
   void FlushPendingMediaFeatureValuesChanged() {
     if (mPendingMediaFeatureValuesChanged)
       MediaFeatureValuesChanged(eRebuildStyleIfNeeded);
   }
 
   /**
    * Support for window.matchMedia()
    */
@@ -276,24 +276,24 @@ public:
    * Access compatibility mode for this context.  This is the same as
    * our document's compatibility mode.
    */
   nsCompatibility CompatibilityMode() const;
 
   /**
    * Notify the context that the document's compatibility mode has changed
    */
-  NS_HIDDEN_(void) CompatibilityModeChanged();
+  void CompatibilityModeChanged();
 
   /**
    * Access the image animation mode for this context
    */
   uint16_t     ImageAnimationMode() const { return mImageAnimationMode; }
-  virtual NS_HIDDEN_(void) SetImageAnimationModeExternal(uint16_t aMode);
-  NS_HIDDEN_(void) SetImageAnimationModeInternal(uint16_t aMode);
+  virtual void SetImageAnimationModeExternal(uint16_t aMode);
+  void SetImageAnimationModeInternal(uint16_t aMode);
 #ifdef MOZILLA_INTERNAL_API
   void SetImageAnimationMode(uint16_t aMode)
   { SetImageAnimationModeInternal(aMode); }
 #else
   void SetImageAnimationMode(uint16_t aMode)
   { SetImageAnimationModeExternal(aMode); }
 #endif
 
@@ -345,17 +345,17 @@ public:
    * as the default font size for variable or fixed fonts for the
    * language group.
    *
    * For aFontID corresponding to a CSS Generic, the nsFont returned has
    * its name set to that generic font's name, and its size set to
    * the user's preference for font size for that generic and the
    * given language.
    */
-  NS_HIDDEN_(const nsFont*) GetDefaultFont(uint8_t aFontID,
+  const nsFont* GetDefaultFont(uint8_t aFontID,
                                            nsIAtom *aLanguage) const;
 
   /** Get a cached boolean pref, by its type */
   // *  - initially created for bugs 31816, 20760, 22963
   bool GetCachedBoolPref(nsPresContext_CachedBoolPrefType aPrefType) const
   {
     // If called with a constant parameter, the compiler should optimize
     // this switch statement away.
@@ -408,17 +408,17 @@ public:
   const nscolor BodyTextColor() const { return mBodyTextColor; }
   void SetBodyTextColor(nscolor aColor) { mBodyTextColor = aColor; }
 
   bool GetUseFocusColors() const { return mUseFocusColors; }
   uint8_t FocusRingWidth() const { return mFocusRingWidth; }
   bool GetFocusRingOnAnything() const { return mFocusRingOnAnything; }
   uint8_t GetFocusRingStyle() const { return mFocusRingStyle; }
 
-  NS_HIDDEN_(void) SetContainer(nsIDocShell* aContainer);
+  void SetContainer(nsIDocShell* aContainer);
 
   virtual nsISupports* GetContainerWeakExternal() const;
   nsISupports* GetContainerWeakInternal() const;
 #ifdef MOZILLA_INTERNAL_API
   nsISupports* GetContainerWeak() const
   { return GetContainerWeakInternal(); }
 #else
   nsISupports* GetContainerWeak() const
@@ -466,17 +466,17 @@ public:
    * context.
    */
   bool IsPaginated() const { return mPaginated; }
 
   /**
    * Sets whether the presentation context can scroll for a paginated
    * context.
    */
-  NS_HIDDEN_(void) SetPaginatedScrolling(bool aResult);
+  void SetPaginatedScrolling(bool aResult);
 
   /**
    * Return true if this presentation context can scroll for paginated
    * context.
    */
   bool HasPaginatedScrolling() const { return mCanPaginatedScroll; }
 
   /**
@@ -705,17 +705,17 @@ public:
   virtual bool BidiEnabledExternal() const;
   bool BidiEnabledInternal() const;
 
   /**
    *  Set bidi enabled. This means we should apply the Unicode Bidi Algorithm
    *
    *  @lina 07/12/2000
    */
-  NS_HIDDEN_(void) SetBidiEnabled() const;
+  void SetBidiEnabled() const;
 
   /**
    *  Set visual or implicit mode into the pres context.
    *
    *  Visual directionality is a presentation method that displays text
    *  as if it were a uni-directional, according to the primary display
    *  direction only.
    *
@@ -738,85 +738,85 @@ public:
    */
   bool IsVisualMode() const { return mIsVisual; }
 
 //Mohamed
 
   /**
    * Set the Bidi options for the presentation context
    */
-  NS_HIDDEN_(void) SetBidi(uint32_t aBidiOptions,
+  void SetBidi(uint32_t aBidiOptions,
                            bool aForceRestyle = false);
 
   /**
    * Get the Bidi options for the presentation context
    * Not inline so consumers of nsPresContext are not forced to
    * include nsIDocument.
    */
-  NS_HIDDEN_(uint32_t) GetBidi() const;
+  uint32_t GetBidi() const;
 
   /**
    * Render only Selection
    */
   void SetIsRenderingOnlySelection(bool aResult)
   {
     mIsRenderingOnlySelection = aResult;
   }
 
   bool IsRenderingOnlySelection() const { return mIsRenderingOnlySelection; }
 
-  NS_HIDDEN_(bool) IsTopLevelWindowInactive();
+  bool IsTopLevelWindowInactive();
 
   /*
    * Obtain a native them for rendering our widgets (both form controls and html)
    */
-  NS_HIDDEN_(nsITheme*) GetTheme();
+  nsITheme* GetTheme();
 
   /*
    * Notify the pres context that the theme has changed.  An internal switch
    * means it's one of our Mozilla themes that changed (e.g., Modern to Classic).
    * Otherwise, the OS is telling us that the native theme for the platform
    * has changed.
    */
-  NS_HIDDEN_(void) ThemeChanged();
+  void ThemeChanged();
 
   /*
    * Notify the pres context that the resolution of the user interface has
    * changed. This happens if a window is moved between HiDPI and non-HiDPI
    * displays, so that the ratio of points to device pixels changes.
    */
-  NS_HIDDEN_(void) UIResolutionChanged();
+  void UIResolutionChanged();
 
   /**
    * Recursively notify all remote leaf descendants of a given message manager
    * that the resolution of the user interface has changed.
    */
-  NS_HIDDEN_(void) NotifyUIResolutionChanged(nsIMessageBroadcaster* aManager);
+  void NotifyUIResolutionChanged(nsIMessageBroadcaster* aManager);
 
   /*
    * Notify the pres context that a system color has changed
    */
-  NS_HIDDEN_(void) SysColorChanged();
+  void SysColorChanged();
 
   /** Printing methods below should only be used for Medium() == print **/
-  NS_HIDDEN_(void) SetPrintSettings(nsIPrintSettings *aPrintSettings);
+  void SetPrintSettings(nsIPrintSettings *aPrintSettings);
 
   nsIPrintSettings* GetPrintSettings() { return mPrintSettings; }
 
   /* Accessor for table of frame properties */
   FramePropertyTable* PropertyTable() { return &mPropertyTable; }
 
   /* Helper function that ensures that this prescontext is shown in its
      docshell if it's the most recent prescontext for the docshell.  Returns
      whether the prescontext is now being shown.
   */
-  NS_HIDDEN_(bool) EnsureVisible();
+  bool EnsureVisible();
 
 #ifdef MOZ_REFLOW_PERF
-  NS_HIDDEN_(void) CountReflows(const char * aName,
+  void CountReflows(const char * aName,
                                 nsIFrame * aFrame);
 #endif
 
   /**
    * This table maps border-width enums 'thin', 'medium', 'thick'
    * to actual nscoord values.
    */
   const nscoord* GetBorderWidthTable() { return mBorderWidthTable; }
@@ -848,18 +848,18 @@ public:
   }
 
   // This method should be used instead of directly accessing mPaintFlashing,
   // as that value may be out of date when mPaintFlashingInitialized is false.
   bool GetPaintFlashing() const;
 
   bool             SupressingResizeReflow() const { return mSupressResizeReflow; }
 
-  virtual NS_HIDDEN_(gfxUserFontSet*) GetUserFontSetExternal();
-  NS_HIDDEN_(gfxUserFontSet*) GetUserFontSetInternal();
+  virtual gfxUserFontSet* GetUserFontSetExternal();
+  gfxUserFontSet* GetUserFontSetInternal();
 #ifdef MOZILLA_INTERNAL_API
   gfxUserFontSet* GetUserFontSet() { return GetUserFontSetInternal(); }
 #else
   gfxUserFontSet* GetUserFontSet() { return GetUserFontSetExternal(); }
 #endif
 
   void FlushUserFontSet();
   void RebuildUserFontSet(); // asynchronously
@@ -1030,35 +1030,35 @@ public:
   }
 
   void SetHasWarnedAboutPositionedTableParts() {
     mHasWarnedAboutPositionedTableParts = true;
   }
 
 protected:
   friend class nsRunnableMethod<nsPresContext>;
-  NS_HIDDEN_(void) ThemeChangedInternal();
-  NS_HIDDEN_(void) SysColorChangedInternal();
-  NS_HIDDEN_(void) UIResolutionChangedInternal();
+  void ThemeChangedInternal();
+  void SysColorChangedInternal();
+  void UIResolutionChangedInternal();
 
-  static NS_HIDDEN_(bool)
+  static bool
   UIResolutionChangedSubdocumentCallback(nsIDocument* aDocument, void* aData);
 
-  NS_HIDDEN_(void) SetImgAnimations(nsIContent *aParent, uint16_t aMode);
-  NS_HIDDEN_(void) SetSMILAnimations(nsIDocument *aDoc, uint16_t aNewMode,
+  void SetImgAnimations(nsIContent *aParent, uint16_t aMode);
+  void SetSMILAnimations(nsIDocument *aDoc, uint16_t aNewMode,
                                      uint16_t aOldMode);
-  NS_HIDDEN_(void) GetDocumentColorPreferences();
+  void GetDocumentColorPreferences();
 
-  NS_HIDDEN_(void) PreferenceChanged(const char* aPrefName);
-  static NS_HIDDEN_(void) PrefChangedCallback(const char*, void*);
+  void PreferenceChanged(const char* aPrefName);
+  static void PrefChangedCallback(const char*, void*);
 
-  NS_HIDDEN_(void) UpdateAfterPreferencesChanged();
-  static NS_HIDDEN_(void) PrefChangedUpdateTimerCallback(nsITimer *aTimer, void *aClosure);
+  void UpdateAfterPreferencesChanged();
+  static void PrefChangedUpdateTimerCallback(nsITimer *aTimer, void *aClosure);
 
-  NS_HIDDEN_(void) GetUserPreferences();
+  void GetUserPreferences();
 
   // Allow nsAutoPtr<LangGroupFontPrefs> dtor to access this protected struct's
   // dtor:
   struct LangGroupFontPrefs;
   friend class nsAutoPtr<LangGroupFontPrefs>;
   struct LangGroupFontPrefs {
     // Font sizes default to zero; they will be set in GetFontPreferences
     LangGroupFontPrefs()
@@ -1122,17 +1122,17 @@ protected:
   void ResetCachedFontPrefs() {
     // Throw away any other LangGroupFontPrefs objects:
     mLangGroupFontPrefs.mNext = nullptr;
 
     // Make GetFontPreferences reinitialize mLangGroupFontPrefs:
     mLangGroupFontPrefs.mLangGroup = nullptr;
   }
 
-  NS_HIDDEN_(void) UpdateCharSet(const nsCString& aCharSet);
+  void UpdateCharSet(const nsCString& aCharSet);
 
 public:
   void DoChangeCharSet(const nsCString& aCharSet);
 
   /**
    * Checks for MozAfterPaint listeners on the document
    */
   bool MayHavePaintEventListener();
--- a/layout/base/nsPresShell.h
+++ b/layout/base/nsPresShell.h
@@ -65,105 +65,105 @@ public:
   NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
 
   // nsISupports
   NS_DECL_ISUPPORTS
 
   void Init(nsIDocument* aDocument, nsPresContext* aPresContext,
             nsViewManager* aViewManager, nsStyleSet* aStyleSet,
             nsCompatibility aCompatMode);
-  virtual NS_HIDDEN_(void) Destroy() MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) MakeZombie() MOZ_OVERRIDE;
+  virtual void Destroy() MOZ_OVERRIDE;
+  virtual void MakeZombie() MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(nsresult) SetPreferenceStyleRules(bool aForceReflow) MOZ_OVERRIDE;
+  virtual nsresult SetPreferenceStyleRules(bool aForceReflow) MOZ_OVERRIDE;
 
   NS_IMETHOD GetSelection(SelectionType aType, nsISelection** aSelection);
   virtual mozilla::dom::Selection* GetCurrentSelection(SelectionType aType) MOZ_OVERRIDE;
 
   NS_IMETHOD SetDisplaySelection(int16_t aToggle) MOZ_OVERRIDE;
   NS_IMETHOD GetDisplaySelection(int16_t *aToggle) MOZ_OVERRIDE;
   NS_IMETHOD ScrollSelectionIntoView(SelectionType aType, SelectionRegion aRegion,
                                      int16_t aFlags) MOZ_OVERRIDE;
   NS_IMETHOD RepaintSelection(SelectionType aType) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(void) BeginObservingDocument() MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) EndObservingDocument() MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(nsresult) Initialize(nscoord aWidth, nscoord aHeight) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(nsresult) ResizeReflow(nscoord aWidth, nscoord aHeight) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(nsresult) ResizeReflowOverride(nscoord aWidth, nscoord aHeight) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(nsIPageSequenceFrame*) GetPageSequenceFrame() const MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(nsIFrame*) GetRealPrimaryFrameFor(nsIContent* aContent) const MOZ_OVERRIDE;
+  virtual void BeginObservingDocument() MOZ_OVERRIDE;
+  virtual void EndObservingDocument() MOZ_OVERRIDE;
+  virtual nsresult Initialize(nscoord aWidth, nscoord aHeight) MOZ_OVERRIDE;
+  virtual nsresult ResizeReflow(nscoord aWidth, nscoord aHeight) MOZ_OVERRIDE;
+  virtual nsresult ResizeReflowOverride(nscoord aWidth, nscoord aHeight) MOZ_OVERRIDE;
+  virtual nsIPageSequenceFrame* GetPageSequenceFrame() const MOZ_OVERRIDE;
+  virtual nsIFrame* GetRealPrimaryFrameFor(nsIContent* aContent) const MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(nsIFrame*) GetPlaceholderFrameFor(nsIFrame* aFrame) const MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) FrameNeedsReflow(nsIFrame *aFrame, IntrinsicDirty aIntrinsicDirty,
+  virtual nsIFrame* GetPlaceholderFrameFor(nsIFrame* aFrame) const MOZ_OVERRIDE;
+  virtual void FrameNeedsReflow(nsIFrame *aFrame, IntrinsicDirty aIntrinsicDirty,
                                             nsFrameState aBitToAdd) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) FrameNeedsToContinueReflow(nsIFrame *aFrame) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) CancelAllPendingReflows() MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(bool) IsSafeToFlush() const MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) FlushPendingNotifications(mozFlushType aType) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) FlushPendingNotifications(mozilla::ChangesToFlush aType) MOZ_OVERRIDE;
+  virtual void FrameNeedsToContinueReflow(nsIFrame *aFrame) MOZ_OVERRIDE;
+  virtual void CancelAllPendingReflows() MOZ_OVERRIDE;
+  virtual bool IsSafeToFlush() const MOZ_OVERRIDE;
+  virtual void FlushPendingNotifications(mozFlushType aType) MOZ_OVERRIDE;
+  virtual void FlushPendingNotifications(mozilla::ChangesToFlush aType) MOZ_OVERRIDE;
 
   /**
    * Recreates the frames for a node
    */
-  virtual NS_HIDDEN_(nsresult) RecreateFramesFor(nsIContent* aContent) MOZ_OVERRIDE;
+  virtual nsresult RecreateFramesFor(nsIContent* aContent) MOZ_OVERRIDE;
 
   /**
    * Post a callback that should be handled after reflow has finished.
    */
-  virtual NS_HIDDEN_(nsresult) PostReflowCallback(nsIReflowCallback* aCallback) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) CancelReflowCallback(nsIReflowCallback* aCallback) MOZ_OVERRIDE;
+  virtual nsresult PostReflowCallback(nsIReflowCallback* aCallback) MOZ_OVERRIDE;
+  virtual void CancelReflowCallback(nsIReflowCallback* aCallback) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(void) ClearFrameRefs(nsIFrame* aFrame) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(already_AddRefed<nsRenderingContext>) CreateReferenceRenderingContext();
-  virtual NS_HIDDEN_(nsresult) GoToAnchor(const nsAString& aAnchorName, bool aScroll) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(nsresult) ScrollToAnchor() MOZ_OVERRIDE;
+  virtual void ClearFrameRefs(nsIFrame* aFrame) MOZ_OVERRIDE;
+  virtual already_AddRefed<nsRenderingContext> CreateReferenceRenderingContext();
+  virtual nsresult GoToAnchor(const nsAString& aAnchorName, bool aScroll) MOZ_OVERRIDE;
+  virtual nsresult ScrollToAnchor() MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(nsresult) ScrollContentIntoView(nsIContent* aContent,
+  virtual nsresult ScrollContentIntoView(nsIContent* aContent,
                                                      ScrollAxis  aVertical,
                                                      ScrollAxis  aHorizontal,
                                                      uint32_t    aFlags) MOZ_OVERRIDE;
   virtual bool ScrollFrameRectIntoView(nsIFrame*     aFrame,
                                        const nsRect& aRect,
                                        ScrollAxis    aVertical,
                                        ScrollAxis    aHorizontal,
                                        uint32_t      aFlags) MOZ_OVERRIDE;
   virtual nsRectVisibility GetRectVisibility(nsIFrame *aFrame,
                                              const nsRect &aRect,
                                              nscoord aMinTwips) const MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(void) SetIgnoreFrameDestruction(bool aIgnore) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) NotifyDestroyingFrame(nsIFrame* aFrame) MOZ_OVERRIDE;
+  virtual void SetIgnoreFrameDestruction(bool aIgnore) MOZ_OVERRIDE;
+  virtual void NotifyDestroyingFrame(nsIFrame* aFrame) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(nsresult) CaptureHistoryState(nsILayoutHistoryState** aLayoutHistoryState) MOZ_OVERRIDE;
+  virtual nsresult CaptureHistoryState(nsILayoutHistoryState** aLayoutHistoryState) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(void) UnsuppressPainting() MOZ_OVERRIDE;
+  virtual void UnsuppressPainting() MOZ_OVERRIDE;
 
   virtual nsresult GetAgentStyleSheets(nsCOMArray<nsIStyleSheet>& aSheets) MOZ_OVERRIDE;
   virtual nsresult SetAgentStyleSheets(const nsCOMArray<nsIStyleSheet>& aSheets) MOZ_OVERRIDE;
 
   virtual nsresult AddOverrideStyleSheet(nsIStyleSheet *aSheet) MOZ_OVERRIDE;
   virtual nsresult RemoveOverrideStyleSheet(nsIStyleSheet *aSheet) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(nsresult) HandleEventWithTarget(
+  virtual nsresult HandleEventWithTarget(
                                  mozilla::WidgetEvent* aEvent,
                                  nsIFrame* aFrame,
                                  nsIContent* aContent,
                                  nsEventStatus* aStatus) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(nsIFrame*) GetEventTargetFrame() MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(already_AddRefed<nsIContent>) GetEventTargetContent(
+  virtual nsIFrame* GetEventTargetFrame() MOZ_OVERRIDE;
+  virtual already_AddRefed<nsIContent> GetEventTargetContent(
                                                      mozilla::WidgetEvent* aEvent) MOZ_OVERRIDE;
 
 
   virtual nsresult ReconstructFrames(void) MOZ_OVERRIDE;
   virtual void Freeze() MOZ_OVERRIDE;
   virtual void Thaw() MOZ_OVERRIDE;
   virtual void FireOrClearDelayedEvents(bool aFireEvents) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(nsresult) RenderDocument(const nsRect& aRect, uint32_t aFlags,
+  virtual nsresult RenderDocument(const nsRect& aRect, uint32_t aFlags,
                                               nscolor aBackgroundColor,
                                               gfxContext* aThebesContext) MOZ_OVERRIDE;
 
   virtual mozilla::TemporaryRef<SourceSurface>
   RenderNode(nsIDOMNode* aNode,
              nsIntRegion* aRegion,
              nsIntPoint& aPoint,
              nsIntRect* aScreenRect) MOZ_OVERRIDE;
@@ -185,36 +185,36 @@ public:
   //nsIViewObserver interface
 
   virtual void Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
                      uint32_t aFlags) MOZ_OVERRIDE;
   virtual nsresult HandleEvent(nsIFrame* aFrame,
                                mozilla::WidgetGUIEvent* aEvent,
                                bool aDontRetargetEvents,
                                nsEventStatus* aEventStatus) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(nsresult) HandleDOMEventWithTarget(
+  virtual nsresult HandleDOMEventWithTarget(
                                  nsIContent* aTargetContent,
                                  mozilla::WidgetEvent* aEvent,
                                  nsEventStatus* aStatus) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(nsresult) HandleDOMEventWithTarget(nsIContent* aTargetContent,
+  virtual nsresult HandleDOMEventWithTarget(nsIContent* aTargetContent,
                                                         nsIDOMEvent* aEvent,
                                                         nsEventStatus* aStatus) MOZ_OVERRIDE;
   virtual bool ShouldIgnoreInvalidation() MOZ_OVERRIDE;
   virtual void WillPaint() MOZ_OVERRIDE;
   virtual void WillPaintWindow() MOZ_OVERRIDE;
   virtual void DidPaintWindow() MOZ_OVERRIDE;
   virtual void ScheduleViewManagerFlush(PaintType aType = PAINT_DEFAULT) MOZ_OVERRIDE;
   virtual void DispatchSynthMouseMove(mozilla::WidgetGUIEvent* aEvent,
                                       bool aFlushOnHoverChange) MOZ_OVERRIDE;
   virtual void ClearMouseCaptureOnView(nsView* aView) MOZ_OVERRIDE;
   virtual bool IsVisible() MOZ_OVERRIDE;
 
   // caret handling
-  virtual NS_HIDDEN_(already_AddRefed<nsCaret>) GetCaret() const MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) MaybeInvalidateCaretPosition() MOZ_OVERRIDE;
+  virtual already_AddRefed<nsCaret> GetCaret() const MOZ_OVERRIDE;
+  virtual void MaybeInvalidateCaretPosition() MOZ_OVERRIDE;
   NS_IMETHOD SetCaretEnabled(bool aInEnable) MOZ_OVERRIDE;
   NS_IMETHOD SetCaretReadOnly(bool aReadOnly) MOZ_OVERRIDE;
   NS_IMETHOD GetCaretEnabled(bool *aOutEnabled) MOZ_OVERRIDE;
   NS_IMETHOD SetCaretVisibilityDuringSelection(bool aVisibility) MOZ_OVERRIDE;
   NS_IMETHOD GetCaretVisible(bool *_retval) MOZ_OVERRIDE;
   virtual void SetCaret(nsCaret *aNewCaret) MOZ_OVERRIDE;
   virtual void RestoreCaret() MOZ_OVERRIDE;
 
@@ -262,41 +262,41 @@ public:
   NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
 
   NS_DECL_NSIOBSERVER
 
 #ifdef MOZ_REFLOW_PERF
-  virtual NS_HIDDEN_(void) DumpReflows() MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) CountReflows(const char * aName, nsIFrame * aFrame) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) PaintCount(const char * aName,
+  virtual void DumpReflows() MOZ_OVERRIDE;
+  virtual void CountReflows(const char * aName, nsIFrame * aFrame) MOZ_OVERRIDE;
+  virtual void PaintCount(const char * aName,
                                       nsRenderingContext* aRenderingContext,
                                       nsPresContext* aPresContext,
                                       nsIFrame * aFrame,
                                       const nsPoint& aOffset,
                                       uint32_t aColor) MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(void) SetPaintFrameCount(bool aOn) MOZ_OVERRIDE;
+  virtual void SetPaintFrameCount(bool aOn) MOZ_OVERRIDE;
   virtual bool IsPaintingFrameCounts() MOZ_OVERRIDE;
 #endif
 
 #ifdef DEBUG
   virtual void ListStyleContexts(nsIFrame *aRootFrame, FILE *out,
                                  int32_t aIndent = 0) MOZ_OVERRIDE;
 
   virtual void ListStyleSheets(FILE *out, int32_t aIndent = 0) MOZ_OVERRIDE;
   virtual void VerifyStyleTree() MOZ_OVERRIDE;
 #endif
 
 #ifdef PR_LOGGING
   static PRLogModuleInfo* gLog;
 #endif
 
-  virtual NS_HIDDEN_(void) DisableNonTestMouseEvents(bool aDisable) MOZ_OVERRIDE;
+  virtual void DisableNonTestMouseEvents(bool aDisable) MOZ_OVERRIDE;
 
   virtual void UpdateCanvasBackground() MOZ_OVERRIDE;
 
   virtual void AddCanvasBackgroundColorItem(nsDisplayListBuilder& aBuilder,
                                             nsDisplayList& aList,
                                             nsIFrame* aFrame,
                                             const nsRect& aBounds,
                                             nscolor aBackstopColor,
@@ -304,17 +304,17 @@ public:
 
   virtual void AddPrintPreviewBackgroundItem(nsDisplayListBuilder& aBuilder,
                                              nsDisplayList& aList,
                                              nsIFrame* aFrame,
                                              const nsRect& aBounds) MOZ_OVERRIDE;
 
   virtual nscolor ComputeBackstopColor(nsView* aDisplayRoot) MOZ_OVERRIDE;
 
-  virtual NS_HIDDEN_(nsresult) SetIsActive(bool aIsActive) MOZ_OVERRIDE;
+  virtual nsresult SetIsActive(bool aIsActive) MOZ_OVERRIDE;
 
   virtual bool GetIsViewportOverridden() MOZ_OVERRIDE { return mViewportOverridden; }
 
   virtual bool IsLayoutFlushObserver() MOZ_OVERRIDE
   {
     return GetPresContext()->RefreshDriver()->
       IsLayoutFlushObserver(this);
   }
--- a/layout/base/nsStyleSheetService.h
+++ b/layout/base/nsStyleSheetService.h
@@ -34,38 +34,38 @@ class nsStyleSheetService MOZ_FINAL
  public:
   nsStyleSheetService() NS_HIDDEN;
   ~nsStyleSheetService() NS_HIDDEN;
 
   NS_DECL_ISUPPORTS
   NS_DECL_NSISTYLESHEETSERVICE
   NS_DECL_NSIMEMORYREPORTER
 
-  NS_HIDDEN_(nsresult) Init();
+  nsresult Init();
 
   nsCOMArray<nsIStyleSheet>* AgentStyleSheets() { return &mSheets[AGENT_SHEET]; }
   nsCOMArray<nsIStyleSheet>* UserStyleSheets() { return &mSheets[USER_SHEET]; }
   nsCOMArray<nsIStyleSheet>* AuthorStyleSheets() { return &mSheets[AUTHOR_SHEET]; }
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
   static nsStyleSheetService *GetInstance();
   static nsStyleSheetService *gInstance;
 
  private:
 
-  NS_HIDDEN_(void) RegisterFromEnumerator(nsICategoryManager  *aManager,
+  void RegisterFromEnumerator(nsICategoryManager  *aManager,
                                           const char          *aCategory,
                                           nsISimpleEnumerator *aEnumerator,
                                           uint32_t             aSheetType);
 
-  NS_HIDDEN_(int32_t) FindSheetByURI(const nsCOMArray<nsIStyleSheet> &sheets,
+  int32_t FindSheetByURI(const nsCOMArray<nsIStyleSheet> &sheets,
                                      nsIURI *sheetURI);
 
   // Like LoadAndRegisterSheet, but doesn't notify.  If successful, the
   // new sheet will be the last sheet in mSheets[aSheetType].
-  NS_HIDDEN_(nsresult) LoadAndRegisterSheetInternal(nsIURI *aSheetURI,
+  nsresult LoadAndRegisterSheetInternal(nsIURI *aSheetURI,
                                                     uint32_t aSheetType);
 
   nsCOMArray<nsIStyleSheet> mSheets[3];
 };
 
 #endif
--- a/layout/forms/nsFieldSetFrame.h
+++ b/layout/forms/nsFieldSetFrame.h
@@ -11,17 +11,17 @@
 
 class nsFieldSetFrame MOZ_FINAL : public nsContainerFrame
 {
 public:
   NS_DECL_FRAMEARENA_HELPERS
 
   nsFieldSetFrame(nsStyleContext* aContext);
 
-  NS_HIDDEN_(nscoord)
+  nscoord
     GetIntrinsicWidth(nsRenderingContext* aRenderingContext,
                       nsLayoutUtils::IntrinsicWidthType);
   virtual nscoord GetMinWidth(nsRenderingContext* aRenderingContext) MOZ_OVERRIDE;
   virtual nscoord GetPrefWidth(nsRenderingContext* aRenderingContext) MOZ_OVERRIDE;
   virtual nsSize ComputeSize(nsRenderingContext *aRenderingContext,
                              nsSize aCBSize, nscoord aAvailableWidth,
                              nsSize aMargin, nsSize aBorder, nsSize aPadding,
                              uint32_t aFlags) MOZ_OVERRIDE;
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -2648,35 +2648,35 @@ NS_PTR_TO_INT32(frame->Properties().Get(
   virtual bool IsCollapsed() = 0;
   // This does not alter the overflow area. If the caller is changing
   // the box size, the caller is responsible for updating the overflow
   // area. It's enough to just call Layout or SyncLayout on the
   // box. You can pass true to aRemoveOverflowArea as a
   // convenience.
   virtual void SetBounds(nsBoxLayoutState& aBoxLayoutState, const nsRect& aRect,
                          bool aRemoveOverflowAreas = false) = 0;
-  NS_HIDDEN_(nsresult) Layout(nsBoxLayoutState& aBoxLayoutState);
+  nsresult Layout(nsBoxLayoutState& aBoxLayoutState);
   // Box methods.  Note that these do NOT just get the CSS border, padding,
   // etc.  They also talk to nsITheme.
   virtual nsresult GetBorderAndPadding(nsMargin& aBorderAndPadding);
   virtual nsresult GetBorder(nsMargin& aBorder)=0;
   virtual nsresult GetPadding(nsMargin& aBorderAndPadding)=0;
   virtual nsresult GetMargin(nsMargin& aMargin)=0;
   virtual void SetLayoutManager(nsBoxLayout* aLayout) { }
   virtual nsBoxLayout* GetLayoutManager() { return nullptr; }
-  NS_HIDDEN_(nsresult) GetClientRect(nsRect& aContentRect);
+  nsresult GetClientRect(nsRect& aContentRect);
 
   // For nsSprocketLayout
   virtual Valignment GetVAlign() const = 0;
   virtual Halignment GetHAlign() const = 0;
 
   bool IsHorizontal() const { return (mState & NS_STATE_IS_HORIZONTAL) != 0; }
   bool IsNormalDirection() const { return (mState & NS_STATE_IS_DIRECTION_NORMAL) != 0; }
 
-  NS_HIDDEN_(nsresult) Redraw(nsBoxLayoutState& aState);
+  nsresult Redraw(nsBoxLayoutState& aState);
   virtual nsresult RelayoutChildAtOrdinal(nsBoxLayoutState& aState, nsIFrame* aChild)=0;
   // XXX take this out after we've branched
   virtual bool GetMouseThrough() const { return false; }
 
 #ifdef DEBUG_LAYOUT
   virtual nsresult SetDebug(nsBoxLayoutState& aState, bool aDebug)=0;
   virtual nsresult GetDebug(bool& aDebug)=0;
 
--- a/layout/xul/nsBox.h
+++ b/layout/xul/nsBox.h
@@ -42,30 +42,30 @@ public:
   virtual nsresult RelayoutChildAtOrdinal(nsBoxLayoutState& aState, nsIFrame* aChild) MOZ_OVERRIDE;
 
 #ifdef DEBUG_LAYOUT
   NS_IMETHOD GetDebugBoxAt(const nsPoint& aPoint, nsIFrame** aBox);
   virtual nsresult GetDebug(bool& aDebug) MOZ_OVERRIDE;
   virtual nsresult SetDebug(nsBoxLayoutState& aState, bool aDebug) MOZ_OVERRIDE;
 
   virtual nsresult DumpBox(FILE* out) MOZ_OVERRIDE;
-  NS_HIDDEN_(void) PropagateDebug(nsBoxLayoutState& aState);
+  void PropagateDebug(nsBoxLayoutState& aState);
 #endif
 
   nsBox();
   virtual ~nsBox();
 
   /**
    * Returns true if this box clips its children, e.g., if this box is an sc
 rollbox.
   */
   virtual bool DoesClipChildren();
   virtual bool ComputesOwnOverflowArea() = 0;
 
-  NS_HIDDEN_(nsresult) SyncLayout(nsBoxLayoutState& aBoxLayoutState);
+  nsresult SyncLayout(nsBoxLayoutState& aBoxLayoutState);
 
   bool DoesNeedRecalc(const nsSize& aSize);
   bool DoesNeedRecalc(nscoord aCoord);
   void SizeNeedsRecalc(nsSize& aSize);
   void CoordNeedsRecalc(nscoord& aCoord);
 
   void AddBorderAndPadding(nsSize& aSize);
 
@@ -86,23 +86,23 @@ protected:
 #ifdef DEBUG_LAYOUT
   virtual void AppendAttribute(const nsAutoString& aAttribute, const nsAutoString& aValue, nsAutoString& aResult);
 
   virtual void ListBox(nsAutoString& aResult);
 #endif
   
   virtual void GetLayoutFlags(uint32_t& aFlags);
 
-  NS_HIDDEN_(nsresult) BeginLayout(nsBoxLayoutState& aState);
+  nsresult BeginLayout(nsBoxLayoutState& aState);
   NS_IMETHOD DoLayout(nsBoxLayoutState& aBoxLayoutState);
-  NS_HIDDEN_(nsresult) EndLayout(nsBoxLayoutState& aState);
+  nsresult EndLayout(nsBoxLayoutState& aState);
 
 #ifdef DEBUG_LAYOUT
   virtual void GetBoxName(nsAutoString& aName);
-  NS_HIDDEN_(void) PropagateDebug(nsBoxLayoutState& aState);
+  void PropagateDebug(nsBoxLayoutState& aState);
 #endif
 
   static bool gGotTheme;
   static nsITheme* gTheme;
 
   enum eMouseThrough {
     unset,
     never,
--- a/layout/xul/nsBoxFrame.h
+++ b/layout/xul/nsBoxFrame.h
@@ -200,17 +200,17 @@ protected:
     bool GetEventPoint(mozilla::WidgetGUIEvent* aEvent, nsPoint& aPoint);
     // Gets the event coordinates relative to the widget offset associated with
     // this frame. Return true if a single valid point was found.
     bool GetEventPoint(mozilla::WidgetGUIEvent* aEvent, nsIntPoint& aPoint);
 
 protected:
     void RegUnregAccessKey(bool aDoReg);
 
-  NS_HIDDEN_(void) CheckBoxOrder();
+  void CheckBoxOrder();
 
 private: 
 
 #ifdef DEBUG_LAYOUT
     nsresult SetDebug(nsPresContext* aPresContext, bool aDebug);
     bool GetInitialDebug(bool& aDebug);
     void GetDebugPref(nsPresContext* aPresContext);
 
--- a/layout/xul/nsMenuFrame.h
+++ b/layout/xul/nsMenuFrame.h
@@ -261,17 +261,17 @@ protected:
   void CreateMenuCommandEvent(mozilla::WidgetGUIEvent* aEvent,
                               bool aFlipChecked);
   void PassMenuCommandEventToPopupManager();
 
 protected:
 #ifdef DEBUG_LAYOUT
   nsresult SetDebug(nsBoxLayoutState& aState, nsIFrame* aList, bool aDebug);
 #endif
-  NS_HIDDEN_(nsresult) Notify(nsITimer* aTimer);
+  nsresult Notify(nsITimer* aTimer);
 
   bool mIsMenu; // Whether or not we can even have children or not.
   bool mChecked;              // are we checked?
   bool mIgnoreAccelTextChange; // temporarily set while determining the accelerator key
   nsMenuType mType;
 
   // Reference to the mediator which wraps this frame.
   nsRefPtr<nsMenuTimerMediator> mTimerMediator;
--- a/modules/libjar/zipwriter/src/StreamFunctions.cpp
+++ b/modules/libjar/zipwriter/src/StreamFunctions.cpp
@@ -6,17 +6,17 @@
 #include "nscore.h"
 #include "nsIInputStream.h"
 #include "nsIOutputStream.h"
 
 /*
  * Fully reads the required amount of data. Keeps reading until all the
  * data is retrieved or an error is hit.
  */
-NS_HIDDEN_(nsresult) ZW_ReadData(nsIInputStream *aStream, char *aBuffer, uint32_t aCount)
+nsresult ZW_ReadData(nsIInputStream *aStream, char *aBuffer, uint32_t aCount)
 {
     while (aCount > 0) {
         uint32_t read;
         nsresult rv = aStream->Read(aBuffer, aCount, &read);
         NS_ENSURE_SUCCESS(rv, rv);
         aCount -= read;
         aBuffer += read;
         // If we hit EOF before reading the data we need then throw.
@@ -26,17 +26,17 @@ NS_HIDDEN_(nsresult) ZW_ReadData(nsIInpu
 
     return NS_OK;
 }
 
 /*
  * Fully writes the required amount of data. Keeps writing until all the
  * data is written or an error is hit.
  */
-NS_HIDDEN_(nsresult) ZW_WriteData(nsIOutputStream *aStream, const char *aBuffer,
+nsresult ZW_WriteData(nsIOutputStream *aStream, const char *aBuffer,
                                   uint32_t aCount)
 {
     while (aCount > 0) {
         uint32_t written;
         nsresult rv = aStream->Write(aBuffer, aCount, &written);
         NS_ENSURE_SUCCESS(rv, rv);
         if (written <= 0)
             return NS_ERROR_FAILURE;
--- a/modules/libjar/zipwriter/src/StreamFunctions.h
+++ b/modules/libjar/zipwriter/src/StreamFunctions.h
@@ -11,58 +11,58 @@
 #include "nsIOutputStream.h"
 
 /*
  * ZIP file data is stored little-endian. These are helper functions to read and
  * write little endian data to/from a char buffer.
  * The off argument, where present, is incremented according to the number of
  * bytes consumed from the buffer.
  */
-inline NS_HIDDEN_(void) WRITE8(uint8_t* buf, uint32_t* off, uint8_t val)
+inline void WRITE8(uint8_t* buf, uint32_t* off, uint8_t val)
 {
   buf[(*off)++] = val;
 }
 
-inline NS_HIDDEN_(void) WRITE16(uint8_t* buf, uint32_t* off, uint16_t val)
+inline void WRITE16(uint8_t* buf, uint32_t* off, uint16_t val)
 {
   WRITE8(buf, off, val & 0xff);
   WRITE8(buf, off, (val >> 8) & 0xff);
 }
 
-inline NS_HIDDEN_(void) WRITE32(uint8_t* buf, uint32_t* off, uint32_t val)
+inline void WRITE32(uint8_t* buf, uint32_t* off, uint32_t val)
 {
   WRITE16(buf, off, val & 0xffff);
   WRITE16(buf, off, (val >> 16) & 0xffff);
 }
 
-inline NS_HIDDEN_(uint8_t) READ8(const uint8_t* buf, uint32_t* off)
+inline uint8_t READ8(const uint8_t* buf, uint32_t* off)
 {
   return buf[(*off)++];
 }
 
-inline NS_HIDDEN_(uint16_t) READ16(const uint8_t* buf, uint32_t* off)
+inline uint16_t READ16(const uint8_t* buf, uint32_t* off)
 {
   uint16_t val = READ8(buf, off);
   val |= READ8(buf, off) << 8;
   return val;
 }
 
-inline NS_HIDDEN_(uint32_t) READ32(const uint8_t* buf, uint32_t* off)
+inline uint32_t READ32(const uint8_t* buf, uint32_t* off)
 {
   uint32_t val = READ16(buf, off);
   val |= READ16(buf, off) << 16;
   return val;
 }
 
-inline NS_HIDDEN_(uint32_t) PEEK32(const uint8_t* buf)
+inline uint32_t PEEK32(const uint8_t* buf)
 {
   return (uint32_t)( (buf [0]      ) |
                      (buf [1] <<  8) |
                      (buf [2] << 16) |
                      (buf [3] << 24) );
 }
 
-NS_HIDDEN_(nsresult) ZW_ReadData(nsIInputStream *aStream, char *aBuffer, uint32_t aCount);
+nsresult ZW_ReadData(nsIInputStream *aStream, char *aBuffer, uint32_t aCount);
 
-NS_HIDDEN_(nsresult) ZW_WriteData(nsIOutputStream *aStream, const char *aBuffer,
+nsresult ZW_WriteData(nsIOutputStream *aStream, const char *aBuffer,
                       uint32_t aCount);
 
 #endif
--- a/netwerk/base/public/nsNetStrings.h
+++ b/netwerk/base/public/nsNetStrings.h
@@ -13,12 +13,12 @@
  */
 class nsNetStrings {
 public:
   nsNetStrings();
 
   const nsLiteralString kChannelPolicy;
 };
 
-extern NS_HIDDEN_(nsNetStrings*) gNetStrings;
+extern nsNetStrings* gNetStrings;
 
 
 #endif
--- a/netwerk/base/public/nsNetUtil.h
+++ b/netwerk/base/public/nsNetUtil.h
@@ -2341,18 +2341,18 @@ NS_GenerateHostPort(const nsCString& hos
  * content type could not be sniffed.
  */
 inline void
 NS_SniffContent(const char* aSnifferType, nsIRequest* aRequest,
                 const uint8_t* aData, uint32_t aLength,
                 nsACString& aSniffedType)
 {
   typedef nsCategoryCache<nsIContentSniffer> ContentSnifferCache;
-  extern NS_HIDDEN_(ContentSnifferCache*) gNetSniffers;
-  extern NS_HIDDEN_(ContentSnifferCache*) gDataSniffers;
+  extern ContentSnifferCache* gNetSniffers;
+  extern ContentSnifferCache* gDataSniffers;
   ContentSnifferCache* cache = nullptr;
   if (!strcmp(aSnifferType, NS_CONTENT_SNIFFER_CATEGORY)) {
     if (!gNetSniffers) {
       gNetSniffers = new ContentSnifferCache(NS_CONTENT_SNIFFER_CATEGORY);
     }
     cache = gNetSniffers;
   } else if (!strcmp(aSnifferType, NS_DATA_SNIFFER_CATEGORY)) {
     if (!gDataSniffers) {
--- a/netwerk/base/src/nsIOService.h
+++ b/netwerk/base/src/nsIOService.h
@@ -51,18 +51,18 @@ public:
     NS_DECL_NSINETUTIL
     NS_DECL_NSISPECULATIVECONNECT
 
     // Gets the singleton instance of the IO Service, creating it as needed
     // Returns nullptr on out of memory or failure to initialize.
     // Returns an addrefed pointer.
     static nsIOService* GetInstance();
 
-    NS_HIDDEN_(nsresult) Init();
-    NS_HIDDEN_(nsresult) NewURI(const char* aSpec, nsIURI* aBaseURI,
+    nsresult Init();
+    nsresult NewURI(const char* aSpec, nsIURI* aBaseURI,
                                 nsIURI* *result,
                                 nsIProtocolHandler* *hdlrResult);
 
     // Called by channels before a redirect happens. This notifies the global
     // redirect observers.
     nsresult AsyncOnChannelRedirect(nsIChannel* oldChan, nsIChannel* newChan,
                                     uint32_t flags,
                                     nsAsyncRedirectVerifyHelper *helper);
@@ -76,29 +76,29 @@ public:
 
 private:
     // These shouldn't be called directly:
     // - construct using GetInstance
     // - destroy using Release
     nsIOService() NS_HIDDEN;
     ~nsIOService() NS_HIDDEN;
 
-    NS_HIDDEN_(nsresult) TrackNetworkLinkStatusForOffline();
+    nsresult TrackNetworkLinkStatusForOffline();
 
-    NS_HIDDEN_(nsresult) GetCachedProtocolHandler(const char *scheme,
+    nsresult GetCachedProtocolHandler(const char *scheme,
                                                   nsIProtocolHandler* *hdlrResult,
                                                   uint32_t start=0,
                                                   uint32_t end=0);
-    NS_HIDDEN_(nsresult) CacheProtocolHandler(const char *scheme,
+    nsresult CacheProtocolHandler(const char *scheme,
                                               nsIProtocolHandler* hdlr);
 
     // Prefs wrangling
-    NS_HIDDEN_(void) PrefsChanged(nsIPrefBranch *prefs, const char *pref = nullptr);
-    NS_HIDDEN_(void) GetPrefBranch(nsIPrefBranch **);
-    NS_HIDDEN_(void) ParsePortList(nsIPrefBranch *prefBranch, const char *pref, bool remove);
+    void PrefsChanged(nsIPrefBranch *prefs, const char *pref = nullptr);
+    void GetPrefBranch(nsIPrefBranch **);
+    void ParsePortList(nsIPrefBranch *prefBranch, const char *pref, bool remove);
 
     nsresult InitializeSocketTransportService();
     nsresult InitializeNetworkLinkService();
 
     // consolidated helper function
     void LookupProxyInfo(nsIURI *aURI, nsIURI *aProxyURI, uint32_t aProxyFlags,
                          nsCString *aScheme, nsIProxyInfo **outPI);
 
--- a/netwerk/base/src/nsInputStreamPump.h
+++ b/netwerk/base/src/nsInputStreamPump.h
@@ -27,17 +27,17 @@ public:
     NS_DECL_NSIREQUEST
     NS_DECL_NSIINPUTSTREAMPUMP
     NS_DECL_NSIINPUTSTREAMCALLBACK
     NS_DECL_NSITHREADRETARGETABLEREQUEST
 
     nsInputStreamPump(); 
     ~nsInputStreamPump();
 
-    static NS_HIDDEN_(nsresult)
+    static nsresult
                       Create(nsInputStreamPump  **result,
                              nsIInputStream      *stream,
                              int64_t              streamPos = -1,
                              int64_t              streamLen = -1,
                              uint32_t             segsize = 0,
                              uint32_t             segcount = 0,
                              bool                 closeWhenDone = false);
 
@@ -48,17 +48,17 @@ public:
      * method will not call the callback when there is no data in the stream.
      * The callback will be called at most once.
      *
      * The data from the stream will not be consumed, i.e. the pump's listener
      * can still read all the data.
      *
      * Do not call before asyncRead. Do not call after onStopRequest.
      */
-    NS_HIDDEN_(nsresult) PeekStream(PeekSegmentFun callback, void *closure);
+    nsresult PeekStream(PeekSegmentFun callback, void *closure);
 
     /**
      * Dispatched (to the main thread) by OnStateStop if it's called off main
      * thread. Updates mState based on return value of OnStateStop.
      */
     nsresult CallOnStateStop();
 
 protected:
--- a/netwerk/base/src/nsNetStrings.cpp
+++ b/netwerk/base/src/nsNetStrings.cpp
@@ -1,14 +1,14 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsNetStrings.h"
 #include "nsChannelProperties.h"
 
-NS_HIDDEN_(nsNetStrings*) gNetStrings;
+nsNetStrings* gNetStrings;
 
 nsNetStrings::nsNetStrings()
   : NS_LITERAL_STRING_INIT(kChannelPolicy, NS_CHANNEL_PROP_CHANNEL_POLICY_STR)
 {}
 
 
--- a/netwerk/base/src/nsPACMan.h
+++ b/netwerk/base/src/nsPACMan.h
@@ -144,17 +144,17 @@ public:
     if (mPACURISpec.IsEmpty() && mPACURIRedirectSpec.IsEmpty())
       return false;
 
     nsAutoCString tmp;
     uri->GetSpec(tmp);
     return IsPACURI(tmp);
   }
 
-  NS_HIDDEN_(nsresult) Init(nsISystemProxySettings *);
+  nsresult Init(nsISystemProxySettings *);
   static nsPACMan *sInstance;
 
   // PAC thread operations only
   void ProcessPendingQ();
   void CancelPendingQ(nsresult);
 
 private:
   NS_DECL_NSISTREAMLOADEROBSERVER
--- a/netwerk/base/src/nsProtocolProxyService.h
+++ b/netwerk/base/src/nsProtocolProxyService.h
@@ -33,34 +33,34 @@ class nsProtocolProxyService MOZ_FINAL :
 public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSIPROTOCOLPROXYSERVICE2
     NS_DECL_NSIPROTOCOLPROXYSERVICE
     NS_DECL_NSIOBSERVER
 
     nsProtocolProxyService() NS_HIDDEN;
 
-    NS_HIDDEN_(nsresult) Init();
+    nsresult Init();
 
 protected:
     friend class nsAsyncResolveRequest;
 
     ~nsProtocolProxyService() NS_HIDDEN;
 
     /**
      * This method is called whenever a preference may have changed or
      * to initialize all preferences.
      *
      * @param prefs
      *        This must be a pointer to the root pref branch.
      * @param name
      *        This can be the name of a fully-qualified preference, or it can
      *        be null, in which case all preferences will be initialized.
      */
-    NS_HIDDEN_(void) PrefsChanged(nsIPrefBranch *prefs, const char *name);
+    void PrefsChanged(nsIPrefBranch *prefs, const char *name);
 
     /**
      * This method is called to create a nsProxyInfo instance from the given
      * PAC-style proxy string.  It parses up to the end of the string, or to
      * the next ';' character.
      * 
      * @param proxy
      *        The PAC-style proxy string to parse.  This must not be null.
@@ -68,98 +68,98 @@ protected:
      *        The flags passed to Resolve or AsyncResolve that are stored in 
      *        proxyInfo.
      * @param result
      *        Upon return this points to a newly allocated nsProxyInfo or null
      *        if the proxy string was invalid.
      *
      * @return A pointer beyond the parsed proxy string (never null).
      */
-    NS_HIDDEN_(const char *) ExtractProxyInfo(const char *proxy,
+    const char * ExtractProxyInfo(const char *proxy,
                                               uint32_t aResolveFlags,
                                               nsProxyInfo **result);
 
     /**
      * Load the specified PAC file.
      * 
      * @param pacURI
      *        The URI spec of the PAC file to load.
      */
-    NS_HIDDEN_(nsresult) ConfigureFromPAC(const nsCString &pacURI, bool forceReload);
+    nsresult ConfigureFromPAC(const nsCString &pacURI, bool forceReload);
 
     /**
      * This method builds a list of nsProxyInfo objects from the given PAC-
      * style string.
      *
      * @param pacString
      *        The PAC-style proxy string to parse.  This may be empty.
      * @param aResolveFlags
      *        The flags passed to Resolve or AsyncResolve that are stored in 
      *        proxyInfo.
      * @param result
      *        The resulting list of proxy info objects.
      */
-    NS_HIDDEN_(void) ProcessPACString(const nsCString &pacString,
+    void ProcessPACString(const nsCString &pacString,
                                       uint32_t aResolveFlags,
                                       nsIProxyInfo **result);
 
     /**
      * This method generates a string valued identifier for the given
      * nsProxyInfo object.
      *
      * @param pi
      *        The nsProxyInfo object from which to generate the key.
      * @param result
      *        Upon return, this parameter holds the generated key.
      */
-    NS_HIDDEN_(void) GetProxyKey(nsProxyInfo *pi, nsCString &result);
+    void GetProxyKey(nsProxyInfo *pi, nsCString &result);
 
     /**
      * @return Seconds since start of session.
      */
-    NS_HIDDEN_(uint32_t) SecondsSinceSessionStart();
+    uint32_t SecondsSinceSessionStart();
 
     /**
      * This method removes the specified proxy from the disabled list.
      *
      * @param pi
      *        The nsProxyInfo object identifying the proxy to enable.
      */
-    NS_HIDDEN_(void) EnableProxy(nsProxyInfo *pi);
+    void EnableProxy(nsProxyInfo *pi);
 
     /**
      * This method adds the specified proxy to the disabled list.
      *
      * @param pi
      *        The nsProxyInfo object identifying the proxy to disable.
      */
-    NS_HIDDEN_(void) DisableProxy(nsProxyInfo *pi);
+    void DisableProxy(nsProxyInfo *pi);
 
     /**
      * This method tests to see if the given proxy is disabled.
      *
      * @param pi
      *        The nsProxyInfo object identifying the proxy to test.
      *
      * @return True if the specified proxy is disabled.
      */
-    NS_HIDDEN_(bool) IsProxyDisabled(nsProxyInfo *pi);
+    bool IsProxyDisabled(nsProxyInfo *pi);
 
     /**
      * This method queries the protocol handler for the given scheme to check
      * for the protocol flags and default port.
      *
      * @param uri
      *        The URI to query.
      * @param info
      *        Holds information about the protocol upon return.  Pass address
      *        of structure when you call this method.  This parameter must not
      *        be null.
      */
-    NS_HIDDEN_(nsresult) GetProtocolInfo(nsIURI *uri, nsProtocolInfo *result);
+    nsresult GetProtocolInfo(nsIURI *uri, nsProtocolInfo *result);
 
     /**
      * This method is an internal version nsIProtocolProxyService::newProxyInfo
      * that expects a string literal for the type.
      *
      * @param type
      *        The proxy type.
      * @param host
@@ -172,17 +172,17 @@ protected:
      *        The failover timeout for this proxy.
      * @param next
      *        The next proxy to try if this one fails.
      * @param aResolveFlags
      *        The flags passed to resolve (from nsIProtocolProxyService).
      * @param result
      *        The resulting nsIProxyInfo object.
      */
-    NS_HIDDEN_(nsresult) NewProxyInfo_Internal(const char *type,
+    nsresult NewProxyInfo_Internal(const char *type,
                                                const nsACString &host,
                                                int32_t port,
                                                uint32_t flags,
                                                uint32_t timeout,
                                                nsIProxyInfo *next,
                                                uint32_t aResolveFlags,
                                                nsIProxyInfo **result);
 
@@ -199,34 +199,34 @@ protected:
      * @param flags
      *        The flags passed to either the resolve or the asyncResolve method.
      * @param usePAC
      *        If this flag is set upon return, then PAC should be queried to
      *        resolve the proxy info.
      * @param result
      *        The resulting proxy info or null.
      */
-    NS_HIDDEN_(nsresult) Resolve_Internal(nsIURI *uri,
+    nsresult Resolve_Internal(nsIURI *uri,
                                           const nsProtocolInfo &info,
                                           uint32_t flags,
                                           bool *usePAC, 
                                           nsIProxyInfo **result);
 
     /**
      * This method applies the registered filters to the given proxy info
      * list, and returns a possibly modified list.
      *
      * @param uri
      *        The URI corresponding to this proxy info list.
      * @param info
      *        Information about the URI's protocol.
      * @param proxyInfo
      *        The proxy info list to be modified.  This is an inout param.
      */
-    NS_HIDDEN_(void) ApplyFilters(nsIURI *uri, const nsProtocolInfo &info,
+    void ApplyFilters(nsIURI *uri, const nsProtocolInfo &info,
                                   nsIProxyInfo **proxyInfo);
 
     /**
      * This method is a simple wrapper around ApplyFilters that takes the
      * proxy info list inout param as a nsCOMPtr.
      */
     inline void ApplyFilters(nsIURI *uri, const nsProtocolInfo &info,
                              nsCOMPtr<nsIProxyInfo> &proxyInfo)
@@ -241,46 +241,46 @@ protected:
      * This method prunes out disabled and disallowed proxies from a given
      * proxy info list.
      *
      * @param info
      *        Information about the URI's protocol.
      * @param proxyInfo
      *        The proxy info list to be modified.  This is an inout param.
      */
-    NS_HIDDEN_(void) PruneProxyInfo(const nsProtocolInfo &info,
+    void PruneProxyInfo(const nsProtocolInfo &info,
                                     nsIProxyInfo **proxyInfo);
 
     /**
      * This method populates mHostFiltersArray from the given string.
      *
      * @param hostFilters
      *        A "no-proxy-for" exclusion list.
      */
-    NS_HIDDEN_(void) LoadHostFilters(const char *hostFilters);
+    void LoadHostFilters(const char *hostFilters);
 
     /**
      * This method checks the given URI against mHostFiltersArray.
      *
      * @param uri
      *        The URI to test.
      * @param defaultPort
      *        The default port for the given URI.
      *
      * @return True if the URI can use the specified proxy.
      */
-    NS_HIDDEN_(bool) CanUseProxy(nsIURI *uri, int32_t defaultPort);
+    bool CanUseProxy(nsIURI *uri, int32_t defaultPort);
 
     /**
      * Disable Prefetch in the DNS service if a proxy is in use.
      *
      * @param aProxy
      *        The proxy information
      */
-    NS_HIDDEN_(void) MaybeDisableDNSPrefetch(nsIProxyInfo *aProxy);
+    void MaybeDisableDNSPrefetch(nsIProxyInfo *aProxy);
 
 private:
     nsresult SetupPACThread();
     nsresult ResetPACThread();
 
 public:
     // The Sun Forte compiler and others implement older versions of the
     // C++ standard's rules on access and nested classes.  These structs
--- a/netwerk/base/src/nsTransportUtils.h
+++ b/netwerk/base/src/nsTransportUtils.h
@@ -15,15 +15,15 @@
  * the previous event has not yet been delivered, then only one event will
  * be delivered.  The progress reported will be that from the second event.
  * If aCoalesceAllEvents is true, then any undelivered event will be replaced
  * with the next event if it arrives early enough.  This option should be used
  * cautiously since it can cause states to be effectively skipped.  Coalescing
  * events can help prevent a backlog of unprocessed transport events in the
  * case that the target thread is overworked.
  */
-NS_HIDDEN_(nsresult)
+nsresult
 net_NewTransportEventSinkProxy(nsITransportEventSink **aResult,
                                nsITransportEventSink *aSink,
                                nsIEventTarget *aTarget,
                                bool aCoalesceAllEvents = false);
 
 #endif // nsTransportUtils_h__
--- a/netwerk/base/src/nsURLHelper.h
+++ b/netwerk/base/src/nsURLHelper.h
@@ -29,76 +29,76 @@ enum netCoalesceFlags
   NET_COALESCE_DOUBLE_SLASH_IS_ROOT = 1<<1
 };
 
 //----------------------------------------------------------------------------
 // This module contains some private helper functions related to URL parsing.
 //----------------------------------------------------------------------------
 
 /* shutdown frees URL parser */
-NS_HIDDEN_(void) net_ShutdownURLHelper();
+void net_ShutdownURLHelper();
 #ifdef XP_MACOSX
-NS_HIDDEN_(void) net_ShutdownURLHelperOSX();
+void net_ShutdownURLHelperOSX();
 #endif
 
 /* access URL parsers */
-NS_HIDDEN_(nsIURLParser *) net_GetAuthURLParser();
-NS_HIDDEN_(nsIURLParser *) net_GetNoAuthURLParser();
-NS_HIDDEN_(nsIURLParser *) net_GetStdURLParser();
+nsIURLParser * net_GetAuthURLParser();
+nsIURLParser * net_GetNoAuthURLParser();
+nsIURLParser * net_GetStdURLParser();
 
 /* convert between nsIFile and file:// URL spec 
  * net_GetURLSpecFromFile does an extra stat, so callers should
  * avoid it if possible in favor of net_GetURLSpecFromActualFile
  * and net_GetURLSpecFromDir */
-NS_HIDDEN_(nsresult) net_GetURLSpecFromFile(nsIFile *, nsACString &);
-NS_HIDDEN_(nsresult) net_GetURLSpecFromDir(nsIFile *, nsACString &);
-NS_HIDDEN_(nsresult) net_GetURLSpecFromActualFile(nsIFile *, nsACString &);
-NS_HIDDEN_(nsresult) net_GetFileFromURLSpec(const nsACString &, nsIFile **);
+nsresult net_GetURLSpecFromFile(nsIFile *, nsACString &);
+nsresult net_GetURLSpecFromDir(nsIFile *, nsACString &);
+nsresult net_GetURLSpecFromActualFile(nsIFile *, nsACString &);
+nsresult net_GetFileFromURLSpec(const nsACString &, nsIFile **);
 
 /* extract file path components from file:// URL */
-NS_HIDDEN_(nsresult) net_ParseFileURL(const nsACString &inURL,
+nsresult net_ParseFileURL(const nsACString &inURL,
                                       nsACString &outDirectory,
                                       nsACString &outFileBaseName,
                                       nsACString &outFileExtension);
 
 /* handle .. in dirs while resolving URLs (path is UTF-8) */
-NS_HIDDEN_(void) net_CoalesceDirs(netCoalesceFlags flags, char* path);
+void net_CoalesceDirs(netCoalesceFlags flags, char* path);
 
 /**
  * Resolves a relative path string containing "." and ".."
  * with respect to a base path (assumed to already be resolved). 
  * For example, resolving "../../foo/./bar/../baz.html" w.r.t.
  * "/a/b/c/d/e/" yields "/a/b/c/foo/baz.html". Attempting to 
  * ascend above the base results in the NS_ERROR_MALFORMED_URI
  * exception. If basePath is null, it treats it as "/".
  *
  * @param relativePath  a relative URI
  * @param basePath      a base URI
  *
  * @return a new string, representing canonical uri
  */
-NS_HIDDEN_(nsresult) net_ResolveRelativePath(const nsACString &relativePath,
+nsresult net_ResolveRelativePath(const nsACString &relativePath,
                                              const nsACString &basePath,
                                              nsACString &result);
 
 /**
  * Extract URI-Scheme if possible
  *
  * @param inURI     URI spec
  * @param startPos  start of scheme (may be null)
  * @param endPos    end of scheme; index of colon (may be null)
  * @param scheme    scheme copied to this buffer on return (may be null)
  */
-NS_HIDDEN_(nsresult) net_ExtractURLScheme(const nsACString &inURI,
+nsresult net_ExtractURLScheme(const nsACString &inURI,
                                           uint32_t *startPos, 
                                           uint32_t *endPos,
                                           nsACString *scheme = nullptr);
 
 /* check that the given scheme conforms to RFC 2396 */
-NS_HIDDEN_(bool) net_IsValidScheme(const char *scheme, uint32_t schemeLen);
+bool net_IsValidScheme(const char *scheme, uint32_t schemeLen);
 
 inline bool net_IsValidScheme(const nsAFlatCString &scheme)
 {
     return net_IsValidScheme(scheme.get(), scheme.Length());
 }
 
 /**
  * Filter out whitespace from a URI string.  The input is the |str|
@@ -111,87 +111,87 @@ inline bool net_IsValidScheme(const nsAF
  * call on things like javascript: urls or data: urls, where we may in fact run
  * into whitespace that is not properly encoded.  Note that stripping does not
  * occur in the scheme portion itself.
  *
  * @param str the pointer to the string to filter.  Must be non-null.
  * @param result the out param to write to if filtering happens
  * @return whether result was written to
  */
-NS_HIDDEN_(bool) net_FilterURIString(const char *str, nsACString& result);
+bool net_FilterURIString(const char *str, nsACString& result);
 
 #if defined(XP_WIN)
 /**
  * On Win32 and OS/2 system's a back-slash in a file:// URL is equivalent to a
  * forward-slash.  This function maps any back-slashes to forward-slashes.
  *
  * @param aURL
  *        The URL string to normalize (UTF-8 encoded).  This can be a
  *        relative URL segment.
  * @param aResultBuf 
  *        The resulting string is appended to this string.  If the input URL
  *        is already normalized, then aResultBuf is unchanged.
  *
  * @returns false if aURL is already normalized.  Otherwise, returns true.
  */
-NS_HIDDEN_(bool) net_NormalizeFileURL(const nsACString &aURL,
+bool net_NormalizeFileURL(const nsACString &aURL,
                                         nsCString &aResultBuf);
 #endif
 
 /*****************************************************************************
  * generic string routines follow (XXX move to someplace more generic).
  */
 
 /* convert to lower case */
-NS_HIDDEN_(void) net_ToLowerCase(char* str, uint32_t length);
-NS_HIDDEN_(void) net_ToLowerCase(char* str);
+void net_ToLowerCase(char* str, uint32_t length);
+void net_ToLowerCase(char* str);
 
 /**
  * returns pointer to first character of |str| in the given set.  if not found,
  * then |end| is returned.  stops prematurely if a null byte is encountered,
  * and returns the address of the null byte.
  */
-NS_HIDDEN_(char *) net_FindCharInSet(const char *str, const char *end, const char *set);
+char * net_FindCharInSet(const char *str, const char *end, const char *set);
 
 /**
  * returns pointer to first character of |str| NOT in the given set.  if all
  * characters are in the given set, then |end| is returned.  if '\0' is not
  * included in |set|, then stops prematurely if a null byte is encountered,
  * and returns the address of the null byte.
  */
-NS_HIDDEN_(char *) net_FindCharNotInSet(const char *str, const char *end, const char *set);
+char * net_FindCharNotInSet(const char *str, const char *end, const char *set);
 
 /**
  * returns pointer to last character of |str| NOT in the given set.  if all
  * characters are in the given set, then |str - 1| is returned.
  */
-NS_HIDDEN_(char *) net_RFindCharNotInSet(const char *str, const char *end, const char *set);
+char * net_RFindCharNotInSet(const char *str, const char *end, const char *set);
 
 /**
  * Parses a content-type header and returns the content type and
  * charset (if any).  aCharset is not modified if no charset is
  * specified in anywhere in aHeaderStr.  In that case (no charset
  * specified), aHadCharset is set to false.  Otherwise, it's set to
  * true.  Note that aContentCharset can be empty even if aHadCharset
  * is true.
  */
-NS_HIDDEN_(void) net_ParseContentType(const nsACString &aHeaderStr,
+void net_ParseContentType(const nsACString &aHeaderStr,
                                       nsACString       &aContentType,
                                       nsACString       &aContentCharset,
                                       bool*          aHadCharset);
 /**
  * As above, but also returns the start and end indexes for the charset
  * parameter in aHeaderStr.  These are indices for the entire parameter, NOT
  * just the value.  If there is "effectively" no charset parameter (e.g. if an
  * earlier type with one is overridden by a later type without one),
  * *aHadCharset will be true but *aCharsetStart will be set to -1.  Note that
  * it's possible to have aContentCharset empty and *aHadCharset true when
  * *aCharsetStart is nonnegative; this corresponds to charset="".
  */
-NS_HIDDEN_(void) net_ParseContentType(const nsACString &aHeaderStr,
+void net_ParseContentType(const nsACString &aHeaderStr,
                                       nsACString       &aContentType,
                                       nsACString       &aContentCharset,
                                       bool             *aHadCharset,
                                       int32_t          *aCharsetStart,
                                       int32_t          *aCharsetEnd);
 
 /* inline versions */
 
@@ -210,21 +210,21 @@ inline char *net_RFindCharNotInSet(const
 {
     return net_RFindCharNotInSet(str, str + strlen(str), set);
 }
 
 /**
  * This function returns true if the given hostname does not include any
  * restricted characters.  Otherwise, false is returned.
  */
-NS_HIDDEN_(bool) net_IsValidHostName(const nsCSubstring &host);
+bool net_IsValidHostName(const nsCSubstring &host);
 
 /**
  * Checks whether the IPv4 address is valid according to RFC 3986 section 3.2.2.
  */
-NS_HIDDEN_(bool) net_IsValidIPv4Addr(const char *addr, int32_t addrLen);
+bool net_IsValidIPv4Addr(const char *addr, int32_t addrLen);
 
 /**
  * Checks whether the IPv6 address is valid according to RFC 3986 section 3.2.2.
  */
-NS_HIDDEN_(bool) net_IsValidIPv6Addr(const char *addr, int32_t addrLen);
+bool net_IsValidIPv6Addr(const char *addr, int32_t addrLen);
 
 #endif // !nsURLHelper_h__
--- a/netwerk/build/nsNetModule.cpp
+++ b/netwerk/build/nsNetModule.cpp
@@ -44,18 +44,18 @@
 
 #include "nsNetCID.h"
 
 #ifndef XP_MACOSX
 #define BUILD_BINHEX_DECODER 1
 #endif
 
 typedef nsCategoryCache<nsIContentSniffer> ContentSnifferCache;
-NS_HIDDEN_(ContentSnifferCache*) gNetSniffers = nullptr;
-NS_HIDDEN_(ContentSnifferCache*) gDataSniffers = nullptr;
+ContentSnifferCache* gNetSniffers = nullptr;
+ContentSnifferCache* gDataSniffers = nullptr;
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "nsIOService.h"
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIOService, nsIOService::GetInstance)
 
 #include "nsDNSService2.h"
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIDNSService,
--- a/netwerk/protocol/data/nsDataHandler.h
+++ b/netwerk/protocol/data/nsDataHandler.h
@@ -22,17 +22,17 @@ public:
 
     // Define a Create method to be used with a factory:
     static nsresult
     Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult);
 
     // Parse a data: URI and return the individual parts
     // (the given spec will temporarily be modified but will be returned
     //  to the original before returning)
-    static NS_HIDDEN_(nsresult) ParseURI(nsCString& spec,
+    static nsresult ParseURI(nsCString& spec,
                                          nsCString& contentType,
                                          nsCString& contentCharset,
                                          bool&    isBase64,
                                          nsCString& dataBuffer,
                                          nsCString& hashRef);
 };
 
 #endif /* nsDataHandler_h___ */
--- a/netwerk/protocol/viewsource/nsViewSourceChannel.h
+++ b/netwerk/protocol/viewsource/nsViewSourceChannel.h
@@ -42,19 +42,19 @@ public:
     NS_FORWARD_SAFE_NSIUPLOADCHANNEL(mUploadChannel)
     NS_FORWARD_SAFE_NSIHTTPCHANNELINTERNAL(mHttpChannelInternal)
 
     // nsViewSourceChannel methods:
     nsViewSourceChannel()
         : mIsDocument(false)
         , mOpened(false) {}
 
-    NS_HIDDEN_(nsresult) Init(nsIURI* uri);
+    nsresult Init(nsIURI* uri);
 
-    NS_HIDDEN_(nsresult) InitSrcdoc(nsIURI* aURI, const nsAString &aSrcdoc,
+    nsresult InitSrcdoc(nsIURI* aURI, const nsAString &aSrcdoc,
                                     nsIURI* aBaseURI);
 
 protected:
     nsCOMPtr<nsIChannel>        mChannel;
     nsCOMPtr<nsIHttpChannel>    mHttpChannel;
     nsCOMPtr<nsIHttpChannelInternal>    mHttpChannelInternal;
     nsCOMPtr<nsICachingChannel> mCachingChannel;
     nsCOMPtr<nsIApplicationCacheChannel> mApplicationCacheChannel;
--- a/parser/htmlparser/public/nsScannerString.h
+++ b/parser/htmlparser/public/nsScannerString.h
@@ -286,17 +286,17 @@ class nsScannerSharedSubstring
 
       ~nsScannerSharedSubstring()
         {
           if (mBufferList)
             ReleaseBuffer();
         }
 
         // Acquire a copy-on-write reference to the given substring.
-      NS_HIDDEN_(void) Rebind(const nsScannerIterator& aStart,
+      void Rebind(const nsScannerIterator& aStart,
                               const nsScannerIterator& aEnd);
 
        // Get a mutable reference to this string
       nsSubstring& writable()
         {
           if (mBufferList)
             MakeMutable();
 
@@ -304,18 +304,18 @@ class nsScannerSharedSubstring
         }
 
         // Get a const reference to this string
       const nsSubstring& str() const { return mString; }
 
     private:
       typedef nsScannerBufferList::Buffer Buffer;
 
-      NS_HIDDEN_(void) ReleaseBuffer();
-      NS_HIDDEN_(void) MakeMutable();
+      void ReleaseBuffer();
+      void MakeMutable();
 
       nsDependentSubstring  mString;
       Buffer               *mBuffer;
       nsScannerBufferList  *mBufferList;
   };
 
   /**
    * nsScannerIterator works just like nsReadingIterator<CharT> except that
--- a/storage/src/FileSystemModule.h
+++ b/storage/src/FileSystemModule.h
@@ -9,14 +9,14 @@
 
 #include "nscore.h"
 
 struct sqlite3;
 
 namespace mozilla {
 namespace storage {
 
-NS_HIDDEN_(int) RegisterFileSystemModule(sqlite3* aDB, const char* aName);
+int RegisterFileSystemModule(sqlite3* aDB, const char* aName);
 
 } // namespace storage
 } // namespace mozilla
 
 #endif // mozilla_storage_FileSystemModule_h
--- a/storage/src/SQLCollations.h
+++ b/storage/src/SQLCollations.h
@@ -21,17 +21,17 @@ namespace storage {
  * database and Service.
  *
  * @param  aDB
  *         The database we'll be registering the collations with.
  * @param  aService
  *         The Service that owns the nsICollation used by our collations.
  * @return the SQLite status code indicating success or failure.
  */
-NS_HIDDEN_(int) registerCollations(sqlite3 *aDB, Service *aService);
+int registerCollations(sqlite3 *aDB, Service *aService);
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Predefined Functions
 
 /**
  * Custom UTF-8 collating sequence that respects the application's locale.
  * Comparison is case- and accent-insensitive.  This is called by SQLite.
  *
@@ -46,17 +46,17 @@ NS_HIDDEN_(int) registerCollations(sqlit
  *         The number of bytes in aStr2.
  * @param  aStr2
  *         The string to be compared against aStr1.  It will be passed in by
  *         SQLite as a non-null-terminated char* buffer.
  * @return aStr1 - aStr2.  That is, if aStr1 < aStr2, returns a negative number.
  *         If aStr1 > aStr2, returns a positive number.  If aStr1 == aStr2,
  *         returns 0.
  */
-NS_HIDDEN_(int) localeCollation8(void *aService,
+int localeCollation8(void *aService,
                                  int aLen1,
                                  const void *aStr1,
                                  int aLen2,
                                  const void *aStr2);
 
 /**
  * Custom UTF-8 collating sequence that respects the application's locale.
  * Comparison is case-sensitive and accent-insensitive.  This is called by
@@ -73,17 +73,17 @@ NS_HIDDEN_(int) localeCollation8(void *a
  *         The number of bytes in aStr2.
  * @param  aStr2
  *         The string to be compared against aStr1.  It will be passed in by
  *         SQLite as a non-null-terminated char* buffer.
  * @return aStr1 - aStr2.  That is, if aStr1 < aStr2, returns a negative number.
  *         If aStr1 > aStr2, returns a positive number.  If aStr1 == aStr2,
  *         returns 0.
  */
-NS_HIDDEN_(int) localeCollationCaseSensitive8(void *aService,
+int localeCollationCaseSensitive8(void *aService,
                                               int aLen1,
                                               const void *aStr1,
                                               int aLen2,
                                               const void *aStr2);
 
 /**
  * Custom UTF-8 collating sequence that respects the application's locale.
  * Comparison is case-insensitive and accent-sensitive.  This is called by
@@ -100,17 +100,17 @@ NS_HIDDEN_(int) localeCollationCaseSensi
  *         The number of bytes in aStr2.
  * @param  aStr2
  *         The string to be compared against aStr1.  It will be passed in by
  *         SQLite as a non-null-terminated char* buffer.
  * @return aStr1 - aStr2.  That is, if aStr1 < aStr2, returns a negative number.
  *         If aStr1 > aStr2, returns a positive number.  If aStr1 == aStr2,
  *         returns 0.
  */
-NS_HIDDEN_(int) localeCollationAccentSensitive8(void *aService,
+int localeCollationAccentSensitive8(void *aService,
                                                 int aLen1,
                                                 const void *aStr1,
                                                 int aLen2,
                                                 const void *aStr2);
 
 /**
  * Custom UTF-8 collating sequence that respects the application's locale.
  * Comparison is case- and accent-sensitive.  This is called by SQLite.
@@ -126,17 +126,17 @@ NS_HIDDEN_(int) localeCollationAccentSen
  *         The number of bytes in aStr2.
  * @param  aStr2
  *         The string to be compared against aStr1.  It will be passed in by
  *         SQLite as a non-null-terminated char* buffer.
  * @return aStr1 - aStr2.  That is, if aStr1 < aStr2, returns a negative number.
  *         If aStr1 > aStr2, returns a positive number.  If aStr1 == aStr2,
  *         returns 0.
  */
-NS_HIDDEN_(int) localeCollationCaseAccentSensitive8(void *aService,
+int localeCollationCaseAccentSensitive8(void *aService,
                                                     int aLen1,
                                                     const void *aStr1,
                                                     int aLen2,
                                                     const void *aStr2);
 
 /**
  * Custom UTF-16 collating sequence that respects the application's locale.
  * Comparison is case- and accent-insensitive.  This is called by SQLite.
@@ -152,17 +152,17 @@ NS_HIDDEN_(int) localeCollationCaseAccen
  *         The number of bytes (not characters) in aStr2.
  * @param  aStr2
  *         The string to be compared against aStr1.  It will be passed in by
  *         SQLite as a non-null-terminated char16_t* buffer.
  * @return aStr1 - aStr2.  That is, if aStr1 < aStr2, returns a negative number.
  *         If aStr1 > aStr2, returns a positive number.  If aStr1 == aStr2,
  *         returns 0.
  */
-NS_HIDDEN_(int) localeCollation16(void *aService,
+int localeCollation16(void *aService,
                                   int aLen1,
                                   const void *aStr1,
                                   int aLen2,
                                   const void *aStr2);
 
 /**
  * Custom UTF-16 collating sequence that respects the application's locale.
  * Comparison is case-sensitive and accent-insensitive.  This is called by
@@ -179,17 +179,17 @@ NS_HIDDEN_(int) localeCollation16(void *
  *         The number of bytes (not characters) in aStr2.
  * @param  aStr2
  *         The string to be compared against aStr1.  It will be passed in by
  *         SQLite as a non-null-terminated char16_t* buffer.
  * @return aStr1 - aStr2.  That is, if aStr1 < aStr2, returns a negative number.
  *         If aStr1 > aStr2, returns a positive number.  If aStr1 == aStr2,
  *         returns 0.
  */
-NS_HIDDEN_(int) localeCollationCaseSensitive16(void *aService,
+int localeCollationCaseSensitive16(void *aService,
                                                int aLen1,
                                                const void *aStr1,
                                                int aLen2,
                                                const void *aStr2);
 
 /**
  * Custom UTF-16 collating sequence that respects the application's locale.
  * Comparison is case-insensitive and accent-sensitive.  This is called by
@@ -206,17 +206,17 @@ NS_HIDDEN_(int) localeCollationCaseSensi
  *         The number of bytes (not characters) in aStr2.
  * @param  aStr2
  *         The string to be compared against aStr1.  It will be passed in by
  *         SQLite as a non-null-terminated char16_t* buffer.
  * @return aStr1 - aStr2.  That is, if aStr1 < aStr2, returns a negative number.
  *         If aStr1 > aStr2, returns a positive number.  If aStr1 == aStr2,
  *         returns 0.
  */
-NS_HIDDEN_(int) localeCollationAccentSensitive16(void *aService,
+int localeCollationAccentSensitive16(void *aService,
                                                  int aLen1,
                                                  const void *aStr1,
                                                  int aLen2,
                                                  const void *aStr2);
 
 /**
  * Custom UTF-16 collating sequence that respects the application's locale.
  * Comparison is case- and accent-sensitive.  This is called by SQLite.
@@ -232,17 +232,17 @@ NS_HIDDEN_(int) localeCollationAccentSen
  *         The number of bytes (not characters) in aStr2.
  * @param  aStr2
  *         The string to be compared against aStr1.  It will be passed in by
  *         SQLite as a non-null-terminated char16_t* buffer.
  * @return aStr1 - aStr2.  That is, if aStr1 < aStr2, returns a negative number.
  *         If aStr1 > aStr2, returns a positive number.  If aStr1 == aStr2,
  *         returns 0.
  */
-NS_HIDDEN_(int) localeCollationCaseAccentSensitive16(void *aService,
+int localeCollationCaseAccentSensitive16(void *aService,
                                                      int aLen1,
                                                      const void *aStr1,
                                                      int aLen2,
                                                      const void *aStr2);
 
 } // namespace storage
 } // namespace mozilla
 
--- a/storage/src/mozStorageSQLFunctions.h
+++ b/storage/src/mozStorageSQLFunctions.h
@@ -15,62 +15,62 @@ namespace storage {
 
 /**
  * Registers the functions declared here with the specified database.
  *
  * @param aDB
  *        The database we'll be registering the functions with.
  * @return the SQLite status code indicating success or failure.
  */
-NS_HIDDEN_(int) registerFunctions(sqlite3 *aDB);
+int registerFunctions(sqlite3 *aDB);
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Predefined Functions
 
 /**
  * Overridden function to perform the SQL functions UPPER and LOWER.  These
  * support unicode, which the default implementations do not do.
  *
  * @param aCtx
  *        The sqlite_context that this function is being called on.
  * @param aArgc
  *        The number of arguments the function is being called with.
  * @param aArgv
  *        An array of the arguments the functions is being called with.
  */
-NS_HIDDEN_(void) caseFunction(sqlite3_context *aCtx,
+void caseFunction(sqlite3_context *aCtx,
                               int aArgc,
                               sqlite3_value **aArgv);
 
 /**
  * Overridden function to perform the SQL function LIKE.  This supports unicode,
  * which the default implementation does not do.
  *
  * @param aCtx
  *        The sqlite_context that this function is being called on.
  * @param aArgc
  *        The number of arguments the function is being called with.
  * @param aArgv
  *        An array of the arguments the functions is being called with.
  */
-NS_HIDDEN_(void) likeFunction(sqlite3_context *aCtx,
+void likeFunction(sqlite3_context *aCtx,
                               int aArgc,
                               sqlite3_value **aArgv);
 
 /**
  * An implementation of the Levenshtein Edit Distance algorithm for use in
  * Sqlite queries.
  * 
  * @param aCtx
  *        The sqlite_context that this function is being called on.
  * @param aArgc
  *        The number of arguments the function is being called with.
  * @param aArgv
  *        An array of the arguments the functions is being called with.
  */
-NS_HIDDEN_(void) levenshteinDistanceFunction(sqlite3_context *aCtx,
+void levenshteinDistanceFunction(sqlite3_context *aCtx,
                                              int aArgc,
                                              sqlite3_value **aArgv);
 
 } // namespace storage
 } // namespace mozilla
 
 #endif // mozStorageSQLFunctions_h
--- a/toolkit/components/typeaheadfind/nsTypeAheadFind.h
+++ b/toolkit/components/typeaheadfind/nsTypeAheadFind.h
@@ -63,17 +63,17 @@ protected:
   nsresult GetSearchContainers(nsISupports *aContainer,
                                nsISelectionController *aSelectionController,
                                bool aIsFirstVisiblePreferred,
                                bool aFindPrev, nsIPresShell **aPresShell,
                                nsPresContext **aPresContext);
 
   // Get the pres shell from mPresShell and return it only if it is still
   // attached to the DOM window.
-  NS_HIDDEN_(already_AddRefed<nsIPresShell>) GetPresShell();
+  already_AddRefed<nsIPresShell> GetPresShell();
 
   void ReleaseStrongMemberVariables();
 
   // Current find state
   nsString mTypeAheadBuffer;
   nsCString mNotFoundSoundURL;
 
   // PRBools are used instead of PRPackedBools because the address of the
--- a/toolkit/profile/nsToolkitProfileService.cpp
+++ b/toolkit/profile/nsToolkitProfileService.cpp
@@ -117,17 +117,17 @@ private:
     {
         gService = this;
     }
     ~nsToolkitProfileService()
     {
         gService = nullptr;
     }
 
-    NS_HIDDEN_(nsresult) Init();
+    nsresult Init();
 
     nsresult CreateTimesInternal(nsIFile *profileDir);
 
     nsresult CreateProfileInternal(nsIFile* aRootDir,
                                    const nsACString& aName,
                                    const nsACString* aProfileName,
                                    const nsACString* aAppName,
                                    const nsACString* aVendorName,
--- a/toolkit/system/gnome/nsGConfService.h
+++ b/toolkit/system/gnome/nsGConfService.h
@@ -15,17 +15,17 @@
 
 class nsGConfService MOZ_FINAL : public nsIGConfService
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIGCONFSERVICE
 
   nsGConfService() : mClient(nullptr) {}
-  NS_HIDDEN_(nsresult) Init();
+  nsresult Init();
 
 private:
   ~nsGConfService() NS_HIDDEN;
 
   GConfClient *mClient;
 };
 
 #endif
--- a/toolkit/system/gnome/nsGSettingsService.h
+++ b/toolkit/system/gnome/nsGSettingsService.h
@@ -12,16 +12,16 @@
 {0xbfd4a9d8, 0xd886, 0x4161, {0x81, 0xef, 0x88, 0x68, 0xda, 0x11, 0x41, 0x70}}
 
 class nsGSettingsService MOZ_FINAL : public nsIGSettingsService
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIGSETTINGSSERVICE
 
-  NS_HIDDEN_(nsresult) Init();
+  nsresult Init();
 
 private:
   ~nsGSettingsService();
 };
 
 #endif
 
--- a/toolkit/system/gnome/nsGnomeVFSService.h
+++ b/toolkit/system/gnome/nsGnomeVFSService.h
@@ -13,12 +13,12 @@
 {0x5f43022c, 0x6194, 0x4b37, {0xb2, 0x6d, 0xe4, 0x10, 0x24, 0x62, 0x52, 0x64}}
 
 class nsGnomeVFSService MOZ_FINAL : public nsIGnomeVFSService
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIGNOMEVFSSERVICE
 
-  NS_HIDDEN_(nsresult) Init();
+  nsresult Init();
 };
 
 #endif
--- a/toolkit/xre/nsAppRunner.h
+++ b/toolkit/xre/nsAppRunner.h
@@ -60,20 +60,20 @@ extern bool gLogConsoleErrors;
 
 /**
  * Create the nativeappsupport implementation.
  *
  * @note XPCOMInit has not happened yet.
  */
 nsresult NS_CreateNativeAppSupport(nsINativeAppSupport* *aResult);
 
-NS_HIDDEN_(nsresult)
+nsresult
 NS_NewToolkitProfileService(nsIToolkitProfileService* *aResult);
 
-NS_HIDDEN_(nsresult)
+nsresult
 NS_NewToolkitProfileFactory(nsIFactory* *aResult);
 
 /**
  * Try to acquire exclusive access to the specified profile directory.
  *
  * @param aPath
  *        The profile directory to lock.
  * @param aTempPath
@@ -83,21 +83,21 @@ NS_NewToolkitProfileFactory(nsIFactory* 
  *        appears to be locked.
  * @param aResult
  *        The resulting profile lock object (or null if the profile could
  *        not be locked).
  *
  * @return NS_ERROR_FILE_ACCESS_DENIED to indicate that the profile
  *         directory cannot be unlocked.
  */
-NS_HIDDEN_(nsresult)
+nsresult
 NS_LockProfilePath(nsIFile* aPath, nsIFile* aTempPath,
                    nsIProfileUnlocker* *aUnlocker, nsIProfileLock* *aResult);
 
-NS_HIDDEN_(void)
+void
 WriteConsoleLog();
 
 #ifdef XP_WIN
 BOOL
 WinLaunchChild(const wchar_t *exePath, int argc,
                char **argv, HANDLE userToken = nullptr,
                HANDLE *hProcess = nullptr);
 BOOL
--- a/toolkit/xre/nsUpdateDriver.h
+++ b/toolkit/xre/nsUpdateDriver.h
@@ -43,17 +43,17 @@ class nsIFile;
  * version and is used to determine if an update's version is older than the
  * current application version.
  *
  * If you want the update to be processed without restarting, set the restart
  * parameter to false.
  *
  * This function does not modify appDir.
  */
-NS_HIDDEN_(nsresult) ProcessUpdates(nsIFile *greDir, nsIFile *appDir,
+nsresult ProcessUpdates(nsIFile *greDir, nsIFile *appDir,
                                     nsIFile *updRootDir,
                                     int argc, char **argv,
                                     const char *appVersion,
                                     bool restart = true,
                                     bool isOSUpdate = false,
                                     nsIFile *osApplyToDir = nullptr,
                                     ProcessType *pid = nullptr);
 
--- a/uriloader/base/nsURILoader.h
+++ b/uriloader/base/nsURILoader.h
@@ -33,17 +33,17 @@ public:
   nsURILoader();
   ~nsURILoader();
 
 protected:
   /**
    * Equivalent to nsIURILoader::openChannel, but allows specifying whether the
    * channel is opened already.
    */
-  NS_HIDDEN_(nsresult) OpenChannel(nsIChannel* channel,
+  nsresult OpenChannel(nsIChannel* channel,
                                    uint32_t aFlags,
                                    nsIInterfaceRequestor* aWindowContext,
                                    bool aChannelOpen,
                                    nsIStreamListener** aListener);
 
   /**
    * we shouldn't need to have an owning ref count on registered
    * content listeners because they are supposed to unregister themselves
--- a/uriloader/exthandler/android/nsMIMEInfoAndroid.h
+++ b/uriloader/exthandler/android/nsMIMEInfoAndroid.h
@@ -26,18 +26,18 @@ public:
 
   NS_DECL_ISUPPORTS
   NS_DECL_NSIMIMEINFO
   NS_DECL_NSIHANDLERINFO
 
   nsMIMEInfoAndroid(const nsACString& aMIMEType);
 
 protected:
-  virtual NS_HIDDEN_(nsresult) LaunchDefaultWithFile(nsIFile* aFile);
-  virtual NS_HIDDEN_(nsresult) LoadUriInternal(nsIURI *aURI);
+  virtual nsresult LaunchDefaultWithFile(nsIFile* aFile);
+  virtual nsresult LoadUriInternal(nsIURI *aURI);
   nsCOMPtr<nsIMutableArray> mHandlerApps;
   nsCString mType;
   nsTArray<nsCString> mExtensions;
   bool mAlwaysAsk;
   nsHandlerInfoAction mPrefAction;
   nsString mDescription;
   nsCOMPtr<nsIHandlerApp> mPrefApp;
   
--- a/uriloader/exthandler/android/nsOSHelperAppService.h
+++ b/uriloader/exthandler/android/nsOSHelperAppService.h
@@ -15,17 +15,17 @@ public:
     nsOSHelperAppService();
     virtual ~nsOSHelperAppService();
 
     virtual already_AddRefed<nsIMIMEInfo>
     GetMIMEInfoFromOS(const nsACString& aMIMEType,
                       const nsACString& aFileExt,
                       bool* aFound);
 
-    virtual NS_HIDDEN_(nsresult)
+    virtual nsresult
     OSProtocolHandlerExists(const char* aScheme,
                             bool* aExists);
 
     NS_IMETHOD GetProtocolHandlerInfoFromOS(const nsACString &aScheme,
                                             bool *found,
                                             nsIHandlerInfo **_retval);
 
     static nsIHandlerApp*
--- a/uriloader/exthandler/gonk/nsOSHelperAppService.cpp
+++ b/uriloader/exthandler/gonk/nsOSHelperAppService.cpp
@@ -17,17 +17,17 @@
 #include "nsOSHelperAppService.h"
 #include "nsMIMEInfoImpl.h"
 
 class nsGonkMIMEInfo : public nsMIMEInfoImpl {
 public:
     nsGonkMIMEInfo(const nsACString& aMIMEType) : nsMIMEInfoImpl(aMIMEType) { }
 
 protected:
-    virtual NS_HIDDEN_(nsresult) LoadUriInternal(nsIURI *aURI) {
+    virtual nsresult LoadUriInternal(nsIURI *aURI) {
         return NS_ERROR_NOT_IMPLEMENTED;
     }
 };
 
 nsOSHelperAppService::nsOSHelperAppService() : nsExternalHelperAppService()
 {
 }
 
--- a/uriloader/exthandler/gonk/nsOSHelperAppService.h
+++ b/uriloader/exthandler/gonk/nsOSHelperAppService.h
@@ -26,14 +26,14 @@ public:
     nsOSHelperAppService();
     virtual ~nsOSHelperAppService();
 
     virtual already_AddRefed<nsIMIMEInfo>
     GetMIMEInfoFromOS(const nsACString& aMIMEType,
                       const nsACString& aFileExt,
                       bool* aFound);
 
-    virtual NS_HIDDEN_(nsresult)
+    virtual nsresult
     OSProtocolHandlerExists(const char* aScheme,
                             bool* aExists);
 };
 
 #endif /* nsOSHelperAppService_h */
--- a/uriloader/exthandler/mac/nsMIMEInfoMac.h
+++ b/uriloader/exthandler/mac/nsMIMEInfoMac.h
@@ -11,24 +11,24 @@ class nsMIMEInfoMac : public nsMIMEInfoI
   public:
     nsMIMEInfoMac(const char* aMIMEType = "") : nsMIMEInfoImpl(aMIMEType) {}
     nsMIMEInfoMac(const nsACString& aMIMEType) : nsMIMEInfoImpl(aMIMEType) {}
     nsMIMEInfoMac(const nsACString& aType, HandlerClass aClass) :
       nsMIMEInfoImpl(aType, aClass) {}
 
     NS_IMETHOD LaunchWithFile(nsIFile* aFile);
   protected:
-    virtual NS_HIDDEN_(nsresult) LoadUriInternal(nsIURI *aURI);
+    virtual nsresult LoadUriInternal(nsIURI *aURI);
 #ifdef DEBUG
-    virtual NS_HIDDEN_(nsresult) LaunchDefaultWithFile(nsIFile* aFile) {
+    virtual nsresult LaunchDefaultWithFile(nsIFile* aFile) {
       NS_NOTREACHED("do not call this method, use LaunchWithFile");
       return NS_ERROR_UNEXPECTED;
     }
 #endif
-    static NS_HIDDEN_(nsresult) OpenApplicationWithURI(nsIFile *aApplication, 
+    static nsresult OpenApplicationWithURI(nsIFile *aApplication, 
                                                        const nsCString& aURI);
                                                        
     NS_IMETHOD GetDefaultDescription(nsAString& aDefaultDescription);
     
 };
 
 
 #endif
--- a/uriloader/exthandler/nsExternalHelperAppService.h
+++ b/uriloader/exthandler/nsExternalHelperAppService.h
@@ -66,17 +66,17 @@ public:
 
   nsExternalHelperAppService();
   virtual ~nsExternalHelperAppService();
 
   /**
    * Initializes internal state. Will be called automatically when
    * this service is first instantiated.
    */
-  NS_HIDDEN_(nsresult) Init();
+  nsresult Init();
  
   /**
    * Given a mimetype and an extension, looks up a mime info from the OS.
    * The mime type is given preference. This function follows the same rules
    * as nsIMIMEService::GetFromTypeAndExtension.
    * This is supposed to be overridden by the platform-specific
    * nsOSHelperAppService!
    * @param aFileExt The file extension; may be empty. UTF-8 encoded.
@@ -104,48 +104,48 @@ public:
    *                        file spec, a unix path or a windows path depending
    *                        on the platform
    * @param aFile           [out] An nsIFile representation of that platform
    *                        application path.
    */
   virtual nsresult GetFileTokenForPath(const char16_t * platformAppPath,
                                        nsIFile ** aFile);
 
-  virtual NS_HIDDEN_(nsresult) OSProtocolHandlerExists(const char *aScheme,
+  virtual nsresult OSProtocolHandlerExists(const char *aScheme,
                                                        bool *aExists) = 0;
 
 protected:
   /**
    * Searches the "extra" array of MIMEInfo objects for an object
    * with a specific type. If found, it will modify the passed-in
    * MIMEInfo. Otherwise, it will return an error and the MIMEInfo
    * will be untouched.
    * @param aContentType The type to search for.
    * @param aMIMEInfo    [inout] The mime info, if found
    */
-  NS_HIDDEN_(nsresult) FillMIMEInfoForMimeTypeFromExtras(
+  nsresult FillMIMEInfoForMimeTypeFromExtras(
     const nsACString& aContentType, nsIMIMEInfo * aMIMEInfo);
   /**
    * Searches the "extra" array of MIMEInfo objects for an object
    * with a specific extension.
    *
    * Does not change the MIME Type of the MIME Info.
    *
    * @see FillMIMEInfoForMimeTypeFromExtras
    */
-  NS_HIDDEN_(nsresult) FillMIMEInfoForExtensionFromExtras(
+  nsresult FillMIMEInfoForExtensionFromExtras(
     const nsACString& aExtension, nsIMIMEInfo * aMIMEInfo);
 
   /**
    * Searches the "extra" array for a MIME type, and gets its extension.
    * @param aExtension The extension to search for
    * @param aMIMEType [out] The found MIME type.
    * @return true if the extension was found, false otherwise.
    */
-  NS_HIDDEN_(bool) GetTypeFromExtras(const nsACString& aExtension,
+  bool GetTypeFromExtras(const nsACString& aExtension,
                                        nsACString& aMIMEType);
 
 #ifdef PR_LOGGING
   /**
    * NSPR Logging Module. Usage: set NSPR_LOG_MODULES=HelperAppService:level,
    * where level should be 2 for errors, 3 for debug messages from the cross-
    * platform nsExternalHelperAppService, and 4 for os-specific debug messages.
    */
--- a/uriloader/exthandler/nsLocalHandlerApp.h
+++ b/uriloader/exthandler/nsLocalHandlerApp.h
@@ -37,17 +37,17 @@ protected:
   /**
    * Launches this application with a single argument (typically either
    * a file path or a URI spec).  This is meant as a helper method for
    * implementations of (e.g.) LaunchWithURI.
    *
    * @param aApp The application to launch (may not be null)
    * @param aArg The argument to pass on the command line
    */
-  NS_HIDDEN_(nsresult) LaunchWithIProcess(const nsCString &aArg);
+  nsresult LaunchWithIProcess(const nsCString &aArg);
 };
 
 // any platforms that need a platform-specific class instead of just 
 // using nsLocalHandlerApp need to add an include and a typedef here.
 #ifdef XP_MACOSX
 # ifndef NSLOCALHANDLERAPPMAC_H_  
 # include "mac/nsLocalHandlerAppMac.h"
 typedef nsLocalHandlerAppMac PlatformLocalHandlerApp_t;
--- a/uriloader/exthandler/nsMIMEInfoImpl.h
+++ b/uriloader/exthandler/nsMIMEInfoImpl.h
@@ -94,49 +94,49 @@ class nsMIMEInfoBase : public nsIMIMEInf
   protected:
     /**
      * Launch the default application for the given file.
      * For even more control over the launching, override launchWithFile.
      * Also see the comment about nsIMIMEInfo in general, above.
      *
      * @param aFile The file that should be opened
      */
-    virtual NS_HIDDEN_(nsresult) LaunchDefaultWithFile(nsIFile* aFile) = 0;
+    virtual nsresult LaunchDefaultWithFile(nsIFile* aFile) = 0;
 
     /**
      * Loads the URI with the OS default app.
      *
      * @param aURI The URI to pass off to the OS.
      */
-    virtual NS_HIDDEN_(nsresult) LoadUriInternal(nsIURI *aURI) = 0;
+    virtual nsresult LoadUriInternal(nsIURI *aURI) = 0;
 
     static already_AddRefed<nsIProcess> InitProcess(nsIFile* aApp,
                                                     nsresult* aResult);
 
     /**
      * This method can be used to launch the file or URI with a single 
      * argument (typically either a file path or a URI spec).  This is 
      * meant as a helper method for implementations of
      * LaunchWithURI/LaunchDefaultWithFile.
      *
      * @param aApp The application to launch (may not be null)
      * @param aArg The argument to pass on the command line
      */
-    static NS_HIDDEN_(nsresult) LaunchWithIProcess(nsIFile* aApp,
+    static nsresult LaunchWithIProcess(nsIFile* aApp,
                                                    const nsCString &aArg);
-    static NS_HIDDEN_(nsresult) LaunchWithIProcess(nsIFile* aApp,
+    static nsresult LaunchWithIProcess(nsIFile* aApp,
                                                    const nsString &aArg);
 
     /**
      * Given a file: nsIURI, return the associated nsIFile
      *
      * @param  aURI      the file: URI in question
      * @param  aFile     the associated nsIFile (out param)
      */
-    static NS_HIDDEN_(nsresult) GetLocalFileFromURI(nsIURI *aURI,
+    static nsresult GetLocalFileFromURI(nsIURI *aURI,
                                                     nsIFile **aFile);
 
     // member variables
     nsTArray<nsCString>    mExtensions; ///< array of file extensions associated w/ this MIME obj
     nsString               mDescription; ///< human readable description
     nsCString              mSchemeOrType;
     HandlerClass           mClass;
     nsCOMPtr<nsIHandlerApp> mPreferredApplication;
@@ -176,20 +176,20 @@ class nsMIMEInfoImpl : public nsMIMEInfo
     void SetDefaultApplication(nsIFile* aApp) { if (!mDefaultApplication) mDefaultApplication = aApp; }
 
   protected:
     // nsMIMEInfoBase methods
     /**
      * The base class implementation is to use LaunchWithIProcess in combination
      * with mDefaultApplication. Subclasses can override that behaviour.
      */
-    virtual NS_HIDDEN_(nsresult) LaunchDefaultWithFile(nsIFile* aFile);
+    virtual nsresult LaunchDefaultWithFile(nsIFile* aFile);
 
     /**
      * Loads the URI with the OS default app.  This should be overridden by each
      * OS's implementation.
      */
-    virtual NS_HIDDEN_(nsresult) LoadUriInternal(nsIURI *aURI) = 0;
+    virtual nsresult LoadUriInternal(nsIURI *aURI) = 0;
 
     nsCOMPtr<nsIFile>      mDefaultApplication; ///< default application associated with this type.
 };
 
 #endif //__nsmimeinfoimpl_h___
--- a/uriloader/exthandler/unix/nsMIMEInfoUnix.h
+++ b/uriloader/exthandler/unix/nsMIMEInfoUnix.h
@@ -16,17 +16,17 @@ public:
   nsMIMEInfoUnix(const nsACString& aMIMEType) : nsMIMEInfoImpl(aMIMEType) {}
   nsMIMEInfoUnix(const nsACString& aType, HandlerClass aClass) :
     nsMIMEInfoImpl(aType, aClass) {}
   static bool HandlerExists(const char *aProtocolScheme);
 
 protected:
   NS_IMETHOD GetHasDefaultHandler(bool *_retval);
 
-  virtual NS_HIDDEN_(nsresult) LoadUriInternal(nsIURI *aURI);
+  virtual nsresult LoadUriInternal(nsIURI *aURI);
 
-  virtual NS_HIDDEN_(nsresult) LaunchDefaultWithFile(nsIFile *aFile);
+  virtual nsresult LaunchDefaultWithFile(nsIFile *aFile);
 #if defined(MOZ_ENABLE_CONTENTACTION)
   NS_IMETHOD GetPossibleApplicationHandlers(nsIMutableArray * *aPossibleAppHandlers);
 #endif
 };
 
 #endif // nsMIMEInfoUnix_h_
--- a/uriloader/exthandler/win/nsMIMEInfoWin.h
+++ b/uriloader/exthandler/win/nsMIMEInfoWin.h
@@ -26,17 +26,17 @@ class nsMIMEInfoWin : public nsMIMEInfoB
     NS_DECL_NSIPROPERTYBAG
 
     void SetDefaultApplicationHandler(nsIFile* aDefaultApplication) 
     { 
       mDefaultApplication = aDefaultApplication; 
     }
 
   protected:
-    virtual NS_HIDDEN_(nsresult) LoadUriInternal(nsIURI *aURI);
+    virtual nsresult LoadUriInternal(nsIURI *aURI);
     virtual nsresult LaunchDefaultWithFile(nsIFile* aFile);
 
   private:
     nsCOMPtr<nsIFile>      mDefaultApplication;
     
     // Given a path to a local handler, return its 
     // nsILocalHandlerApp instance.
     bool GetLocalHandlerApp(const nsAString& aCommandHandler,
--- a/widget/gtk/nsNativeThemeGTK.h
+++ b/widget/gtk/nsNativeThemeGTK.h
@@ -24,22 +24,22 @@ public:
   NS_IMETHOD DrawWidgetBackground(nsRenderingContext* aContext,
                                   nsIFrame* aFrame, uint8_t aWidgetType,
                                   const nsRect& aRect,
                                   const nsRect& aDirtyRect);
 
   NS_IMETHOD GetWidgetBorder(nsDeviceContext* aContext, nsIFrame* aFrame,
                              uint8_t aWidgetType, nsIntMargin* aResult);
 
-  virtual NS_HIDDEN_(bool) GetWidgetPadding(nsDeviceContext* aContext,
+  virtual bool GetWidgetPadding(nsDeviceContext* aContext,
                                               nsIFrame* aFrame,
                                               uint8_t aWidgetType,
                                               nsIntMargin* aResult);
 
-  virtual NS_HIDDEN_(bool) GetWidgetOverflow(nsDeviceContext* aContext,
+  virtual bool GetWidgetOverflow(nsDeviceContext* aContext,
                                                nsIFrame* aFrame,
                                                uint8_t aWidgetType,
                                                nsRect* aOverflowRect);
 
   NS_IMETHOD GetMinimumWidgetSize(nsRenderingContext* aContext,
                                   nsIFrame* aFrame, uint8_t aWidgetType,
                                   nsIntSize* aResult, bool* aIsOverridable);
 
--- a/xpcom/base/nsMemoryImpl.h
+++ b/xpcom/base/nsMemoryImpl.h
@@ -30,18 +30,18 @@ public:
     return 1;
   }
 
   NS_DECL_NSIMEMORY
 
   static nsresult Create(nsISupports* aOuter,
                          const nsIID& aIID, void** aResult);
 
-  NS_HIDDEN_(nsresult) FlushMemory(const char16_t* aReason, bool aImmediate);
-  NS_HIDDEN_(nsresult) RunFlushers(const char16_t* aReason);
+  nsresult FlushMemory(const char16_t* aReason, bool aImmediate);
+  nsresult RunFlushers(const char16_t* aReason);
 
 protected:
   struct FlushEvent : public nsIRunnable
   {
     NS_DECL_ISUPPORTS_INHERITED
     NS_DECL_NSIRUNNABLE
     const char16_t* mReason;
   };
--- a/xpcom/ds/TimeStamp.h
+++ b/xpcom/ds/TimeStamp.h
@@ -338,18 +338,18 @@ public:
     MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
     return mValue != aOther.mValue;
   }
 
   // Comparing TimeStamps for equality should be discouraged. Adding
   // two TimeStamps, or scaling TimeStamps, is nonsense and must never
   // be allowed.
 
-  static NS_HIDDEN_(nsresult) Startup();
-  static NS_HIDDEN_(void) Shutdown();
+  static nsresult Startup();
+  static void Shutdown();
 
 private:
   friend struct IPC::ParamTraits<mozilla::TimeStamp>;
   friend void StartupTimelineRecordExternal(int, uint64_t);
 
   TimeStamp(TimeStampValue aValue) : mValue(aValue) {}
 
   static TimeStamp Now(bool aHighResolution);
--- a/xpcom/ds/nsMathUtils.h
+++ b/xpcom/ds/nsMathUtils.h
@@ -14,34 +14,34 @@
 
 #ifdef SOLARIS
 #include <ieeefp.h>
 #endif
 
 /*
  * round
  */
-inline NS_HIDDEN_(double) NS_round(double x)
+inline double NS_round(double x)
 {
     return x >= 0.0 ? floor(x + 0.5) : ceil(x - 0.5);
 }
-inline NS_HIDDEN_(float) NS_roundf(float x)
+inline float NS_roundf(float x)
 {
     return x >= 0.0f ? floorf(x + 0.5f) : ceilf(x - 0.5f);
 }
-inline NS_HIDDEN_(int32_t) NS_lround(double x)
+inline int32_t NS_lround(double x)
 {
     return x >= 0.0 ? int32_t(x + 0.5) : int32_t(x - 0.5);
 }
 
 /* NS_roundup30 rounds towards infinity for positive and       */
 /* negative numbers.                                           */
 
 #if defined(XP_WIN32) && defined(_M_IX86) && !defined(__GNUC__)
-inline NS_HIDDEN_(int32_t) NS_lroundup30(float x)
+inline int32_t NS_lroundup30(float x)
 {
     /* Code derived from Laurent de Soras' paper at             */
     /* http://ldesoras.free.fr/doc/articles/rounding_en.pdf     */
 
     /* Rounding up on Windows is expensive using the float to   */
     /* int conversion and the floor function. A faster          */
     /* approach is to use f87 rounding while assuming the       */
     /* default rounding mode of rounding to the nearest         */
@@ -63,42 +63,42 @@ inline NS_HIDDEN_(int32_t) NS_lroundup30
       fadd    st, st(0)           ; double it
       fadd    round_to_nearest    ; add the rounding factor
       fistp   dword ptr i         ; convert the result to int
     }
     return i >> 1;                /* divide by 2 */
 }
 #endif /* XP_WIN32 && _M_IX86 && !__GNUC__ */
 
-inline NS_HIDDEN_(int32_t) NS_lroundf(float x)
+inline int32_t NS_lroundf(float x)
 {
     return x >= 0.0f ? int32_t(x + 0.5f) : int32_t(x - 0.5f);
 }
 
 /*
  * hypot.  We don't need a super accurate version of this, if a platform
  * turns up with none of the possibilities below it would be okay to fall
  * back to sqrt(x*x + y*y).
  */
-inline NS_HIDDEN_(double) NS_hypot(double x, double y)
+inline double NS_hypot(double x, double y)
 {
 #ifdef __GNUC__
     return __builtin_hypot(x, y);
 #elif defined _WIN32
     return _hypot(x, y);
 #else
     return hypot(x, y);
 #endif
 }
 
 /**
  * Check whether a floating point number is finite (not +/-infinity and not a
  * NaN value).
  */
-inline NS_HIDDEN_(bool) NS_finite(double d)
+inline bool NS_finite(double d)
 {
 #ifdef WIN32
     // NOTE: '!!' casts an int to bool without spamming MSVC warning C4800.
     return !!_finite(d);
 #elif defined(XP_DARWIN)
     // Darwin has deprecated |finite| and recommends |isfinite|. The former is
     // not present in the iOS SDK.
     return std::isfinite(d);
@@ -108,14 +108,14 @@ inline NS_HIDDEN_(bool) NS_finite(double
 }
 
 /**
  * Returns the result of the modulo of x by y using a floored division.
  * fmod(x, y) is using a truncated division.
  * The main difference is that the result of this method will have the sign of
  * y while the result of fmod(x, y) will have the sign of x.
  */
-inline NS_HIDDEN_(double) NS_floorModulo(double x, double y)
+inline double NS_floorModulo(double x, double y)
 {
   return (x - y * floor(x / y));
 }
 
 #endif
--- a/xpcom/threads/TimerThread.h
+++ b/xpcom/threads/TimerThread.h
@@ -28,24 +28,24 @@ class TimerThread MOZ_FINAL
   , public nsIObserver
 {
 public:
   typedef mozilla::Monitor Monitor;
   typedef mozilla::TimeStamp TimeStamp;
   typedef mozilla::TimeDuration TimeDuration;
 
   TimerThread();
-  NS_HIDDEN_(nsresult) InitLocks();
+  nsresult InitLocks();
 
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIRUNNABLE
   NS_DECL_NSIOBSERVER
 
-  NS_HIDDEN_(nsresult) Init();
-  NS_HIDDEN_(nsresult) Shutdown();
+  nsresult Init();
+  nsresult Shutdown();
 
   nsresult AddTimer(nsTimerImpl* aTimer);
   nsresult TimerDelayChanged(nsTimerImpl* aTimer);
   nsresult RemoveTimer(nsTimerImpl* aTimer);
 
   void DoBeforeSleep();
   void DoAfterSleep();
 
--- a/xpcom/threads/nsTimerImpl.h
+++ b/xpcom/threads/nsTimerImpl.h
@@ -47,18 +47,18 @@ enum
 
 class nsTimerImpl MOZ_FINAL : public nsITimer
 {
 public:
   typedef mozilla::TimeStamp TimeStamp;
 
   nsTimerImpl();
 
-  static NS_HIDDEN_(nsresult) Startup();
-  static NS_HIDDEN_(void) Shutdown();
+  static nsresult Startup();
+  static void Shutdown();
 
   friend class TimerThread;
   friend struct TimerAdditionComparator;
 
   void Fire();
   nsresult PostTimerEvent();
   void SetDelayInternal(uint32_t aDelay);
 
--- a/xpfe/appshell/src/nsXULWindow.h
+++ b/xpfe/appshell/src/nsXULWindow.h
@@ -96,20 +96,20 @@ protected:
    bool       LoadMiscPersistentAttributesFromXUL();
    void       SyncAttributesToWidget();
    NS_IMETHOD SavePersistentAttributes();
 
    NS_IMETHOD GetWindowDOMWindow(nsIDOMWindow** aDOMWindow);
    mozilla::dom::Element* GetWindowDOMElement() const;
 
    // See nsIDocShellTreeOwner for docs on next two methods
-   NS_HIDDEN_(nsresult) ContentShellAdded(nsIDocShellTreeItem* aContentShell,
+   nsresult ContentShellAdded(nsIDocShellTreeItem* aContentShell,
                                           bool aPrimary, bool aTargetable,
                                           const nsAString& aID);
-   NS_HIDDEN_(nsresult) ContentShellRemoved(nsIDocShellTreeItem* aContentShell);
+   nsresult ContentShellRemoved(nsIDocShellTreeItem* aContentShell);
    NS_IMETHOD SizeShellTo(nsIDocShellTreeItem* aShellItem, int32_t aCX, 
       int32_t aCY);
    NS_IMETHOD ExitModalLoop(nsresult aStatus);
    NS_IMETHOD CreateNewChromeWindow(int32_t aChromeFlags, nsIXULWindow **_retval);
    NS_IMETHOD CreateNewContentWindow(int32_t aChromeFlags, nsIXULWindow **_retval);
 
    void       EnableParent(bool aEnable);
    bool       ConstrainToZLevel(bool aImmediate, nsWindowZ *aPlacement,