Eliminate NS_HIDDEN and NS_HIDDEN_ from layout/style/. Search-and-replace plus formatting fixes. rs=bzbarsky, no bug.
authorZack Weinberg <zweinberg@mozilla.com>
Tue, 06 Apr 2010 14:52:17 -0700
changeset 40517 6c32102f5594e1b4ff4b874c45615c67eb59baef
parent 40516 ed5afed89c4948ae4ee142be7851eef4a2860f74
child 40518 be88ae1fc67538477799c4ef347729aa2951f967
push idunknown
push userunknown
push dateunknown
reviewersbzbarsky, no
milestone1.9.3a4pre
Eliminate NS_HIDDEN and NS_HIDDEN_ from layout/style/. Search-and-replace plus formatting fixes. rs=bzbarsky, no bug.
layout/style/nsCSSParser.h
layout/style/nsCSSScanner.h
layout/style/nsCSSStyleSheet.h
layout/style/nsCSSValue.h
layout/style/nsICSSStyleSheet.h
layout/style/nsRuleNode.h
layout/style/nsStyleContext.h
layout/style/nsStyleSet.h
layout/style/nsTransitionManager.cpp
--- a/layout/style/nsCSSParser.h
+++ b/layout/style/nsCSSParser.h
@@ -60,48 +60,48 @@ namespace css {
   class Loader;
 }
 }
 
 // Interface to the css parser.
 
 class NS_STACK_CLASS nsCSSParser {
 public:
-  NS_HIDDEN nsCSSParser(mozilla::css::Loader* aLoader = nsnull,
-                        nsICSSStyleSheet* aSheet = nsnull);
-  NS_HIDDEN ~nsCSSParser();
+  nsCSSParser(mozilla::css::Loader* aLoader = nsnull,
+              nsICSSStyleSheet* aSheet = nsnull);
+  ~nsCSSParser();
 
   static void Shutdown();
 
 private:
   // not to be implemented
   nsCSSParser(nsCSSParser const&);
   nsCSSParser& operator=(nsCSSParser const&);
 
 public:
   // If this is false, memory allocation failed in the constructor
   // and all other methods will crash.
-  NS_HIDDEN operator bool() const
+  operator bool() const
   { return !!mImpl; }
 
   // Set a style sheet for the parser to fill in. The style sheet must
   // implement the nsICSSStyleSheet interface.  Null can be passed in to clear
   // out an existing stylesheet reference.
-  NS_HIDDEN_(nsresult) SetStyleSheet(nsICSSStyleSheet* aSheet);
+  nsresult SetStyleSheet(nsICSSStyleSheet* aSheet);
 
   // Set whether or not to emulate Nav quirks
-  NS_HIDDEN_(nsresult) SetQuirkMode(PRBool aQuirkMode);
+  nsresult SetQuirkMode(PRBool aQuirkMode);
 
 #ifdef  MOZ_SVG
   // Set whether or not we are in an SVG element
-  NS_HIDDEN_(nsresult) SetSVGMode(PRBool aSVGMode);
+  nsresult SetSVGMode(PRBool aSVGMode);
 #endif
 
   // Set loader to use for child sheets
-  NS_HIDDEN_(nsresult) SetChildLoader(mozilla::css::Loader* aChildLoader);
+  nsresult SetChildLoader(mozilla::css::Loader* aChildLoader);
 
   /**
    * Parse aInput into the stylesheet that was previously set by calling
    * SetStyleSheet.  Calling this method without calling SetStyleSheet first is
    * an error.
    *
    * @param aInput the data to parse
    * @param aSheetURL the URI to use as the sheet URI (for error reporting).
@@ -109,92 +109,92 @@ public:
    *                  SetStyleSheet.
    * @param aBaseURI the URI to use for relative URI resolution
    * @param aSheetPrincipal the principal of the stylesheet.  This must match
    *                        the principal of the sheet passed to SetStyleSheet.
    * @param aLineNumber the line number of the first line of the sheet.
    * @param aAllowUnsafeRules see aEnableUnsafeRules in
    *                          mozilla::css::Loader::LoadSheetSync
    */
-  NS_HIDDEN_(nsresult) Parse(nsIUnicharInputStream* aInput,
-                             nsIURI*                aSheetURL,
-                             nsIURI*                aBaseURI,
-                             nsIPrincipal*          aSheetPrincipal,
-                             PRUint32               aLineNumber,
-                             PRBool                 aAllowUnsafeRules);
+  nsresult Parse(nsIUnicharInputStream* aInput,
+                 nsIURI*                aSheetURL,
+                 nsIURI*                aBaseURI,
+                 nsIPrincipal*          aSheetPrincipal,
+                 PRUint32               aLineNumber,
+                 PRBool                 aAllowUnsafeRules);
 
   // Parse HTML style attribute or its equivalent in other markup
   // languages.  aBaseURL is the base url to use for relative links in
   // the declaration.
-  NS_HIDDEN_(nsresult) ParseStyleAttribute(const nsAString&  aAttributeValue,
-                                           nsIURI*           aDocURL,
-                                           nsIURI*           aBaseURL,
-                                           nsIPrincipal*     aNodePrincipal,
-                                           nsICSSStyleRule** aResult);
+  nsresult ParseStyleAttribute(const nsAString&  aAttributeValue,
+                               nsIURI*           aDocURL,
+                               nsIURI*           aBaseURL,
+                               nsIPrincipal*     aNodePrincipal,
+                               nsICSSStyleRule** aResult);
 
-  NS_HIDDEN_(nsresult) ParseAndAppendDeclaration(const nsAString& aBuffer,
-                                                 nsIURI* aSheetURL,
-                                                 nsIURI* aBaseURL,
-                                                 nsIPrincipal* aSheetPrincipal,
-                                                 nsCSSDeclaration* aDeclaration,
-                                                 PRBool  aParseOnlyOneDecl,
-                                                 PRBool* aChanged,
-                                                 PRBool  aClearOldDecl);
+  nsresult ParseAndAppendDeclaration(const nsAString&  aBuffer,
+                                     nsIURI*           aSheetURL,
+                                     nsIURI*           aBaseURL,
+                                     nsIPrincipal*     aSheetPrincipal,
+                                     nsCSSDeclaration* aDeclaration,
+                                     PRBool            aParseOnlyOneDecl,
+                                     PRBool*           aChanged,
+                                     PRBool            aClearOldDecl);
 
-  NS_HIDDEN_(nsresult) ParseRule(const nsAString&        aRule,
-                                 nsIURI*                 aSheetURL,
-                                 nsIURI*                 aBaseURL,
-                                 nsIPrincipal*           aSheetPrincipal,
-                                 nsCOMArray<nsICSSRule>& aResult);
+  nsresult ParseRule(const nsAString&        aRule,
+                     nsIURI*                 aSheetURL,
+                     nsIURI*                 aBaseURL,
+                     nsIPrincipal*           aSheetPrincipal,
+                     nsCOMArray<nsICSSRule>& aResult);
 
-  NS_HIDDEN_(nsresult) ParseProperty(const nsCSSProperty aPropID,
-                                     const nsAString&    aPropValue,
-                                     nsIURI*             aSheetURL,
-                                     nsIURI*             aBaseURL,
-                                     nsIPrincipal*       aSheetPrincipal,
-                                     nsCSSDeclaration*   aDeclaration,
-                                     PRBool*             aChanged,
-                                     PRBool              aIsImportant);
+  nsresult ParseProperty(const nsCSSProperty aPropID,
+                         const nsAString&    aPropValue,
+                         nsIURI*             aSheetURL,
+                         nsIURI*             aBaseURL,
+                         nsIPrincipal*       aSheetPrincipal,
+                         nsCSSDeclaration*   aDeclaration,
+                         PRBool*             aChanged,
+                         PRBool              aIsImportant);
 
   /**
    * Parse aBuffer into a media list |aMediaList|, which must be
    * non-null, replacing its current contents.  If aHTMLMode is true,
    * parse according to HTML rules, with commas as the most important
    * delimiter.  Otherwise, parse according to CSS rules, with
    * parentheses and strings more important than commas.  |aURL| and
    * |aLineNumber| are used for error reporting.
    */
-  NS_HIDDEN_(nsresult) ParseMediaList(const nsSubstring& aBuffer,
-                                      nsIURI*            aURL,
-                                      PRUint32           aLineNumber,
-                                      nsMediaList*       aMediaList,
-                                      PRBool             aHTMLMode);
+  nsresult ParseMediaList(const nsSubstring& aBuffer,
+                          nsIURI*            aURL,
+                          PRUint32           aLineNumber,
+                          nsMediaList*       aMediaList,
+                          PRBool             aHTMLMode);
 
   /**
    * Parse aBuffer into a nscolor |aColor|.  The alpha component of the
    * resulting aColor may vary due to rgba()/hsla().  Will return
    * NS_ERROR_FAILURE if aBuffer is not a valid CSS color specification.
    *
    * Will also currently return NS_ERROR_FAILURE if it is not
    * self-contained (i.e.  doesn't reference any external style state,
    * such as "initial" or "inherit").
    */
-  NS_HIDDEN_(nsresult) ParseColorString(const nsSubstring& aBuffer,
-                                        nsIURI*            aURL,
-                                        PRUint32           aLineNumber,
-                                        nscolor*           aColor);
+  nsresult ParseColorString(const nsSubstring& aBuffer,
+                            nsIURI*            aURL,
+                            PRUint32           aLineNumber,
+                            nscolor*           aColor);
 
   /**
    * Parse aBuffer into a selector list.  On success, caller must
    * delete *aSelectorList when done with it.
    */
-  NS_HIDDEN_(nsresult) ParseSelectorString(const nsSubstring&  aSelectorString,
-                                           nsIURI*             aURL,
-                                           PRUint32            aLineNumber,
-                                           nsCSSSelectorList** aSelectorList);
+  nsresult ParseSelectorString(const nsSubstring&  aSelectorString,
+                               nsIURI*             aURL,
+                               PRUint32            aLineNumber,
+                               nsCSSSelectorList** aSelectorList);
 
 protected:
   // This is a CSSParserImpl*, but if we expose that type name in this
   // header, we can't put the type definition (in nsCSSParser.cpp) in
   // the anonymous namespace.
   void* mImpl;
 };
 
