--- 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__