--- a/layout/style/nsCSSScanner.h
+++ b/layout/style/nsCSSScanner.h
@@ -156,38 +156,37 @@ class nsCSSScanner {
     mSVGMode = aSVGMode;
   }
   PRBool IsSVGMode() const {
     return mSVGMode;
   }
 
 #endif
 #ifdef CSS_REPORT_PARSE_ERRORS
-  NS_HIDDEN_(void) AddToError(const nsSubstring& aErrorText);
-  NS_HIDDEN_(void) OutputError();
-  NS_HIDDEN_(void) ClearError();
+  void AddToError(const nsSubstring& aErrorText);
+  void OutputError();
+  void ClearError();
 
   // aMessage must take no parameters
-  NS_HIDDEN_(void) ReportUnexpected(const char* aMessage);
-  NS_HIDDEN_(void) ReportUnexpectedParams(const char* aMessage,
-                                          const PRUnichar **aParams,
-                                          PRUint32 aParamsLength);
+  void ReportUnexpected(const char* aMessage);
+  void ReportUnexpectedParams(const char* aMessage,
+                              const PRUnichar **aParams,
+                              PRUint32 aParamsLength);
   // aLookingFor is a plain string, not a format string
-  NS_HIDDEN_(void) ReportUnexpectedEOF(const char* aLookingFor);
+  void ReportUnexpectedEOF(const char* aLookingFor);
   // aLookingFor is a single character
-  NS_HIDDEN_(void) ReportUnexpectedEOF(PRUnichar aLookingFor);
+  void ReportUnexpectedEOF(PRUnichar aLookingFor);
   // aMessage must take 1 parameter (for the string representation of the
   // unexpected token)
-  NS_HIDDEN_(void) ReportUnexpectedToken(nsCSSToken& tok,
-                                         const char *aMessage);
+  void ReportUnexpectedToken(nsCSSToken& tok, const char *aMessage);
   // aParams's first entry must be null, and we'll fill in the token
-  NS_HIDDEN_(void) ReportUnexpectedTokenParams(nsCSSToken& tok,
-                                               const char* aMessage,
-                                               const PRUnichar **aParams,
-                                               PRUint32 aParamsLength);
+  void ReportUnexpectedTokenParams(nsCSSToken& tok,
+                                   const char* aMessage,
+                                   const PRUnichar **aParams,
+                                   PRUint32 aParamsLength);
 #endif
 
   PRUint32 GetLineNumber() { return mLineNumber; }
 
   // Get the next token. Return PR_FALSE on EOF. aTokenResult
   // is filled in with the data for the token.
   PRBool Next(nsCSSToken& aTokenResult);
 
--- a/layout/style/nsCSSStyleSheet.h
+++ b/layout/style/nsCSSStyleSheet.h
@@ -146,24 +146,24 @@ public:
   NS_IMETHOD GetStyleRuleAt(PRInt32 aIndex, nsICSSRule*& aRule) const;
   NS_IMETHOD DeleteRuleFromGroup(nsICSSGroupRule* aGroup, PRUint32 aIndex);
   NS_IMETHOD InsertRuleIntoGroup(const nsAString& aRule, nsICSSGroupRule* aGroup, PRUint32 aIndex, PRUint32* _retval);
   NS_IMETHOD ReplaceRuleInGroup(nsICSSGroupRule* aGroup, nsICSSRule* aOld, nsICSSRule* aNew);
   NS_IMETHOD StyleSheetCount(PRInt32& aCount) const;
   NS_IMETHOD GetStyleSheetAt(PRInt32 aIndex, nsICSSStyleSheet*& aSheet) const;
   NS_IMETHOD SetURIs(nsIURI* aSheetURI, nsIURI* aOriginalSheetURI,
                      nsIURI* aBaseURI);
-  virtual NS_HIDDEN_(void) SetPrincipal(nsIPrincipal* aPrincipal);
-  virtual NS_HIDDEN_(nsIPrincipal*) Principal() const;
+  virtual void SetPrincipal(nsIPrincipal* aPrincipal);
+  virtual nsIPrincipal* Principal() const;
   NS_IMETHOD SetTitle(const nsAString& aTitle);
   NS_IMETHOD SetMedia(nsMediaList* aMedia);
   NS_IMETHOD SetOwningNode(nsIDOMNode* aOwningNode);
   NS_IMETHOD SetOwnerRule(nsICSSImportRule* aOwnerRule);
   NS_IMETHOD GetOwnerRule(nsICSSImportRule** aOwnerRule);
-  virtual NS_HIDDEN_(nsXMLNameSpaceMap*) GetNameSpaceMap() const;
+  virtual nsXMLNameSpaceMap* GetNameSpaceMap() const;
   NS_IMETHOD Clone(nsICSSStyleSheet* aCloneParent,
                    nsICSSImportRule* aCloneOwnerRule,
                    nsIDocument* aCloneDocument,
                    nsIDOMNode* aCloneOwningNode,
                    nsICSSStyleSheet** aClone) const;
   NS_IMETHOD IsModified(PRBool* aSheetModified) const;
   NS_IMETHOD SetModified(PRBool aModified);
   NS_IMETHOD AddRuleProcessor(nsCSSRuleProcessor* aProcessor);
--- a/layout/style/nsCSSValue.h
+++ b/layout/style/nsCSSValue.h
@@ -176,28 +176,28 @@ public:
   
   // for valueless units only (null, auto, inherit, none, all, normal)
   explicit nsCSSValue(nsCSSUnit aUnit = eCSSUnit_Null)
     : mUnit(aUnit)
   {
     NS_ASSERTION(aUnit <= eCSSUnit_RectIsAuto, "not a valueless unit");
   }
 
-  nsCSSValue(PRInt32 aValue, nsCSSUnit aUnit) NS_HIDDEN;
-  nsCSSValue(float aValue, nsCSSUnit aUnit) NS_HIDDEN;
-  nsCSSValue(const nsString& aValue, nsCSSUnit aUnit) NS_HIDDEN;
-  nsCSSValue(Array* aArray, nsCSSUnit aUnit) NS_HIDDEN;
-  explicit nsCSSValue(URL* aValue) NS_HIDDEN;
-  explicit nsCSSValue(Image* aValue) NS_HIDDEN;
-  explicit nsCSSValue(nsCSSValueGradient* aValue) NS_HIDDEN;
-  nsCSSValue(const nsCSSValue& aCopy) NS_HIDDEN;
+  nsCSSValue(PRInt32 aValue, nsCSSUnit aUnit);
+  nsCSSValue(float aValue, nsCSSUnit aUnit);
+  nsCSSValue(const nsString& aValue, nsCSSUnit aUnit);
+  nsCSSValue(Array* aArray, nsCSSUnit aUnit);
+  explicit nsCSSValue(URL* aValue);
+  explicit nsCSSValue(Image* aValue);
+  explicit nsCSSValue(nsCSSValueGradient* aValue);
+  nsCSSValue(const nsCSSValue& aCopy);
   ~nsCSSValue() { Reset(); }
 
-  NS_HIDDEN_(nsCSSValue&)  operator=(const nsCSSValue& aCopy);
-  NS_HIDDEN_(PRBool)      operator==(const nsCSSValue& aOther) const;
+  nsCSSValue&  operator=(const nsCSSValue& aCopy);
+  PRBool      operator==(const nsCSSValue& aOther) const;
 
   PRBool operator!=(const nsCSSValue& aOther) const
   {
     return !(*this == aOther);
   }
 
   nsCSSUnit GetUnit() const { return mUnit; }
   PRBool    IsLengthUnit() const
@@ -305,78 +305,77 @@ public:
     return GetBufferValue(mUnit == eCSSUnit_URL ?
                             mValue.mURL->mString :
                             mValue.mImage->mString);
   }
 
   // Not making this inline because that would force us to include
   // imgIRequest.h, which leads to REQUIRES hell, since this header is included
   // all over.
-  NS_HIDDEN_(imgIRequest*) GetImageValue() const;
+  imgIRequest* GetImageValue() const;
 
-  NS_HIDDEN_(nscoord)   GetLengthTwips() const;
+  nscoord GetLengthTwips() const;
 
-  NS_HIDDEN_(void)  Reset()  // sets to null
+  void Reset()  // sets to null
   {
     if (mUnit != eCSSUnit_Null)
       DoReset();
   }
 private:
-  NS_HIDDEN_(void)  DoReset();
+  void DoReset();
 
 public:
-  NS_HIDDEN_(void)  SetIntValue(PRInt32 aValue, nsCSSUnit aUnit);
-  NS_HIDDEN_(void)  SetPercentValue(float aValue);
-  NS_HIDDEN_(void)  SetFloatValue(float aValue, nsCSSUnit aUnit);
-  NS_HIDDEN_(void)  SetStringValue(const nsString& aValue, nsCSSUnit aUnit);
-  NS_HIDDEN_(void)  SetColorValue(nscolor aValue);
-  NS_HIDDEN_(void)  SetArrayValue(nsCSSValue::Array* aArray, nsCSSUnit aUnit);
-  NS_HIDDEN_(void)  SetURLValue(nsCSSValue::URL* aURI);
-  NS_HIDDEN_(void)  SetImageValue(nsCSSValue::Image* aImage);
-  NS_HIDDEN_(void)  SetGradientValue(nsCSSValueGradient* aGradient);
-  NS_HIDDEN_(void)  SetAutoValue();
-  NS_HIDDEN_(void)  SetInheritValue();
-  NS_HIDDEN_(void)  SetInitialValue();
-  NS_HIDDEN_(void)  SetNoneValue();
-  NS_HIDDEN_(void)  SetAllValue();
-  NS_HIDDEN_(void)  SetNormalValue();
-  NS_HIDDEN_(void)  SetSystemFontValue();
-  NS_HIDDEN_(void)  SetDummyValue();
-  NS_HIDDEN_(void)  SetDummyInheritValue();
-  NS_HIDDEN_(void)  StartImageLoad(nsIDocument* aDocument)
-                                   const;  // Not really const, but pretending
+  void SetIntValue(PRInt32 aValue, nsCSSUnit aUnit);
+  void SetPercentValue(float aValue);
+  void SetFloatValue(float aValue, nsCSSUnit aUnit);
+  void SetStringValue(const nsString& aValue, nsCSSUnit aUnit);
+  void SetColorValue(nscolor aValue);
+  void SetArrayValue(nsCSSValue::Array* aArray, nsCSSUnit aUnit);
+  void SetURLValue(nsCSSValue::URL* aURI);
+  void SetImageValue(nsCSSValue::Image* aImage);
+  void SetGradientValue(nsCSSValueGradient* aGradient);
+  void SetAutoValue();
+  void SetInheritValue();
+  void SetInitialValue();
+  void SetNoneValue();
+  void SetAllValue();
+  void SetNormalValue();
+  void SetSystemFontValue();
+  void SetDummyValue();
+  void SetDummyInheritValue();
+  void StartImageLoad(nsIDocument* aDocument) const;  // Only pretend const
 
   // Initializes as a function value with the specified function id.
-  NS_HIDDEN_(Array*) InitFunction(nsCSSKeyword aFunctionId, PRUint32 aNumArgs);
+  Array* InitFunction(nsCSSKeyword aFunctionId, PRUint32 aNumArgs);
   // Checks if this is a function value with the specified function id.
-  NS_HIDDEN_(PRBool) EqualsFunction(nsCSSKeyword aFunctionId) const;
+  PRBool EqualsFunction(nsCSSKeyword aFunctionId) const;
 
   // Returns an already addrefed buffer.  Can return null on allocation
   // failure.
   static nsStringBuffer* BufferFromString(const nsString& aValue);
   
   struct URL {
     // Methods are not inline because using an nsIPrincipal means requiring
     // caps, which leads to REQUIRES hell, since this header is included all
     // over.    
 
     // aString must not be null.
     // aOriginPrincipal must not be null.
     URL(nsIURI* aURI, nsStringBuffer* aString, nsIURI* aReferrer,
-        nsIPrincipal* aOriginPrincipal) NS_HIDDEN;
+        nsIPrincipal* aOriginPrincipal);
 
-    ~URL() NS_HIDDEN;
+    ~URL();
 
-    NS_HIDDEN_(PRBool) operator==(const URL& aOther) const;
+    PRBool operator==(const URL& aOther) const;
 
     // URIEquals only compares URIs and principals (unlike operator==, which
     // also compares the original strings).  URIEquals also assumes that the
     // mURI member of both URL objects is non-null.  Do NOT call this method
     // unless you're sure this is the case.
-    NS_HIDDEN_(PRBool) URIEquals(const URL& aOther) const;
+    PRBool URIEquals(const URL& aOther) const;
 
     nsCOMPtr<nsIURI> mURI; // null == invalid URL
     nsStringBuffer* mString; // Could use nsRefPtr, but it'd add useless
                              // null-checks; this is never null.
     nsCOMPtr<nsIURI> mReferrer;
     nsCOMPtr<nsIPrincipal> mOriginPrincipal;
 
     NS_INLINE_DECL_REFCOUNTING(nsCSSValue::URL)
@@ -389,18 +388,18 @@ public:
   };
 
   struct Image : public URL {
     // Not making the constructor and destructor inline because that would
     // force us to include imgIRequest.h, which leads to REQUIRES hell, since
     // this header is included all over.
     // aString must not be null.
     Image(nsIURI* aURI, nsStringBuffer* aString, nsIURI* aReferrer,
-          nsIPrincipal* aOriginPrincipal, nsIDocument* aDocument) NS_HIDDEN;
-    ~Image() NS_HIDDEN;
+          nsIPrincipal* aOriginPrincipal, nsIDocument* aDocument);
+    ~Image();
 
     // Inherit operator== from nsCSSValue::URL
 
     nsCOMPtr<imgIRequest> mRequest; // null == image load blocked or somehow failed
 
     // Override AddRef and Release to not only log ourselves correctly, but
     // also so that we delete correctly without a virtual destructor
     NS_INLINE_DECL_REFCOUNTING(nsCSSValue::Image)
@@ -424,20 +423,20 @@ protected:
     URL*       mURL;
     Image*     mImage;
     nsCSSValueGradient* mGradient;
   }         mValue;
 };
 
 struct nsCSSValueGradientStop {
 public:
-  nsCSSValueGradientStop() NS_HIDDEN;
+  nsCSSValueGradientStop();
   // needed to keep bloat logs happy when we use the nsTArray in nsCSSValueGradient
-  nsCSSValueGradientStop(const nsCSSValueGradientStop& aOther) NS_HIDDEN;
-  ~nsCSSValueGradientStop() NS_HIDDEN;
+  nsCSSValueGradientStop(const nsCSSValueGradientStop& aOther);
+  ~nsCSSValueGradientStop();
 
   nsCSSValue mLocation;
   nsCSSValue mColor;
 
   PRBool operator==(const nsCSSValueGradientStop& aOther) const
   {
     return (mLocation == aOther.mLocation &&
             mColor == aOther.mColor);
@@ -445,18 +444,17 @@ public:
 
   PRBool operator!=(const nsCSSValueGradientStop& aOther) const
   {
     return !(*this == aOther);
   }
 };
 
 struct nsCSSValueGradient {
-  nsCSSValueGradient(PRBool aIsRadial,
-                     PRBool aIsRepeating) NS_HIDDEN;
+  nsCSSValueGradient(PRBool aIsRadial, PRBool aIsRepeating);
 
   // true if gradient is radial, false if it is linear
   PRPackedBool mIsRadial;
   PRPackedBool mIsRepeating;
   // line position and angle
   nsCSSValue mBgPosX;
   nsCSSValue mBgPosY;
   nsCSSValue mAngle;
--- a/layout/style/nsICSSStyleSheet.h
+++ b/layout/style/nsICSSStyleSheet.h
@@ -88,30 +88,30 @@ public:
   NS_IMETHOD  SetURIs(nsIURI* aSheetURI, nsIURI* aOriginalSheetURI,
                       nsIURI* aBaseURI) = 0;
 
   /**
    * SetPrincipal should be called on all sheets before parsing into them.
    * This can only be called once with a non-null principal.  Calling this with
    * a null pointer is allowed and is treated as a no-op.
    */
-  virtual NS_HIDDEN_(void) SetPrincipal(nsIPrincipal* aPrincipal) = 0;
+  virtual void SetPrincipal(nsIPrincipal* aPrincipal) = 0;
 
   // Principal() never returns a null pointer.
-  virtual NS_HIDDEN_(nsIPrincipal*) Principal() const = 0;
+  virtual nsIPrincipal* Principal() const = 0;
   
   NS_IMETHOD  SetTitle(const nsAString& aTitle) = 0;
   NS_IMETHOD  SetMedia(nsMediaList* aMedia) = 0;
   NS_IMETHOD  SetOwningNode(nsIDOMNode* aOwningNode) = 0;
 
   NS_IMETHOD  SetOwnerRule(nsICSSImportRule* aOwnerRule) = 0;
   NS_IMETHOD  GetOwnerRule(nsICSSImportRule** aOwnerRule) = 0;
   
   // get namespace map for sheet
-  virtual NS_HIDDEN_(nsXMLNameSpaceMap*) GetNameSpaceMap() const = 0;
+  virtual nsXMLNameSpaceMap* GetNameSpaceMap() const = 0;
 
   NS_IMETHOD  Clone(nsICSSStyleSheet* aCloneParent,
                     nsICSSImportRule* aCloneOwnerRule,
                     nsIDocument* aCloneDocument,
                     nsIDOMNode* aCloneOwningNode,
                     nsICSSStyleSheet** aClone) const = 0;
 
   NS_IMETHOD  IsModified(PRBool* aModified) const = 0; // returns the mDirty status of the sheet
--- a/layout/style/nsRuleNode.h
+++ b/layout/style/nsRuleNode.h
@@ -167,17 +167,17 @@ struct nsCachedStyleData
   static PRBool IsReset(const nsStyleStructID& aSID) {
     return gInfo[aSID].mIsReset;
   }
 
   static PRUint32 GetBitForSID(const nsStyleStructID& aSID) {
     return 1 << aSID;
   }
 
-  NS_HIDDEN_(void*) NS_FASTCALL GetStyleData(const nsStyleStructID& aSID) {
+  void* NS_FASTCALL GetStyleData(const nsStyleStructID& aSID) {
     // Each struct is stored at this.m##type##Data->m##name##Data where
     // |type| is either Inherit or Reset, and |name| is the name of the
     // style struct.  The |gInfo| stores the offset of the appropriate
     // m##type##Data for the struct within nsCachedStyleData (|this|)
     // and the offset of the appropriate m##name##Data within the
     // m##type##Data.  Note that if we don't have any reset structs,
     // then mResetData is null, and likewise for mInheritedData.  This
     // saves us from having to go through the long if-else cascade into
@@ -200,28 +200,28 @@ struct nsCachedStyleData
       char* dataSlot = resetOrInherit + info.mInheritResetOffset;
       data = *reinterpret_cast<void**>(dataSlot);
     }
     return data;
   }
 
   // Typesafe and faster versions of the above
   #define STYLE_STRUCT_INHERITED(name_, checkdata_cb_, ctor_args_)       \
-    NS_HIDDEN_(nsStyle##name_ *) NS_FASTCALL GetStyle##name_ () {        \
+    nsStyle##name_ * NS_FASTCALL GetStyle##name_ () {        \
       return mInheritedData ? mInheritedData->m##name_##Data : nsnull;   \
     }
   #define STYLE_STRUCT_RESET(name_, checkdata_cb_, ctor_args_)           \
-    NS_HIDDEN_(nsStyle##name_ *) NS_FASTCALL GetStyle##name_ () {        \
+    nsStyle##name_ * NS_FASTCALL GetStyle##name_ () {        \
       return mResetData ? mResetData->m##name_##Data : nsnull;           \
     }
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT_RESET
   #undef STYLE_STRUCT_INHERITED
 
-  NS_HIDDEN_(void) Destroy(PRUint32 aBits, nsPresContext* aContext) {
+  void Destroy(PRUint32 aBits, nsPresContext* aContext) {
     if (mResetData)
       mResetData->Destroy(aBits, aContext);
     if (mInheritedData)
       mInheritedData->Destroy(aBits, aContext);
     mResetData = nsnull;
     mInheritedData = nsnull;
   }
 
@@ -426,291 +426,289 @@ private:
   // Reference count.  This just counts the style contexts that
   // reference this rulenode.  When this goes to 0 or stops being 0,
   // we notify the style set.
   PRUint32 mRefCnt;
 
 public:
   // Overloaded new operator. Initializes the memory to 0 and relies on an arena
   // (which comes from the presShell) to perform the allocation.
-  NS_HIDDEN_(void*) operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW;
-  NS_HIDDEN_(void) Destroy() { DestroyInternal(nsnull); }
-  static NS_HIDDEN_(nsILanguageAtomService*) gLangService;
+  void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW;
+  void Destroy() { DestroyInternal(nsnull); }
+  static nsILanguageAtomService* gLangService;
 
   // Implemented in nsStyleSet.h, since it needs to know about nsStyleSet.
-  inline NS_HIDDEN_(void) AddRef();
+  inline void AddRef();
 
   // Implemented in nsStyleSet.h, since it needs to know about nsStyleSet.
-  inline NS_HIDDEN_(void) Release();
+  inline void Release();
 
 protected:
-  NS_HIDDEN_(void) DestroyInternal(nsRuleNode ***aDestroyQueueTail);
-  NS_HIDDEN_(void) PropagateDependentBit(PRUint32 aBit,
-                                         nsRuleNode* aHighestNode);
-  NS_HIDDEN_(void) PropagateNoneBit(PRUint32 aBit, nsRuleNode* aHighestNode);
+  void DestroyInternal(nsRuleNode ***aDestroyQueueTail);
+  void PropagateDependentBit(PRUint32 aBit, nsRuleNode* aHighestNode);
+  void PropagateNoneBit(PRUint32 aBit, nsRuleNode* aHighestNode);
   
-  NS_HIDDEN_(const void*) SetDefaultOnRoot(const nsStyleStructID aSID,
-                                                 nsStyleContext* aContext);
+  const void* SetDefaultOnRoot(const nsStyleStructID aSID,
+                               nsStyleContext* aContext);
 
-  NS_HIDDEN_(const void*)
+  const void*
     WalkRuleTree(const nsStyleStructID aSID, nsStyleContext* aContext, 
                  nsRuleData* aRuleData, nsRuleDataStruct* aSpecificData);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeDisplayData(void* aStartStruct,
                        const nsRuleDataStruct& aData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail,
                        const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeVisibilityData(void* aStartStruct,
                           const nsRuleDataStruct& aData,
                           nsStyleContext* aContext, nsRuleNode* aHighestNode,
                           RuleDetail aRuleDetail,
                           const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeFontData(void* aStartStruct,
                     const nsRuleDataStruct& aData,
                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
                     RuleDetail aRuleDetail,
                     const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeColorData(void* aStartStruct,
                      const nsRuleDataStruct& aData,
                      nsStyleContext* aContext, nsRuleNode* aHighestNode,
                      RuleDetail aRuleDetail,
                      const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeBackgroundData(void* aStartStruct,
                           const nsRuleDataStruct& aData, 
                           nsStyleContext* aContext, nsRuleNode* aHighestNode,
                           RuleDetail aRuleDetail,
                           const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeMarginData(void* aStartStruct,
                       const nsRuleDataStruct& aData, 
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail,
                       const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeBorderData(void* aStartStruct,
                       const nsRuleDataStruct& aData, 
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail,
                       const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputePaddingData(void* aStartStruct,
                        const nsRuleDataStruct& aData, 
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail,
                        const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeOutlineData(void* aStartStruct,
                        const nsRuleDataStruct& aData, 
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail,
                        const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeListData(void* aStartStruct,
                     const nsRuleDataStruct& aData,
                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
                     RuleDetail aRuleDetail,
                     const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputePositionData(void* aStartStruct,
                         const nsRuleDataStruct& aData, 
                         nsStyleContext* aContext, nsRuleNode* aHighestNode,
                         RuleDetail aRuleDetail,
                         const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeTableData(void* aStartStruct,
                      const nsRuleDataStruct& aData, 
                      nsStyleContext* aContext, nsRuleNode* aHighestNode,
                      RuleDetail aRuleDetail,
                      const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeTableBorderData(void* aStartStruct,
                            const nsRuleDataStruct& aData, 
                            nsStyleContext* aContext, nsRuleNode* aHighestNode,
                            RuleDetail aRuleDetail,
                            const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeContentData(void* aStartStruct,
                        const nsRuleDataStruct& aData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail,
                        const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeQuotesData(void* aStartStruct,
                       const nsRuleDataStruct& aData, 
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail,
                       const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeTextData(void* aStartStruct,
                     const nsRuleDataStruct& aData, 
                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
                     RuleDetail aRuleDetail,
                     const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeTextResetData(void* aStartStruct,
                          const nsRuleDataStruct& aData,
                          nsStyleContext* aContext, nsRuleNode* aHighestNode,
                          RuleDetail aRuleDetail,
                          const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeUserInterfaceData(void* aStartStruct,
                              const nsRuleDataStruct& aData, 
                              nsStyleContext* aContext,
                              nsRuleNode* aHighestNode,
                              RuleDetail aRuleDetail,
                              const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeUIResetData(void* aStartStruct,
                        const nsRuleDataStruct& aData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail,
                        const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeXULData(void* aStartStruct,
                    const nsRuleDataStruct& aData, 
                    nsStyleContext* aContext, nsRuleNode* aHighestNode,
                    RuleDetail aRuleDetail,
                    const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeColumnData(void* aStartStruct,
                       const nsRuleDataStruct& aData,
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail,
                       const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeSVGData(void* aStartStruct,
                    const nsRuleDataStruct& aData, 
                    nsStyleContext* aContext, nsRuleNode* aHighestNode,
                    RuleDetail aRuleDetail,
                    const PRBool aCanStoreInRuleTree);
 
-  NS_HIDDEN_(const void*)
+  const void*
     ComputeSVGResetData(void* aStartStruct,
                         const nsRuleDataStruct& aData, 
                         nsStyleContext* aContext, nsRuleNode* aHighestNode,
                         RuleDetail aRuleDetail,
                         const PRBool aCanStoreInRuleTree);
 
   // helpers for |ComputeFontData| that need access to |mNoneBits|:
-  static NS_HIDDEN_(void) SetFontSize(nsPresContext* aPresContext,
-                                      const nsRuleDataFont& aFontData,
-                                      const nsStyleFont* aFont,
-                                      const nsStyleFont* aParentFont,
-                                      nscoord* aSize,
-                                      const nsFont& aSystemFont,
-                                      nscoord aParentSize,
-                                      nscoord aScriptLevelAdjustedParentSize,
-                                      PRBool aUsedStartStruct,
-                                      PRBool aAtRoot,
-                                      PRBool& aCanStoreInRuleTree);
+  static void SetFontSize(nsPresContext* aPresContext,
+                          const nsRuleDataFont& aFontData,
+                          const nsStyleFont* aFont,
+                          const nsStyleFont* aParentFont,
+                          nscoord* aSize,
+                          const nsFont& aSystemFont,
+                          nscoord aParentSize,
+                          nscoord aScriptLevelAdjustedParentSize,
+                          PRBool aUsedStartStruct,
+                          PRBool aAtRoot,
+                          PRBool& aCanStoreInRuleTree);
 
-  static NS_HIDDEN_(void) SetFont(nsPresContext* aPresContext,
-                                  nsStyleContext* aContext,
-                                  nscoord aMinFontSize,
-                                  PRUint8 aGenericFontID,
-                                  const nsRuleDataFont& aFontData,
-                                  const nsStyleFont* aParentFont,
-                                  nsStyleFont* aFont,
-                                  PRBool aStartStruct,
-                                  PRBool& aCanStoreInRuleTree);
+  static void SetFont(nsPresContext* aPresContext,
+                      nsStyleContext* aContext,
+                      nscoord aMinFontSize,
+                      PRUint8 aGenericFontID,
+                      const nsRuleDataFont& aFontData,
+                      const nsStyleFont* aParentFont,
+                      nsStyleFont* aFont,
+                      PRBool aStartStruct,
+                      PRBool& aCanStoreInRuleTree);
 
-  static NS_HIDDEN_(void) SetGenericFont(nsPresContext* aPresContext,
-                                         nsStyleContext* aContext,
-                                         PRUint8 aGenericFontID,
-                                         nscoord aMinFontSize,
-                                         nsStyleFont* aFont);
+  static void SetGenericFont(nsPresContext* aPresContext,
+                             nsStyleContext* aContext,
+                             PRUint8 aGenericFontID,
+                             nscoord aMinFontSize,
+                             nsStyleFont* aFont);
 
-  NS_HIDDEN_(void) AdjustLogicalBoxProp(nsStyleContext* aContext,
-                                        const nsCSSValue& aLTRSource,
-                                        const nsCSSValue& aRTLSource,
-                                        const nsCSSValue& aLTRLogicalValue,
-                                        const nsCSSValue& aRTLLogicalValue,
-                                        PRUint8 aSide,
-                                        nsCSSRect& aValueRect,
-                                        PRBool& aCanStoreInRuleTree);
+  void AdjustLogicalBoxProp(nsStyleContext* aContext,
+                            const nsCSSValue& aLTRSource,
+                            const nsCSSValue& aRTLSource,
+                            const nsCSSValue& aLTRLogicalValue,
+                            const nsCSSValue& aRTLLogicalValue,
+                            PRUint8 aSide,
+                            nsCSSRect& aValueRect,
+                            PRBool& aCanStoreInRuleTree);
 
   inline RuleDetail CheckSpecifiedProperties(const nsStyleStructID aSID, const nsRuleDataStruct& aRuleDataStruct);
 
-  NS_HIDDEN_(const void*) GetParentData(const nsStyleStructID aSID);
+  const void* GetParentData(const nsStyleStructID aSID);
   #define STYLE_STRUCT(name_, checkdata_cb_, ctor_args_)  \
-    NS_HIDDEN_(const nsStyle##name_*) GetParent##name_();
+    const nsStyle##name_* GetParent##name_();
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT  
 
-  NS_HIDDEN_(const void*) GetDisplayData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetVisibilityData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetFontData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetColorData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetBackgroundData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetMarginData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetBorderData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetPaddingData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetOutlineData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetListData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetPositionData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetTableData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetTableBorderData(nsStyleContext* aContext);
+  const void* GetDisplayData(nsStyleContext* aContext);
+  const void* GetVisibilityData(nsStyleContext* aContext);
+  const void* GetFontData(nsStyleContext* aContext);
+  const void* GetColorData(nsStyleContext* aContext);
+  const void* GetBackgroundData(nsStyleContext* aContext);
+  const void* GetMarginData(nsStyleContext* aContext);
+  const void* GetBorderData(nsStyleContext* aContext);
+  const void* GetPaddingData(nsStyleContext* aContext);
+  const void* GetOutlineData(nsStyleContext* aContext);
+  const void* GetListData(nsStyleContext* aContext);
+  const void* GetPositionData(nsStyleContext* aContext);
+  const void* GetTableData(nsStyleContext* aContext);
+  const void* GetTableBorderData(nsStyleContext* aContext);
 
-  NS_HIDDEN_(const void*) GetContentData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetQuotesData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetTextData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetTextResetData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetUserInterfaceData(nsStyleContext* aContext);
+  const void* GetContentData(nsStyleContext* aContext);
+  const void* GetQuotesData(nsStyleContext* aContext);
+  const void* GetTextData(nsStyleContext* aContext);
+  const void* GetTextResetData(nsStyleContext* aContext);
+  const void* GetUserInterfaceData(nsStyleContext* aContext);
 
-  NS_HIDDEN_(const void*) GetUIResetData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetXULData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetColumnData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetSVGData(nsStyleContext* aContext);
-  NS_HIDDEN_(const void*) GetSVGResetData(nsStyleContext* aContext);
+  const void* GetUIResetData(nsStyleContext* aContext);
+  const void* GetXULData(nsStyleContext* aContext);
+  const void* GetColumnData(nsStyleContext* aContext);
+  const void* GetSVGData(nsStyleContext* aContext);
+  const void* GetSVGResetData(nsStyleContext* aContext);
 
-  NS_HIDDEN_(already_AddRefed<nsCSSShadowArray>)
-                          GetShadowData(nsCSSValueList* aList,
-                                        nsStyleContext* aContext,
-                                        PRBool aIsBoxShadow,
-                                        PRBool& inherited);
+  already_AddRefed<nsCSSShadowArray>
+              GetShadowData(nsCSSValueList* aList,
+                            nsStyleContext* aContext,
+                            PRBool aIsBoxShadow,
+                            PRBool& inherited);
 
 private:
   nsRuleNode(nsPresContext* aPresContext, nsRuleNode* aParent,
-             nsIStyleRule* aRule, PRUint8 aLevel, PRBool aIsImportant)
-    NS_HIDDEN;
-  ~nsRuleNode() NS_HIDDEN;
+             nsIStyleRule* aRule, PRUint8 aLevel, PRBool aIsImportant);
+  ~nsRuleNode();
 
 public:
-  static NS_HIDDEN_(nsRuleNode*) CreateRootNode(nsPresContext* aPresContext);
+  static nsRuleNode* CreateRootNode(nsPresContext* aPresContext);
 
   // Transition never returns null; on out of memory it'll just return |this|.
-  NS_HIDDEN_(nsRuleNode*) Transition(nsIStyleRule* aRule, PRUint8 aLevel,
-                                     PRPackedBool aIsImportantRule);
+  nsRuleNode* Transition(nsIStyleRule* aRule, PRUint8 aLevel,
+                         PRPackedBool aIsImportantRule);
   nsRuleNode* GetParent() const { return mParent; }
   PRBool IsRoot() const { return mParent == nsnull; }
 
   // These PRUint8s are really nsStyleSet::sheetType values.
   PRUint8 GetLevel() const { 
     NS_ASSERTION(!IsRoot(), "can't call on root");
     return (mDependentBits & NS_RULE_NODE_LEVEL_MASK) >>
              NS_RULE_NODE_LEVEL_SHIFT;
@@ -720,35 +718,34 @@ public:
     return (mDependentBits & NS_RULE_NODE_IS_IMPORTANT) != 0;
   }
 
   // NOTE:  Does not |AddRef|.
   nsIStyleRule* GetRule() const { return mRule; }
   // NOTE: Does not |AddRef|.
   nsPresContext* GetPresContext() const { return mPresContext; }
 
-  NS_HIDDEN_(const void*) GetStyleData(nsStyleStructID aSID, 
-                                       nsStyleContext* aContext,
-                                       PRBool aComputeData);
+  const void* GetStyleData(nsStyleStructID aSID, 
+                           nsStyleContext* aContext,
+                           PRBool aComputeData);
 
   #define STYLE_STRUCT(name_, checkdata_cb_, ctor_args_)                      \
-    NS_HIDDEN_(const nsStyle##name_*)                                         \
-      GetStyle##name_(nsStyleContext* aContext,                               \
-                      PRBool aComputeData);
+    const nsStyle##name_* GetStyle##name_(nsStyleContext* aContext,           \
+                                          PRBool aComputeData);
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT  
 
   /*
    * Garbage collection.  Mark walks up the tree, marking any unmarked
    * ancestors until it reaches a marked one.  Sweep recursively sweeps
    * the children, destroys any that are unmarked, and clears marks,
    * returning true if the node on which it was called was destroyed.
    */
-  NS_HIDDEN_(void) Mark();
-  NS_HIDDEN_(PRBool) Sweep();
+  void Mark();
+  PRBool Sweep();
 
   static PRBool
     HasAuthorSpecifiedRules(nsStyleContext* aStyleContext,
                             PRUint32 ruleTypeMask,
                             PRBool aAuthorColorsAllowed);
 
   // Expose this so media queries can use it
   static nscoord CalcLengthWithInitialFont(nsPresContext* aPresContext,
--- a/layout/style/nsStyleContext.h
+++ b/layout/style/nsStyleContext.h
@@ -70,21 +70,21 @@ class nsPresContext;
  * collection.
  */
 
 class nsStyleContext
 {
 public:
   nsStyleContext(nsStyleContext* aParent, nsIAtom* aPseudoTag,
                  nsCSSPseudoElements::Type aPseudoType,
-                 nsRuleNode* aRuleNode, nsPresContext* aPresContext) NS_HIDDEN;
-  ~nsStyleContext() NS_HIDDEN;
+                 nsRuleNode* aRuleNode, nsPresContext* aPresContext);
+  ~nsStyleContext();
 
-  NS_HIDDEN_(void*) operator new(size_t sz, nsPresContext* aPresContext) CPP_THROW_NEW;
-  NS_HIDDEN_(void) Destroy();
+  void* operator new(size_t sz, nsPresContext* aPresContext) CPP_THROW_NEW;
+  void Destroy();
 
   nsrefcnt AddRef() {
     if (mRefCnt == PR_UINT32_MAX) {
       NS_WARNING("refcount overflow, leaking object");
       return mRefCnt;
     }
     ++mRefCnt;
     NS_LOG_ADDREF(this, mRefCnt, "nsStyleContext", sizeof(nsStyleContext));
@@ -117,17 +117,17 @@ public:
 
   // Find, if it already exists *and is easily findable* (i.e., near the
   // start of the child list), a style context whose:
   //  * GetPseudo() matches aPseudoTag
   //  * GetRuleNode() matches aRules
   //  * !GetStyleIfVisited() == !aRulesIfVisited, and, if they're
   //    non-null, GetStyleIfVisited()->GetRuleNode() == aRulesIfVisited
   //  * RelevantLinkVisited() == aRelevantLinkVisited
-  NS_HIDDEN_(already_AddRefed<nsStyleContext>)
+  already_AddRefed<nsStyleContext>
   FindChildWithRules(const nsIAtom* aPseudoTag, nsRuleNode* aRules,
                      nsRuleNode* aRulesIfVisited,
                      PRBool aRelevantLinkVisited);
 
   // Does this style context or any of its ancestors have text
   // decorations?
   PRBool HasTextDecorations() const
     { return !!(mBits & NS_STYLE_HAS_TEXT_DECORATIONS); }
@@ -192,17 +192,17 @@ public:
                    "parent mismatch");
     } else {
       NS_ASSERTION(GetStyleIfVisited()->GetParent() == GetParent(),
                    "parent mismatch");
     }
   }
 
   // Tell this style context to cache aStruct as the struct for aSID
-  NS_HIDDEN_(void) SetStyle(nsStyleStructID aSID, void* aStruct);
+  void SetStyle(nsStyleStructID aSID, void* aStruct);
 
   // Setters for inherit structs only, since rulenode only sets those eagerly.
   #define STYLE_STRUCT_INHERITED(name_, checkdata_cb_, ctor_args_)          \
     void SetStyle##name_ (nsStyle##name_ * aStruct) {                       \
       NS_ASSERTION(!mCachedInheritedData.m##name_##Data ||                  \
                    (mBits &                                                 \
                     nsCachedStyleData::GetBitForSID(eStyleStruct_##name_)), \
                    "Going to leak styledata");                              \
@@ -215,17 +215,17 @@ public:
 
   nsRuleNode* GetRuleNode() { return mRuleNode; }
   void AddStyleBit(const PRUint32& aBit) { mBits |= aBit; }
 
   /*
    * Mark this style context's rule node (and its ancestors) to prevent
    * it from being garbage collected.
    */
-  NS_HIDDEN_(void) Mark();
+  void Mark();
 
   /*
    * Get the style data for a style struct.  This is the most important
    * member function of nsIStyleContext.  It fills in a const pointer
    * to a style data struct that is appropriate for the style context's
    * frame.  This struct may be shared with other contexts (either in
    * the rule tree or the style context tree), so it should not be
    * modified.
@@ -233,17 +233,17 @@ public:
    * This function will NOT return null (even when out of memory) when
    * given a valid style struct ID, so the result does not need to be
    * null-checked.
    *
    * The typesafe functions below are preferred to the use of this
    * function, bothe because they're easier to read and  because they're
    * faster.
    */
-  NS_HIDDEN_(const void*) NS_FASTCALL GetStyleData(nsStyleStructID aSID);
+  const void* NS_FASTCALL GetStyleData(nsStyleStructID aSID);
 
   /**
    * Define typesafe getter functions for each style struct by
    * preprocessing the list of style structs.  These functions are the
    * preferred way to get style data.  The macro creates functions like:
    *   const nsStyleBorder* GetStyleBorder();
    *   const nsStyleColor* GetStyleColor();
    */
@@ -263,52 +263,52 @@ public:
    */
   #define STYLE_STRUCT(name_, checkdata_cb_, ctor_args_)  \
     const nsStyle##name_ * PeekStyle##name_() {           \
       return DoGetStyle##name_(PR_FALSE);                 \
     }
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT
 
-  NS_HIDDEN_(void*) GetUniqueStyleData(const nsStyleStructID& aSID);
+  void* GetUniqueStyleData(const nsStyleStructID& aSID);
 
-  NS_HIDDEN_(nsChangeHint) CalcStyleDifference(nsStyleContext* aOther);
+  nsChangeHint CalcStyleDifference(nsStyleContext* aOther);
 
   /**
    * Get a color that depends on link-visitedness using this and
    * this->GetStyleIfVisited().
    *
    * aProperty must be a color-valued property that nsStyleAnimation
    * knows how to extract.  It must also be a property that we know to
    * do change handling for in nsStyleContext::CalcDifference.
    *
    * Note that if aProperty is eCSSProperty_border_*_color, this
    * function handles -moz-use-text-color.
    */
-  NS_HIDDEN_(nscolor) GetVisitedDependentColor(nsCSSProperty aProperty);
+  nscolor GetVisitedDependentColor(nsCSSProperty aProperty);
 
   /**
    * aColors should be a two element array of nscolor in which the first
    * color is the unvisited color and the second is the visited color.
    *
    * Combine the R, G, and B components of whichever of aColors should
    * be used based on aLinkIsVisited with the A component of aColors[0].
    */
   static nscolor CombineVisitedColors(nscolor *aColors,
                                       PRBool aLinkIsVisited);
 
 #ifdef DEBUG
-  NS_HIDDEN_(void) List(FILE* out, PRInt32 aIndent);
+  void List(FILE* out, PRInt32 aIndent);
 #endif
 
 protected:
-  NS_HIDDEN_(void) AddChild(nsStyleContext* aChild);
-  NS_HIDDEN_(void) RemoveChild(nsStyleContext* aChild);
+  void AddChild(nsStyleContext* aChild);
+  void RemoveChild(nsStyleContext* aChild);
 
-  NS_HIDDEN_(void) ApplyStyleFixups(nsPresContext* aPresContext);
+  void ApplyStyleFixups(nsPresContext* aPresContext);
 
   // Helper function that GetStyleData and GetUniqueStyleData use.  Only
   // returns the structs we cache ourselves; never consults the ruletree.
   inline const void* GetCachedStyleData(nsStyleStructID aSID);
 
   // Helper functions for GetStyle* and PeekStyle*
   #define STYLE_STRUCT_INHERITED(name_, checkdata_cb_, ctor_args_)      \
     const nsStyle##name_ * DoGetStyle##name_(PRBool aComputeData) {     \
@@ -373,15 +373,15 @@ protected:
   // sometimes allocate the mCachedResetData.
   nsResetStyleData*       mCachedResetData; // Cached reset style data.
   nsInheritedStyleData    mCachedInheritedData; // Cached inherited style data
   PRUint32                mBits; // Which structs are inherited from the
                                  // parent context or owned by mRuleNode.
   PRUint32                mRefCnt;
 };
 
-NS_HIDDEN_(already_AddRefed<nsStyleContext>)
+already_AddRefed<nsStyleContext>
 NS_NewStyleContext(nsStyleContext* aParentContext,
                    nsIAtom* aPseudoTag,
                    nsCSSPseudoElements::Type aPseudoType,
                    nsRuleNode* aRuleNode,
                    nsPresContext* aPresContext);
 #endif
--- a/layout/style/nsStyleSet.h
+++ b/layout/style/nsStyleSet.h
@@ -384,23 +384,23 @@ class nsStyleSet
   unsigned mInShutdown : 1;
   unsigned mAuthorStyleDisabled: 1;
   unsigned mInReconstruct : 1;
   unsigned mDirty : 8;  // one dirty bit is used per sheet type
 
 };
 
 inline
-NS_HIDDEN_(void) nsRuleNode::AddRef()
+void nsRuleNode::AddRef()
 {
   if (mRefCnt++ == 0 && !IsRoot()) {
     mPresContext->StyleSet()->RuleNodeInUse();
   }
 }
 
 inline
-NS_HIDDEN_(void) nsRuleNode::Release()
+void nsRuleNode::Release()
 {
   if (--mRefCnt == 0 && !IsRoot()) {
     mPresContext->StyleSet()->RuleNodeUnused();
   }
 }
 #endif
--- a/layout/style/nsTransitionManager.cpp
+++ b/layout/style/nsTransitionManager.cpp
@@ -139,18 +139,17 @@ public:
   NS_DECL_ISUPPORTS
 
   // nsIStyleRule implementation
   NS_IMETHOD MapRuleInfoInto(nsRuleData* aRuleData);
 #ifdef DEBUG
   NS_IMETHOD List(FILE* out = stdout, PRInt32 aIndent = 0) const;
 #endif
 
-  NS_HIDDEN_(void) CoverValue(nsCSSProperty aProperty,
-                              nsStyleAnimation::Value &aStartValue)
+  void CoverValue(nsCSSProperty aProperty, nsStyleAnimation::Value &aStartValue)
   {
     CoveredValue v = { aProperty, aStartValue };
     mCoveredValues.AppendElement(v);
   }
 
   struct CoveredValue {
     nsCSSProperty mProperty;
     nsStyleAnimation::Value mCoveredValue;