get rid of nsStyleStruct base type. b=408933, r+sr=dbaron, a=beltzner
authordwitte@stanford.edu
Thu, 10 Jan 2008 12:56:49 -0800
changeset 10152 bba65f6aeffc7860b7a22b9f07fbff0345fd2506
parent 10151 459982e1b0e49ccb274ef4e287ed0eb813dde50c
child 10153 0f76ab30cdcd8b17a54d47682fb0f56471be52ac
push id1
push userroot
push dateTue, 26 Apr 2011 22:38:44 +0000
treeherdermozilla-beta@bfdb6e623a36 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbeltzner
bugs408933
milestone1.9b3pre
get rid of nsStyleStruct base type. b=408933, r+sr=dbaron, a=beltzner
layout/base/nsFrameManager.cpp
layout/base/nsPresContext.h
layout/base/nsStyleConsts.h
layout/doc/adding-style-props.html
layout/generic/nsFrame.cpp
layout/generic/nsFrame.h
layout/generic/nsIFrame.h
layout/style/nsHTMLStyleSheet.cpp
layout/style/nsRuleData.h
layout/style/nsRuleNode.cpp
layout/style/nsRuleNode.h
layout/style/nsStyleContext.cpp
layout/style/nsStyleContext.h
layout/style/nsStyleStruct.h
layout/style/nsStyleStructFwd.h
layout/style/test/test_style_struct_copy_constructors.html
--- a/layout/base/nsFrameManager.cpp
+++ b/layout/base/nsFrameManager.cpp
@@ -1112,17 +1112,17 @@ nsFrameManager::ReResolveStyleContext(ns
       else
         parentContext = nsnull;
     }
     else {
       // resolve the provider here (before aFrame below).
 
       // assumeDifferenceHint forces the parent's change to be also
       // applied to this frame, no matter what
-      // nsStyleStruct::CalcStyleDifference says. CalcStyleDifference
+      // nsStyleContext::CalcStyleDifference says. CalcStyleDifference
       // can't be trusted because it assumes any changes to the parent
       // style context provider will be automatically propagated to
       // the frame(s) with child style contexts.
       assumeDifferenceHint = ReResolveStyleContext(aPresContext, providerFrame,
                                                    content, aChangeList, aMinChange);
 
       // The provider's new context becomes the parent context of
       // aFrame's context.
--- a/layout/base/nsPresContext.h
+++ b/layout/base/nsPresContext.h
@@ -80,17 +80,16 @@ class nsIImage;
 class nsILinkHandler;
 class nsStyleContext;
 class nsIAtom;
 class nsIEventStateManager;
 class nsIURI;
 class nsILookAndFeel;
 class nsICSSPseudoComparator;
 class nsIAtom;
-struct nsStyleStruct;
 struct nsStyleBackground;
 template <class T> class nsRunnableMethod;
 class nsIRunnable;
 
 #ifdef MOZ_REFLOW_PERF
 class nsIRenderingContext;
 #endif
 
--- a/layout/base/nsStyleConsts.h
+++ b/layout/base/nsStyleConsts.h
@@ -31,17 +31,17 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-/* constants used in the nsStyleStruct data provided by nsStyleContext */
+/* constants used in the style struct data provided by nsStyleContext */
 
 #ifndef nsStyleConsts_h___
 #define nsStyleConsts_h___
 
 #include "nsFont.h"
 
 #ifndef MOZ_CAIRO_GFX
 #define GFX_HAS_INVERT
--- a/layout/doc/adding-style-props.html
+++ b/layout/doc/adding-style-props.html
@@ -283,17 +283,17 @@ value can be held for the layout objects
 First look into <a href="http://lxr.mozilla.org/seamonkey/source/content/shared/public/nsStyleStruct.h">
 nsStyleStruct.h</a>
  to see the existing style strucs. Find the one that you want to store the
 data on. In this example, we want to put it on the nsStyleUserInterface struct,
 however there is also a class nsStyleUIReset that holds the non-inherited
 values, so we will use that one (remember, our property is not inherited).
 Add a <a href="#StyleContextMember">data member</a>
  to hold the value:
-  <pre>struct nsStyleUIReset: public nsStyleStruct {
+  <pre>struct nsStyleUIReset {
   nsStyleUIReset(void);
   nsStyleUIReset(const nsStyleUIReset&amp; aOther);
   ~nsStyleUIReset(void);
 
   NS_DEFINE_STATIC_STYLESTRUCTID_ACCESSOR(eStyleStruct_UIReset)
 
   void* operator new(size_t sz, nsPresContext* aContext) {
     return aContext->AllocateFromShell(sz);
@@ -466,19 +466,17 @@ For example:<br>
 OK, finally the style system is supporting the new property. It is time to
 actually make use of it now.<br>
   <br>
 In layout, retrieve the styleStruct that has the new property from the frame's
 style context. Access the new property and get its value. It is that simple.
 For this example, it looks like this, in nsImageFrame:<br>
   <pre>        PRBool forceIcon = PR_FALSE;
 
-        const nsStyleUIReset* styleData;
-        GetStyleData(eStyleStruct_UIReset, (const nsStyleStruct*&amp;) styleData);
-        if (styleData-&gt;mForceBrokenImageIcon) {
+        if (GetStyleUIReset()-&gt;mForceBrokenImageIcon) {
           forceIcon = PR_TRUE;
         }
 
 </pre>
 Create some testcases with style rules that use the new property, make sure
 it is being parsed correctly. Test it in an external stylesheet and in inline
 style. Test that it is inherited correctly, or not inherited as appropriate
 to your property. Update this document with any further details, or correcting
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -5630,17 +5630,17 @@ nsIFrame::DeleteProperty(nsIAtom* aPropN
 
 void*
 nsIFrame::UnsetProperty(nsIAtom* aPropName, nsresult* aStatus) const
 {
   return PresContext()->PropertyTable()->UnsetProperty(this, aPropName,
                                                           aStatus);
 }
 
-/* virtual */ const nsStyleStruct*
+/* virtual */ const void*
 nsFrame::GetStyleDataExternal(nsStyleStructID aSID) const
 {
   NS_ASSERTION(mStyleContext, "unexpected null pointer");
   return mStyleContext->GetStyleData(aSID);
 }
 
 /* virtual */ PRBool
 nsIFrame::IsFocusable(PRInt32 *aTabIndex, PRBool aWithMouse)
--- a/layout/generic/nsFrame.h
+++ b/layout/generic/nsFrame.h
@@ -406,17 +406,17 @@ public:
   // if the child does not have a overflow use the child area
   void ConsiderChildOverflow(nsRect&   aOverflowArea,
                              nsIFrame* aChildFrame);
 
   //Mouse Capturing code used by the frames to tell the view to capture all the following events
   NS_IMETHOD CaptureMouse(nsPresContext* aPresContext, PRBool aGrabMouseEvents);
   PRBool   IsMouseCaptured(nsPresContext* aPresContext);
 
-  virtual const nsStyleStruct* GetStyleDataExternal(nsStyleStructID aSID) const;
+  virtual const void* GetStyleDataExternal(nsStyleStructID aSID) const;
 
 
 #ifdef NS_DEBUG
   /**
    * Tracing method that writes a method enter/exit routine to the
    * nspr log using the nsIFrame log module. The tracing is only
    * done when the NS_FRAME_TRACE_CALLS bit is set in the log module's
    * level field.
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -636,26 +636,17 @@ public:
   /**
    * Get the style data associated with this frame.  This returns a
    * const style struct pointer that should never be modified.  See
    * |nsIStyleContext::GetStyleData| for more information.
    *
    * The use of the typesafe functions below is preferred to direct use
    * of this function.
    */
-  virtual const nsStyleStruct* GetStyleDataExternal(nsStyleStructID aSID) const = 0;
-
-  const nsStyleStruct* GetStyleData(nsStyleStructID aSID) const {
-#ifdef _IMPL_NS_LAYOUT
-    NS_ASSERTION(mStyleContext, "No style context found!");
-    return mStyleContext->GetStyleData(aSID);
-#else
-    return GetStyleDataExternal(aSID);
-#endif
-  }
+  virtual const void* GetStyleDataExternal(nsStyleStructID aSID) const = 0;
 
   /**
    * 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();
    */
--- a/layout/style/nsHTMLStyleSheet.cpp
+++ b/layout/style/nsHTMLStyleSheet.cpp
@@ -104,17 +104,17 @@ nsHTMLStyleSheet::GenericTableRule::MapR
 #ifdef DEBUG
 NS_IMETHODIMP
 nsHTMLStyleSheet::GenericTableRule::List(FILE* out, PRInt32 aIndent) const
 {
   return NS_OK;
 }
 #endif
 
-static void PostResolveCallback(nsStyleStruct* aStyleStruct, nsRuleData* aRuleData)
+static void PostResolveCallback(void* aStyleStruct, nsRuleData* aRuleData)
 {
   nsStyleText* text = (nsStyleText*)aStyleStruct;
   if (text->mTextAlign == NS_STYLE_TEXT_ALIGN_DEFAULT) {
     nsStyleContext* parentContext = aRuleData->mStyleContext->GetParent();
 
     if (parentContext) {
       const nsStyleText* parentStyleText = parentContext->GetStyleText();
       PRUint8 parentAlign = parentStyleText->mTextAlign;
@@ -130,23 +130,23 @@ nsHTMLStyleSheet::TableTHRule::MapRuleIn
   if (aRuleData->mSIDs & NS_STYLE_INHERIT_BIT(Text)) {
     aRuleData->mCanStoreInRuleTree = PR_FALSE;
     aRuleData->mPostResolveCallback = &PostResolveCallback;
   }
   return NS_OK;
 }
 
 static void 
-ProcessTableRulesAttribute(nsStyleStruct* aStyleStruct, 
-                           nsRuleData*    aRuleData,
-                           PRUint8        aSide,
-                           PRBool         aGroup,
-                           PRUint8        aRulesArg1,
-                           PRUint8        aRulesArg2,
-                           PRUint8        aRulesArg3)
+ProcessTableRulesAttribute(void*       aStyleStruct, 
+                           nsRuleData* aRuleData,
+                           PRUint8     aSide,
+                           PRBool      aGroup,
+                           PRUint8     aRulesArg1,
+                           PRUint8     aRulesArg2,
+                           PRUint8     aRulesArg3)
 {
   if (!aStyleStruct || !aRuleData || !aRuleData->mPresContext) return;
 
   nsStyleContext* tableContext = aRuleData->mStyleContext->GetParent();
   if (!tableContext)
     return;
   if (!aGroup) {
     tableContext = tableContext->GetParent();
@@ -197,17 +197,17 @@ ProcessTableRulesAttribute(nsStyleStruct
         borderData->SetBorderColor(aSide, borderColor);
       }
       // set the border width to be 1 pixel
       borderData->SetBorderWidth(aSide, nsPresContext::CSSPixelsToAppUnits(1));
     }
   }
 }
 
-static void TbodyPostResolveCallback(nsStyleStruct* aStyleStruct, nsRuleData* aRuleData)
+static void TbodyPostResolveCallback(void* aStyleStruct, nsRuleData* aRuleData)
 {
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_TOP, PR_TRUE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_GROUPS, NS_STYLE_TABLE_RULES_ROWS);
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_BOTTOM, PR_TRUE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_GROUPS, NS_STYLE_TABLE_RULES_ROWS);
 }
 
 NS_IMETHODIMP
@@ -216,17 +216,17 @@ nsHTMLStyleSheet::TableTbodyRule::MapRul
   if (aRuleData->mSIDs & NS_STYLE_INHERIT_BIT(Border)) {
     aRuleData->mCanStoreInRuleTree = PR_FALSE;
     aRuleData->mPostResolveCallback = &TbodyPostResolveCallback;
   }
   return NS_OK;
 }
 // -----------------------------------------------------------
 
-static void RowPostResolveCallback(nsStyleStruct* aStyleStruct, nsRuleData* aRuleData)
+static void RowPostResolveCallback(void* aStyleStruct, nsRuleData* aRuleData)
 {
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_TOP, PR_FALSE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_ROWS, NS_STYLE_TABLE_RULES_ROWS);
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_BOTTOM, PR_FALSE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_ROWS, NS_STYLE_TABLE_RULES_ROWS);
 }
 
 NS_IMETHODIMP
@@ -234,17 +234,17 @@ nsHTMLStyleSheet::TableRowRule::MapRuleI
 {
   if (aRuleData->mSIDs & NS_STYLE_INHERIT_BIT(Border)) {
     aRuleData->mCanStoreInRuleTree = PR_FALSE;
     aRuleData->mPostResolveCallback = &RowPostResolveCallback;
   }
   return NS_OK;
 }
 
-static void ColgroupPostResolveCallback(nsStyleStruct* aStyleStruct, nsRuleData* aRuleData)
+static void ColgroupPostResolveCallback(void* aStyleStruct, nsRuleData* aRuleData)
 {
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_LEFT, PR_TRUE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_GROUPS, NS_STYLE_TABLE_RULES_COLS);
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_RIGHT, PR_TRUE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_GROUPS, NS_STYLE_TABLE_RULES_COLS);
 }
 
 NS_IMETHODIMP
@@ -252,25 +252,25 @@ nsHTMLStyleSheet::TableColgroupRule::Map
 {
   if (aRuleData->mSIDs & NS_STYLE_INHERIT_BIT(Border)) {
     aRuleData->mCanStoreInRuleTree = PR_FALSE;
     aRuleData->mPostResolveCallback = &ColgroupPostResolveCallback;
   }
   return NS_OK;
 }
 
-static void ColPostResolveCallback(nsStyleStruct* aStyleStruct, nsRuleData* aRuleData)
+static void ColPostResolveCallback(void* aStyleStruct, nsRuleData* aRuleData)
 {
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_LEFT, PR_FALSE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_COLS, NS_STYLE_TABLE_RULES_COLS);
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_RIGHT, PR_FALSE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_COLS, NS_STYLE_TABLE_RULES_COLS);
 }
 
-static void UngroupedColPostResolveCallback(nsStyleStruct* aStyleStruct,
+static void UngroupedColPostResolveCallback(void* aStyleStruct,
                                             nsRuleData* aRuleData)
 {
   // Pass PR_TRUE for aGroup, so that we find the table's style
   // context correctly.
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_LEFT, PR_TRUE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_COLS, NS_STYLE_TABLE_RULES_COLS);
   ::ProcessTableRulesAttribute(aStyleStruct, aRuleData, NS_SIDE_RIGHT, PR_TRUE, NS_STYLE_TABLE_RULES_ALL,
                                NS_STYLE_TABLE_RULES_COLS, NS_STYLE_TABLE_RULES_COLS);
--- a/layout/style/nsRuleData.h
+++ b/layout/style/nsRuleData.h
@@ -45,17 +45,17 @@
 #define nsRuleData_h_
 
 #include "nsCSSStruct.h"
 #include "nsStyleStructFwd.h"
 class nsPresContext;
 class nsStyleContext;
 
 struct nsRuleData;
-typedef void (*nsPostResolveFunc)(nsStyleStruct* aStyleStruct, nsRuleData* aData);
+typedef void (*nsPostResolveFunc)(void* aStyleStruct, nsRuleData* aData);
 
 struct nsRuleData
 {
   PRUint32 mSIDs;
   PRPackedBool mCanStoreInRuleTree;
   PRPackedBool mIsImportantRule;
   PRUint8 mLevel; // an nsStyleSet::sheetType
   nsPresContext* mPresContext;
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -1111,268 +1111,268 @@ nsRuleNode::CheckSpecifiedProperties(con
 
   if (structData->callback) {
     result = (*structData->callback)(aRuleDataStruct, result);
   }
 
   return result;
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetDisplayData(nsStyleContext* aContext)
 {
   nsRuleDataDisplay displayData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Display), mPresContext, aContext);
   ruleData.mDisplayData = &displayData;
 
   return WalkRuleTree(eStyleStruct_Display, aContext, &ruleData, &displayData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetVisibilityData(nsStyleContext* aContext)
 {
   nsRuleDataDisplay displayData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Visibility), mPresContext, aContext);
   ruleData.mDisplayData = &displayData;
 
   return WalkRuleTree(eStyleStruct_Visibility, aContext, &ruleData, &displayData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetTextData(nsStyleContext* aContext)
 {
   nsRuleDataText textData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Text), mPresContext, aContext);
   ruleData.mTextData = &textData;
 
   return WalkRuleTree(eStyleStruct_Text, aContext, &ruleData, &textData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetTextResetData(nsStyleContext* aContext)
 {
   nsRuleDataText textData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(TextReset), mPresContext, aContext);
   ruleData.mTextData = &textData;
 
-  const nsStyleStruct* res = WalkRuleTree(eStyleStruct_TextReset, aContext, &ruleData, &textData);
+  const void* res = WalkRuleTree(eStyleStruct_TextReset, aContext, &ruleData, &textData);
   textData.mTextShadow = nsnull; // We are sharing with some style rule.  It really owns the data.
   return res;
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetUserInterfaceData(nsStyleContext* aContext)
 {
   nsRuleDataUserInterface uiData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(UserInterface), mPresContext, aContext);
   ruleData.mUserInterfaceData = &uiData;
 
-  const nsStyleStruct* res = WalkRuleTree(eStyleStruct_UserInterface, aContext, &ruleData, &uiData);
+  const void* res = WalkRuleTree(eStyleStruct_UserInterface, aContext, &ruleData, &uiData);
   uiData.mCursor = nsnull; // We are sharing with some style rule.  It really owns the data.
   return res;
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetUIResetData(nsStyleContext* aContext)
 {
   nsRuleDataUserInterface uiData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(UIReset), mPresContext, aContext);
   ruleData.mUserInterfaceData = &uiData;
 
-  const nsStyleStruct* res = WalkRuleTree(eStyleStruct_UIReset, aContext, &ruleData, &uiData);
+  const void* res = WalkRuleTree(eStyleStruct_UIReset, aContext, &ruleData, &uiData);
   return res;
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetFontData(nsStyleContext* aContext)
 {
   nsRuleDataFont fontData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Font), mPresContext, aContext);
   ruleData.mFontData = &fontData;
 
   return WalkRuleTree(eStyleStruct_Font, aContext, &ruleData, &fontData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetColorData(nsStyleContext* aContext)
 {
   nsRuleDataColor colorData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Color), mPresContext, aContext);
   ruleData.mColorData = &colorData;
 
   return WalkRuleTree(eStyleStruct_Color, aContext, &ruleData, &colorData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetBackgroundData(nsStyleContext* aContext)
 {
   nsRuleDataColor colorData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Background), mPresContext, aContext);
   ruleData.mColorData = &colorData;
 
   return WalkRuleTree(eStyleStruct_Background, aContext, &ruleData, &colorData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetMarginData(nsStyleContext* aContext)
 {
   nsRuleDataMargin marginData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Margin), mPresContext, aContext);
   ruleData.mMarginData = &marginData;
 
   return WalkRuleTree(eStyleStruct_Margin, aContext, &ruleData, &marginData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetBorderData(nsStyleContext* aContext)
 {
   nsRuleDataMargin marginData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Border), mPresContext, aContext);
   ruleData.mMarginData = &marginData;
 
   return WalkRuleTree(eStyleStruct_Border, aContext, &ruleData, &marginData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetPaddingData(nsStyleContext* aContext)
 {
   nsRuleDataMargin marginData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Padding), mPresContext, aContext);
   ruleData.mMarginData = &marginData;
 
   return WalkRuleTree(eStyleStruct_Padding, aContext, &ruleData, &marginData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetOutlineData(nsStyleContext* aContext)
 {
   nsRuleDataMargin marginData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Outline), mPresContext, aContext);
   ruleData.mMarginData = &marginData;
 
   return WalkRuleTree(eStyleStruct_Outline, aContext, &ruleData, &marginData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetListData(nsStyleContext* aContext)
 {
   nsRuleDataList listData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(List), mPresContext, aContext);
   ruleData.mListData = &listData;
 
   return WalkRuleTree(eStyleStruct_List, aContext, &ruleData, &listData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetPositionData(nsStyleContext* aContext)
 {
   nsRuleDataPosition posData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Position), mPresContext, aContext);
   ruleData.mPositionData = &posData;
 
   return WalkRuleTree(eStyleStruct_Position, aContext, &ruleData, &posData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetTableData(nsStyleContext* aContext)
 {
   nsRuleDataTable tableData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Table), mPresContext, aContext);
   ruleData.mTableData = &tableData;
 
   return WalkRuleTree(eStyleStruct_Table, aContext, &ruleData, &tableData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetTableBorderData(nsStyleContext* aContext)
 {
   nsRuleDataTable tableData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(TableBorder), mPresContext, aContext);
   ruleData.mTableData = &tableData;
 
   return WalkRuleTree(eStyleStruct_TableBorder, aContext, &ruleData, &tableData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetContentData(nsStyleContext* aContext)
 {
   nsRuleDataContent contentData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Content), mPresContext, aContext);
   ruleData.mContentData = &contentData;
 
-  const nsStyleStruct* res = WalkRuleTree(eStyleStruct_Content, aContext, &ruleData, &contentData);
+  const void* res = WalkRuleTree(eStyleStruct_Content, aContext, &ruleData, &contentData);
   contentData.mCounterIncrement = contentData.mCounterReset = nsnull;
   contentData.mContent = nsnull; // We are sharing with some style rule.  It really owns the data.
   return res;
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetQuotesData(nsStyleContext* aContext)
 {
   nsRuleDataContent contentData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Quotes), mPresContext, aContext);
   ruleData.mContentData = &contentData;
 
-  const nsStyleStruct* res = WalkRuleTree(eStyleStruct_Quotes, aContext, &ruleData, &contentData);
+  const void* res = WalkRuleTree(eStyleStruct_Quotes, aContext, &ruleData, &contentData);
   contentData.mQuotes = nsnull; // We are sharing with some style rule.  It really owns the data.
   return res;
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetXULData(nsStyleContext* aContext)
 {
   nsRuleDataXUL xulData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(XUL), mPresContext, aContext);
   ruleData.mXULData = &xulData;
 
   return WalkRuleTree(eStyleStruct_XUL, aContext, &ruleData, &xulData);
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetColumnData(nsStyleContext* aContext)
 {
   nsRuleDataColumn columnData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Column), mPresContext, aContext);
   ruleData.mColumnData = &columnData;
 
   return WalkRuleTree(eStyleStruct_Column, aContext, &ruleData, &columnData);
 }
 
 #ifdef MOZ_SVG
-const nsStyleStruct*
+const void*
 nsRuleNode::GetSVGData(nsStyleContext* aContext)
 {
   nsRuleDataSVG svgData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(SVG), mPresContext, aContext);
   ruleData.mSVGData = &svgData;
 
-  const nsStyleStruct *res = WalkRuleTree(eStyleStruct_SVG, aContext, &ruleData, &svgData);
+  const void *res = WalkRuleTree(eStyleStruct_SVG, aContext, &ruleData, &svgData);
   svgData.mStrokeDasharray = nsnull; // We are sharing with some style rule.  It really owns the data.
   return res;
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::GetSVGResetData(nsStyleContext* aContext)
 {
   nsRuleDataSVG svgData; // Declare a struct with null CSS values.
   nsRuleData ruleData(NS_STYLE_INHERIT_BIT(SVGReset), mPresContext, aContext);
   ruleData.mSVGData = &svgData;
 
   return WalkRuleTree(eStyleStruct_SVGReset, aContext, &ruleData, &svgData);
 }
 #endif
 
-const nsStyleStruct*
+const void*
 nsRuleNode::WalkRuleTree(const nsStyleStructID aSID,
                          nsStyleContext* aContext, 
                          nsRuleData* aRuleData,
                          nsRuleDataStruct* aSpecificData)
 {
   // We start at the most specific rule in the tree.  
-  nsStyleStruct* startStruct = nsnull;
+  void* startStruct = nsnull;
   
   nsRuleNode* ruleNode = this;
   nsRuleNode* highestNode = nsnull; // The highest node in the rule tree
                                     // that has the same properties
                                     // specified for struct |aSID| as
                                     // |this| does.
   nsRuleNode* rootNode = this; // After the loop below, this will be the
                                // highest node that we've walked without
@@ -1480,46 +1480,46 @@ nsRuleNode::WalkRuleTree(const nsStyleSt
     // In the absence of any computed data in the rule tree and with
     // no rules specified that didn't have values of 'inherit', we should check our parent.
     nsStyleContext* parentContext = aContext->GetParent();
     if (parentContext) {
       // We have a parent, and so we should just inherit from the parent.
       // Set the inherit bits on our context.  These bits tell the style context that
       // it never has to go back to the rule tree for data.  Instead the style context tree
       // should be walked to find the data.
-      const nsStyleStruct* parentStruct = parentContext->GetStyleData(aSID);
+      const void* parentStruct = parentContext->GetStyleData(aSID);
       aContext->AddStyleBit(bit); // makes const_cast OK.
-      aContext->SetStyle(aSID, const_cast<nsStyleStruct*>(parentStruct));
+      aContext->SetStyle(aSID, const_cast<void*>(parentStruct));
       return parentStruct;
     }
     else
       // We are the root.  In the case of fonts, the default values just
       // come from the pres context.
       return SetDefaultOnRoot(aSID, aContext);
   }
 
   // We need to compute the data from the information that the rules specified.
-  const nsStyleStruct* res;
+  const void* res;
 #define STYLE_STRUCT_TEST aSID
 #define STYLE_STRUCT(name, checkdata_cb, ctor_args)                           \
   res = Compute##name##Data(startStruct, *aSpecificData, aContext,            \
                       highestNode, detail, !aRuleData->mCanStoreInRuleTree);
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 #undef STYLE_STRUCT_TEST
 
   // If we have a post-resolve callback, handle that now.
   if (aRuleData->mPostResolveCallback && (NS_LIKELY(res != nsnull)))
-    (*aRuleData->mPostResolveCallback)((nsStyleStruct*)res, aRuleData);
+    (*aRuleData->mPostResolveCallback)(const_cast<void*>(res), aRuleData);
 
   // Now return the result.
   return res;
 }
 
-const nsStyleStruct*
+const void*
 nsRuleNode::SetDefaultOnRoot(const nsStyleStructID aSID, nsStyleContext* aContext)
 {
   switch (aSID) {
     case eStyleStruct_Font: 
     {
       nsStyleFont* fontData = new (mPresContext) nsStyleFont(mPresContext);
       if (NS_LIKELY(fontData != nsnull)) {
         nscoord minimumFontSize =
@@ -2487,17 +2487,17 @@ nsRuleNode::SetGenericFont(nsPresContext
 
     nsRuleNode::SetFont(aPresContext, context, aMinFontSize,
                         aGenericFontID, fontData, &parentFont, aFont,
                         PR_FALSE, dummy);
 
     // XXX Not sure if we need to do this here
     // If we have a post-resolve callback, handle that now.
     if (ruleData.mPostResolveCallback)
-      (ruleData.mPostResolveCallback)((nsStyleStruct*)aFont, &ruleData);
+      (ruleData.mPostResolveCallback)(aFont, &ruleData);
 
     parentFont = *aFont;
   }
 }
 
 static PRBool ExtractGeneric(const nsString& aFamily, PRBool aGeneric,
                              void *aData)
 {
@@ -2505,18 +2505,18 @@ static PRBool ExtractGeneric(const nsStr
 
   if (aGeneric) {
     *data = aFamily;
     return PR_FALSE; // stop enumeration
   }
   return PR_TRUE;
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeFontData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeFontData(void* aStartStruct,
                             const nsRuleDataStruct& aData, 
                             nsStyleContext* aContext, 
                             nsRuleNode* aHighestNode,
                             const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_INHERITED(Font, (mPresContext), font, parentFont,
                           Font, fontData)
 
@@ -2598,18 +2598,18 @@ nsRuleNode::ComputeFontData(nsStyleStruc
     inherited = PR_TRUE;
     nsRuleNode::SetGenericFont(mPresContext, aContext, generic,
                                minimumFontSize, font);
   }
 
   COMPUTE_END_INHERITED(Font, font)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeTextData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeTextData(void* aStartStruct,
                             const nsRuleDataStruct& aData, 
                             nsStyleContext* aContext, 
                             nsRuleNode* aHighestNode,
                             const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_INHERITED(Text, (), text, parentText, Text, textData)
 
     // letter-spacing: normal, length, inherit
@@ -2705,18 +2705,18 @@ nsRuleNode::ComputeTextData(nsStyleStruc
   // word-spacing: normal, length, inherit
   SetCoord(textData.mWordSpacing, text->mWordSpacing, parentText->mWordSpacing,
            SETCOORD_LH | SETCOORD_NORMAL | SETCOORD_INITIAL_NORMAL,
            aContext, mPresContext, inherited);
 
   COMPUTE_END_INHERITED(Text, text)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeTextResetData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeTextResetData(void* aStartStruct,
                                  const nsRuleDataStruct& aData, 
                                  nsStyleContext* aContext, 
                                  nsRuleNode* aHighestNode,
                                  const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(TextReset, (), text, parentText, Text, textData)
   
   // vertical-align: enum, length, percent, inherit
@@ -2764,18 +2764,18 @@ nsRuleNode::ComputeTextResetData(nsStyle
   else if (eCSSUnit_Inherit == textData.mUnicodeBidi.GetUnit() ) {
     inherited = PR_TRUE;
     text->mUnicodeBidi = parentText->mUnicodeBidi;
   }
 
   COMPUTE_END_RESET(TextReset, text)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeUserInterfaceData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeUserInterfaceData(void* aStartStruct,
                                      const nsRuleDataStruct& aData, 
                                      nsStyleContext* aContext, 
                                      nsRuleNode* aHighestNode,
                                      const RuleDetail aRuleDetail,
                                      PRBool aInherited)
 {
   COMPUTE_START_INHERITED(UserInterface, (), ui, parentUI,
                           UserInterface, uiData)
@@ -2883,18 +2883,18 @@ nsRuleNode::ComputeUserInterfaceData(nsS
   else if (eCSSUnit_Inherit == uiData.mUserFocus.GetUnit()) {
     inherited = PR_TRUE;
     ui->mUserFocus = parentUI->mUserFocus;
   }
 
   COMPUTE_END_INHERITED(UserInterface, ui)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeUIResetData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeUIResetData(void* aStartStruct,
                                const nsRuleDataStruct& aData, 
                                nsStyleContext* aContext, 
                                nsRuleNode* aHighestNode,
                                const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(UIReset, (), ui, parentUI, UserInterface, uiData)
   
   // user-select: none, enum, inherit
@@ -2936,18 +2936,18 @@ nsRuleNode::ComputeUIResetData(nsStyleSt
     inherited = PR_TRUE;
     ui->mForceBrokenImageIcon = parentUI->mForceBrokenImageIcon;
   } else if (eCSSUnit_Initial == uiData.mForceBrokenImageIcon.GetUnit()) {
     ui->mForceBrokenImageIcon = 0;
   }
   COMPUTE_END_RESET(UIReset, ui)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeDisplayData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeDisplayData(void* aStartStruct,
                                const nsRuleDataStruct& aData, 
                                nsStyleContext* aContext, 
                                nsRuleNode* aHighestNode,
                                const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Display, (), display, parentDisplay,
                       Display, displayData)
   nsIAtom* pseudoTag = aContext->GetPseudoType();
@@ -3298,18 +3298,18 @@ nsRuleNode::ComputeDisplayData(nsStyleSt
       inherited = PR_TRUE;
     }
 
   }
 
   COMPUTE_END_RESET(Display, display)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeVisibilityData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeVisibilityData(void* aStartStruct,
                                   const nsRuleDataStruct& aData, 
                                   nsStyleContext* aContext, 
                                   nsRuleNode* aHighestNode,
                                   const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_INHERITED(Visibility, (mPresContext),
                           visibility, parentVisibility,
                           Display, displayData)
@@ -3356,18 +3356,18 @@ nsRuleNode::ComputeVisibilityData(nsStyl
       displayData.mLang.GetStringValue(lang);
       visibility->mLangGroup = gLangService->LookupLanguage(lang);
     }
   } 
 
   COMPUTE_END_INHERITED(Visibility, visibility)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeColorData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeColorData(void* aStartStruct,
                              const nsRuleDataStruct& aData, 
                              nsStyleContext* aContext, 
                              nsRuleNode* aHighestNode,
                              const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_INHERITED(Color, (mPresContext), color, parentColor,
                           Color, colorData)
 
@@ -3385,18 +3385,18 @@ nsRuleNode::ComputeColorData(nsStyleStru
   else {
     SetColor(colorData.mColor, parentColor->mColor, mPresContext, aContext, color->mColor, 
              inherited);
   }
 
   COMPUTE_END_INHERITED(Color, color)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeBackgroundData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeBackgroundData(void* aStartStruct,
                                   const nsRuleDataStruct& aData, 
                                   nsStyleContext* aContext, 
                                   nsRuleNode* aHighestNode,
                                   const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Background, (mPresContext), bg, parentBG,
                       Color, colorData)
 
@@ -3572,18 +3572,18 @@ nsRuleNode::ComputeBackgroundData(nsStyl
   }
   else if (eCSSUnit_Initial == colorData.mBackPosition.mYValue.GetUnit()) {
     bg->mBackgroundFlags &= ~(NS_STYLE_BG_Y_POSITION_LENGTH | NS_STYLE_BG_Y_POSITION_PERCENT);
   }
 
   COMPUTE_END_RESET(Background, bg)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeMarginData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeMarginData(void* aStartStruct,
                               const nsRuleDataStruct& aData, 
                               nsStyleContext* aContext, 
                               nsRuleNode* aHighestNode,
                               const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Margin, (), margin, parentMargin, Margin, marginData)
 
   // margin: length, percent, auto, inherit
@@ -3608,18 +3608,18 @@ nsRuleNode::ComputeMarginData(nsStyleStr
       margin->mMargin.Set(side, coord);
     }
   }
 
   margin->RecalcData();
   COMPUTE_END_RESET(Margin, margin)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeBorderData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeBorderData(void* aStartStruct,
                               const nsRuleDataStruct& aData, 
                               nsStyleContext* aContext, 
                               nsRuleNode* aHighestNode,
                               const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Border, (mPresContext), border, parentBorder,
                       Margin, marginData)
 
@@ -3813,18 +3813,18 @@ nsRuleNode::ComputeBorderData(nsStyleStr
   }
   else if (eCSSUnit_Initial == marginData.mFloatEdge.GetUnit()) {
     border->mFloatEdge = NS_STYLE_FLOAT_EDGE_CONTENT;
   }
 
   COMPUTE_END_RESET(Border, border)
 }
   
-const nsStyleStruct*
-nsRuleNode::ComputePaddingData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputePaddingData(void* aStartStruct,
                                const nsRuleDataStruct& aData, 
                                nsStyleContext* aContext, 
                                nsRuleNode* aHighestNode,
                                const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Padding, (), padding, parentPadding, Margin, marginData)
 
   // padding: length, percent, inherit
@@ -3849,18 +3849,18 @@ nsRuleNode::ComputePaddingData(nsStyleSt
       padding->mPadding.Set(side, coord);
     }
   }
 
   padding->RecalcData();
   COMPUTE_END_RESET(Padding, padding)
 }
 
-const nsStyleStruct*
-nsRuleNode::ComputeOutlineData(nsStyleStruct* aStartStruct,
+const void*
+nsRuleNode::ComputeOutlineData(void* aStartStruct,
                                const nsRuleDataStruct& aData, 
                                nsStyleContext* aContext, 
                                nsRuleNode* aHighestNode,
                                const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Outline, (mPresContext), outline, parentOutline,
                       Margin, marginData)
 
@@ -3937,18 +3937,18 @@ nsRuleNode::ComputeOutlineData(nsStyleSt
     inherited = PR_TRUE;
     outline->SetOutlineStyle(parentOutline->GetOutlineStyle());
   }
 
   outline->RecalcData(mPresContext);
   COMPUTE_END_RESET(Outline, outline)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeListData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeListData(void* aStartStruct,
                             const nsRuleDataStruct& aData, 
                             nsStyleContext* aContext, 
                             nsRuleNode* aHighestNode,
                             const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_INHERITED(List, (), list, parentList, List, listData)
 
   // list-style-type: enum, none, inherit
@@ -4022,18 +4022,18 @@ nsRuleNode::ComputeListData(nsStyleStruc
     else if (listData.mImageRegion.mRight.IsLengthUnit())
       list->mImageRegion.width = CalcLength(listData.mImageRegion.mRight, aContext, mPresContext, inherited) -
                                 list->mImageRegion.x;
   }
 
   COMPUTE_END_INHERITED(List, list)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputePositionData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputePositionData(void* aStartStruct,
                                 const nsRuleDataStruct& aData, 
                                 nsStyleContext* aContext, 
                                 nsRuleNode* aHighestNode,
                                 const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Position, (), pos, parentPos, Position, posData)
 
   // box offsets: length, percent, auto, inherit
@@ -4089,18 +4089,18 @@ nsRuleNode::ComputePositionData(nsStyleS
       inherited = PR_TRUE;
       pos->mZIndex = parentPos->mZIndex;
     }
   }
 
   COMPUTE_END_RESET(Position, pos)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeTableData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeTableData(void* aStartStruct,
                              const nsRuleDataStruct& aData, 
                              nsStyleContext* aContext, 
                              nsRuleNode* aHighestNode,
                              const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Table, (), table, parentTable, Table, tableData)
 
   // table-layout: auto, enum, inherit
@@ -4130,18 +4130,18 @@ nsRuleNode::ComputeTableData(nsStyleStru
   // span: pixels (not a real CSS prop)
   if (eCSSUnit_Enumerated == tableData.mSpan.GetUnit() ||
       eCSSUnit_Integer == tableData.mSpan.GetUnit())
     table->mSpan = tableData.mSpan.GetIntValue();
     
   COMPUTE_END_RESET(Table, table)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeTableBorderData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeTableBorderData(void* aStartStruct,
                                    const nsRuleDataStruct& aData, 
                                    nsStyleContext* aContext, 
                                    nsRuleNode* aHighestNode,
                                    const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_INHERITED(TableBorder, (mPresContext), table, parentTable,
                           Table, tableData)
 
@@ -4192,18 +4192,18 @@ nsRuleNode::ComputeTableBorderData(nsSty
         ? NS_STYLE_TABLE_EMPTY_CELLS_SHOW_BACKGROUND     
         : NS_STYLE_TABLE_EMPTY_CELLS_SHOW;
 
   }
 
   COMPUTE_END_INHERITED(TableBorder, table)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeContentData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeContentData(void* aStartStruct,
                                const nsRuleDataStruct& aData, 
                                nsStyleContext* aContext, 
                                nsRuleNode* aHighestNode,
                                const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Content, (), content, parentContent,
                       Content, contentData)
 
@@ -4379,34 +4379,34 @@ nsRuleNode::ComputeContentData(nsStyleSt
   // marker-offset: length, auto, inherit
   SetCoord(contentData.mMarkerOffset, content->mMarkerOffset, parentContent->mMarkerOffset,
            SETCOORD_LH | SETCOORD_AUTO | SETCOORD_INITIAL_AUTO, aContext,
            mPresContext, inherited);
     
   COMPUTE_END_RESET(Content, content)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeQuotesData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeQuotesData(void* aStartStruct,
                               const nsRuleDataStruct& aData, 
                               nsStyleContext* aContext, 
                               nsRuleNode* aHighestNode,
                               const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_INHERITED(Quotes, (), quotes, parentQuotes,
                           Content, contentData)
 
   // quotes: [string string]+, none, inherit
   PRUint32 count;
   nsAutoString  buffer;
   nsCSSQuotes* ourQuotes = contentData.mQuotes;
   if (ourQuotes) {
     nsAutoString  closeBuffer;
     // FIXME Bug 389406: Implement eCSSUnit_Initial (correctly, unlike
-    // nsStyleStruct), and remove the "initial" value from ua.css.
+    // style structs), and remove the "initial" value from ua.css.
     if (eCSSUnit_Inherit == ourQuotes->mOpen.GetUnit()) {
       inherited = PR_TRUE;
       count = parentQuotes->QuotesCount();
       if (NS_SUCCEEDED(quotes->AllocateQuotes(count))) {
         while (0 < count--) {
           parentQuotes->GetQuotesAt(count, buffer, closeBuffer);
           quotes->SetQuotesAt(count, buffer, closeBuffer);
         }
@@ -4434,18 +4434,18 @@ nsRuleNode::ComputeQuotesData(nsStyleStr
         }
       }
     }
   }
 
   COMPUTE_END_INHERITED(Quotes, quotes)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeXULData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeXULData(void* aStartStruct,
                            const nsRuleDataStruct& aData, 
                            nsStyleContext* aContext, 
                            nsRuleNode* aHighestNode,
                            const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(XUL, (), xul, parentXUL, XUL, xulData)
 
   // box-align: enum, inherit
@@ -4516,18 +4516,18 @@ nsRuleNode::ComputeXULData(nsStyleStruct
     xul->mBoxOrdinal = parentXUL->mBoxOrdinal;
   } else if (eCSSUnit_Initial == xulData.mBoxOrdinal.GetUnit()) {
     xul->mBoxOrdinal = 1;
   }
 
   COMPUTE_END_RESET(XUL, xul)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeColumnData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeColumnData(void* aStartStruct,
                               const nsRuleDataStruct& aData, 
                               nsStyleContext* aContext, 
                               nsRuleNode* aHighestNode,
                               const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(Column, (), column, parent, Column, columnData)
 
   // column-width: length, auto, inherit
@@ -4604,18 +4604,18 @@ SetSVGOpacity(const nsCSSValue& aValue, 
     opacity = PR_MAX(opacity, 0.0f);
     opacity = PR_MIN(opacity, 1.0f);
   }
   else if (aValue.GetUnit() == eCSSUnit_Initial) {
     opacity = 1.0f;
   }
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeSVGData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeSVGData(void* aStartStruct,
                            const nsRuleDataStruct& aData, 
                            nsStyleContext* aContext, 
                            nsRuleNode* aHighestNode,
                            const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_INHERITED(SVG, (), svg, parentSVG, SVG, SVGData)
 
   // clip-rule: enum, inherit
@@ -4874,18 +4874,18 @@ nsRuleNode::ComputeSVGData(nsStyleStruct
   else if (eCSSUnit_Inherit == SVGData.mTextRendering.GetUnit()) {
     inherited = PR_TRUE;
     svg->mTextRendering = parentSVG->mTextRendering;
   }
 
   COMPUTE_END_INHERITED(SVG, svg)
 }
 
-const nsStyleStruct* 
-nsRuleNode::ComputeSVGResetData(nsStyleStruct* aStartStruct,
+const void* 
+nsRuleNode::ComputeSVGResetData(void* aStartStruct,
                                 const nsRuleDataStruct& aData,
                                 nsStyleContext* aContext, 
                                 nsRuleNode* aHighestNode,
                                 const RuleDetail aRuleDetail, PRBool aInherited)
 {
   COMPUTE_START_RESET(SVGReset, (), svgReset, parentSVGReset, SVG, SVGData)
 
   // stop-color:
@@ -4965,17 +4965,17 @@ nsRuleNode::ComputeSVGResetData(nsStyleS
     inherited = PR_TRUE;
     svgReset->mMask = parentSVGReset->mMask;
   }
   
   COMPUTE_END_RESET(SVGReset, svgReset)
 }
 #endif
 
-inline const nsStyleStruct* 
+inline const void* 
 nsRuleNode::GetParentData(const nsStyleStructID aSID)
 {
   NS_PRECONDITION(mDependentBits & nsCachedStyleData::GetBitForSID(aSID),
                   "should be called when node depends on parent data");
   NS_ASSERTION(mStyleData.GetStyleData(aSID) == nsnull,
                "both struct and dependent bits present");
   // Walk up the rule tree from this rule node (towards less specific
   // rules).
@@ -5009,22 +5009,22 @@ nsRuleNode::GetParent##name_()          
     ruleNode = ruleNode->mParent;                                           \
   }                                                                         \
                                                                             \
   return ruleNode->mStyleData.GetStyle##name_();                            \
 }
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 
-const nsStyleStruct* 
+const void* 
 nsRuleNode::GetStyleData(nsStyleStructID aSID, 
                          nsStyleContext* aContext,
                          PRBool aComputeData)
 {
-  const nsStyleStruct *data;
+  const void *data;
   if (mDependentBits & nsCachedStyleData::GetBitForSID(aSID)) {
     // We depend on an ancestor for this struct since the cached struct
     // it has is also appropriate for this rule node.  Just go up the
     // rule tree and return the first cached struct we find.
     data = GetParentData(aSID);
     NS_ASSERTION(data, "dependent bits set but no cached struct present");
     return data;
   }
--- a/layout/style/nsRuleNode.h
+++ b/layout/style/nsRuleNode.h
@@ -188,17 +188,17 @@ struct nsCachedStyleData
   static PRBool IsReset(const nsStyleStructID& aSID) {
     return gInfo[aSID].mIsReset;
   }
 
   static PRUint32 GetBitForSID(const nsStyleStructID& aSID) {
     return 1 << aSID;
   }
 
-  NS_HIDDEN_(nsStyleStruct*) NS_FASTCALL GetStyleData(const nsStyleStructID& aSID) {
+  NS_HIDDEN_(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
@@ -209,22 +209,22 @@ struct nsCachedStyleData
     const StyleStructInfo& info = gInfo[aSID];
 
     // Get either &mInheritedData or &mResetData.
     char* resetOrInheritSlot = reinterpret_cast<char*>(this) + info.mCachedStyleDataOffset;
 
     // Get either mInheritedData or mResetData.
     char* resetOrInherit = reinterpret_cast<char*>(*reinterpret_cast<void**>(resetOrInheritSlot));
 
-    nsStyleStruct* data = nsnull;
+    void* data = nsnull;
     if (resetOrInherit) {
       // If we have the mInheritedData or mResetData, then we might have
       // the struct, so get it.
       char* dataSlot = resetOrInherit + info.mInheritResetOffset;
-      data = *reinterpret_cast<nsStyleStruct**>(dataSlot);
+      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_ () {        \
       return mInheritedData ? mInheritedData->m##name_##Data : nsnull;   \
@@ -446,159 +446,159 @@ public:
   NS_HIDDEN_(void) Destroy();
   static NS_HIDDEN_(nsILanguageAtomService*) gLangService;
 
 protected:
   NS_HIDDEN_(void) PropagateDependentBit(PRUint32 aBit,
                                          nsRuleNode* aHighestNode);
   NS_HIDDEN_(void) PropagateNoneBit(PRUint32 aBit, nsRuleNode* aHighestNode);
   
-  NS_HIDDEN_(const nsStyleStruct*) SetDefaultOnRoot(const nsStyleStructID aSID,
-                                                    nsStyleContext* aContext);
+  NS_HIDDEN_(const void*) SetDefaultOnRoot(const nsStyleStructID aSID,
+                                                 nsStyleContext* aContext);
 
-  NS_HIDDEN_(const nsStyleStruct*)
+  NS_HIDDEN_(const void*)
     WalkRuleTree(const nsStyleStructID aSID, nsStyleContext* aContext, 
                  nsRuleData* aRuleData, nsRuleDataStruct* aSpecificData);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeDisplayData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeDisplayData(void* aStartStruct,
                        const nsRuleDataStruct& aData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeVisibilityData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeVisibilityData(void* aStartStruct,
                           const nsRuleDataStruct& aData,
                           nsStyleContext* aContext, nsRuleNode* aHighestNode,
                           RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeFontData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeFontData(void* aStartStruct,
                     const nsRuleDataStruct& aData,
                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
                     RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeColorData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeColorData(void* aStartStruct,
                      const nsRuleDataStruct& aData,
                      nsStyleContext* aContext, nsRuleNode* aHighestNode,
                      RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeBackgroundData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeBackgroundData(void* aStartStruct,
                           const nsRuleDataStruct& aData, 
                           nsStyleContext* aContext, nsRuleNode* aHighestNode,
                           RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeMarginData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeMarginData(void* aStartStruct,
                       const nsRuleDataStruct& aData, 
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeBorderData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeBorderData(void* aStartStruct,
                       const nsRuleDataStruct& aData, 
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputePaddingData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputePaddingData(void* aStartStruct,
                        const nsRuleDataStruct& aData, 
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeOutlineData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeOutlineData(void* aStartStruct,
                        const nsRuleDataStruct& aData, 
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeListData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeListData(void* aStartStruct,
                     const nsRuleDataStruct& aData,
                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
                     RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputePositionData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputePositionData(void* aStartStruct,
                         const nsRuleDataStruct& aData, 
                         nsStyleContext* aContext, nsRuleNode* aHighestNode,
                         RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeTableData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeTableData(void* aStartStruct,
                      const nsRuleDataStruct& aData, 
                      nsStyleContext* aContext, nsRuleNode* aHighestNode,
                      RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeTableBorderData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeTableBorderData(void* aStartStruct,
                            const nsRuleDataStruct& aData, 
                            nsStyleContext* aContext, nsRuleNode* aHighestNode,
                            RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeContentData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeContentData(void* aStartStruct,
                        const nsRuleDataStruct& aData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeQuotesData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeQuotesData(void* aStartStruct,
                       const nsRuleDataStruct& aData, 
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeTextData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeTextData(void* aStartStruct,
                     const nsRuleDataStruct& aData, 
                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
                     RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeTextResetData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeTextResetData(void* aStartStruct,
                          const nsRuleDataStruct& aData,
                          nsStyleContext* aContext, nsRuleNode* aHighestNode,
                          RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeUserInterfaceData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeUserInterfaceData(void* aStartStruct,
                              const nsRuleDataStruct& aData, 
                              nsStyleContext* aContext,
                              nsRuleNode* aHighestNode,
                              RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeUIResetData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeUIResetData(void* aStartStruct,
                        const nsRuleDataStruct& aData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeXULData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeXULData(void* aStartStruct,
                    const nsRuleDataStruct& aData, 
                    nsStyleContext* aContext, nsRuleNode* aHighestNode,
                    RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeColumnData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeColumnData(void* aStartStruct,
                       const nsRuleDataStruct& aData,
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail, PRBool aInherited);
 
 #ifdef MOZ_SVG
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeSVGData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeSVGData(void* aStartStruct,
                    const nsRuleDataStruct& aData, 
                    nsStyleContext* aContext, nsRuleNode* aHighestNode,
                    RuleDetail aRuleDetail, PRBool aInherited);
 
-  NS_HIDDEN_(const nsStyleStruct*)
-    ComputeSVGResetData(nsStyleStruct* aStartStruct,
+  NS_HIDDEN_(const void*)
+    ComputeSVGResetData(void* aStartStruct,
                         const nsRuleDataStruct& aData, 
                         nsStyleContext* aContext, nsRuleNode* aHighestNode,
                         RuleDetail aRuleDetail, PRBool aInherited);
 #endif
 
   // helpers for |ComputeFontData| that need access to |mNoneBits|:
   static NS_HIDDEN_(void) SetFontSize(nsPresContext* aPresContext,
                                       const nsRuleDataFont& aFontData,
@@ -632,50 +632,48 @@ protected:
                                         const nsCSSValue& aLTRLogicalValue,
                                         const nsCSSValue& aRTLLogicalValue,
                                         PRUint8 aSide,
                                         nsCSSRect& aValueRect,
                                         PRBool& aInherited);
 
   inline RuleDetail CheckSpecifiedProperties(const nsStyleStructID aSID, const nsRuleDataStruct& aRuleDataStruct);
 
-  NS_HIDDEN_(const nsStyleStruct*) GetParentData(const nsStyleStructID aSID);
+  NS_HIDDEN_(const void*) GetParentData(const nsStyleStructID aSID);
   #define STYLE_STRUCT(name_, checkdata_cb_, ctor_args_)  \
     NS_HIDDEN_(const nsStyle##name_*) GetParent##name_();
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT  
 
-  NS_HIDDEN_(const nsStyleStruct*) GetDisplayData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetVisibilityData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetFontData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetColorData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetBackgroundData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetMarginData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetBorderData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetPaddingData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetOutlineData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetListData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetPositionData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetTableData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*)
-    GetTableBorderData(nsStyleContext* aContext);
+  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);
 
-  NS_HIDDEN_(const nsStyleStruct*) GetContentData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetQuotesData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetTextData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetTextResetData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*)
-    GetUserInterfaceData(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);
 
-  NS_HIDDEN_(const nsStyleStruct*) GetUIResetData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetXULData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetColumnData(nsStyleContext* aContext);
+  NS_HIDDEN_(const void*) GetUIResetData(nsStyleContext* aContext);
+  NS_HIDDEN_(const void*) GetXULData(nsStyleContext* aContext);
+  NS_HIDDEN_(const void*) GetColumnData(nsStyleContext* aContext);
 #ifdef MOZ_SVG
-  NS_HIDDEN_(const nsStyleStruct*) GetSVGData(nsStyleContext* aContext);
-  NS_HIDDEN_(const nsStyleStruct*) GetSVGResetData(nsStyleContext* aContext);
+  NS_HIDDEN_(const void*) GetSVGData(nsStyleContext* aContext);
+  NS_HIDDEN_(const void*) GetSVGResetData(nsStyleContext* aContext);
 #endif
 
 private:
   nsRuleNode(nsPresContext* aPresContext, nsRuleNode* aParent,
              nsIStyleRule* aRule, PRUint8 aLevel, PRBool aIsImportant)
     NS_HIDDEN;
   ~nsRuleNode() NS_HIDDEN;
 
@@ -698,19 +696,19 @@ 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 nsStyleStruct*) GetStyleData(nsStyleStructID aSID, 
-                                                nsStyleContext* aContext,
-                                                PRBool aComputeData);
+  NS_HIDDEN_(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);
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT  
 
--- a/layout/style/nsStyleContext.cpp
+++ b/layout/style/nsStyleContext.cpp
@@ -209,19 +209,19 @@ PRBool nsStyleContext::Equals(const nsSt
       result = PR_FALSE;
     }
   }
   return result;
 }
 
 //=========================================================================================================
 
-const nsStyleStruct* nsStyleContext::GetStyleData(nsStyleStructID aSID)
+const void* nsStyleContext::GetStyleData(nsStyleStructID aSID)
 {
-  const nsStyleStruct* cachedData = mCachedStyleData.GetStyleData(aSID); 
+  const void* cachedData = mCachedStyleData.GetStyleData(aSID); 
   if (cachedData)
     return cachedData; // We have computed data stored on this node in the context tree.
   return mRuleNode->GetStyleData(aSID, this, PR_TRUE); // Our rule node will take care of it for us.
 }
 
 #define STYLE_STRUCT(name_, checkdata_cb_, ctor_args_)                      \
   const nsStyle##name_ * nsStyleContext::GetStyle##name_ ()                 \
   {                                                                         \
@@ -230,42 +230,42 @@ const nsStyleStruct* nsStyleContext::Get
       return cachedData; /* We have computed data stored on this node */    \
                          /* in the context tree. */                         \
     /* Else our rule node will take care of it for us. */                   \
     return mRuleNode->GetStyle##name_(this, PR_TRUE);                       \
   }
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 
-inline const nsStyleStruct* nsStyleContext::PeekStyleData(nsStyleStructID aSID)
+inline const void* nsStyleContext::PeekStyleData(nsStyleStructID aSID)
 {
-  const nsStyleStruct* cachedData = mCachedStyleData.GetStyleData(aSID); 
+  const void* cachedData = mCachedStyleData.GetStyleData(aSID); 
   if (cachedData)
     return cachedData; // We have computed data stored on this node in the context tree.
   return mRuleNode->GetStyleData(aSID, this, PR_FALSE); // Our rule node will take care of it for us.
 }
 
 // This is an evil evil function, since it forces you to alloc your own separate copy of
 // style data!  Do not use this function unless you absolutely have to!  You should avoid
 // this at all costs! -dwh
-nsStyleStruct* 
+void* 
 nsStyleContext::GetUniqueStyleData(const nsStyleStructID& aSID)
 {
   // If we already own the struct and no kids could depend on it, then
   // just return it.  (We leak in this case if there are kids -- and this
   // function really shouldn't be called for style contexts that could
   // have kids depending on the data.  ClearStyleData would be OK, but
   // this test for no mChild or mEmptyChild doesn't catch that case.)
-  const nsStyleStruct *current = GetStyleData(aSID);
+  const void *current = GetStyleData(aSID);
   if (!mChild && !mEmptyChild &&
       !(mBits & nsCachedStyleData::GetBitForSID(aSID)) &&
       mCachedStyleData.GetStyleData(aSID))
-    return const_cast<nsStyleStruct*>(current);
+    return const_cast<void*>(current);
 
-  nsStyleStruct* result;
+  void* result;
   nsPresContext *presContext = PresContext();
   switch (aSID) {
 
 #define UNIQUE_CASE(c_)                                                       \
   case eStyleStruct_##c_:                                                     \
     result = new (presContext) nsStyle##c_(                                   \
       * static_cast<const nsStyle##c_ *>(current));                           \
     break;
@@ -278,29 +278,29 @@ nsStyleContext::GetUniqueStyleData(const
 #undef UNIQUE_CASE
 
   default:
     NS_ERROR("Struct type not supported.  Please find another way to do this if you can!\n");
     return nsnull;
   }
 
   if (!result) {
-    NS_WARNING("Ran out of memory while trying to allocate memory for a unique nsStyleStruct! "
+    NS_WARNING("Ran out of memory while trying to allocate memory for a unique style struct! "
                "Returning the non-unique data.");
-    return const_cast<nsStyleStruct*>(current);
+    return const_cast<void*>(current);
   }
 
   SetStyle(aSID, result);
   mBits &= ~nsCachedStyleData::GetBitForSID(aSID);
 
   return result;
 }
 
 void
-nsStyleContext::SetStyle(nsStyleStructID aSID, nsStyleStruct* aStruct)
+nsStyleContext::SetStyle(nsStyleStructID aSID, void* aStruct)
 {
   // This method should only be called from nsRuleNode!  It is not a public
   // method!
   
   NS_ASSERTION(aSID >= 0 && aSID < nsStyleStructID_Length, "out of bounds");
 
   // NOTE:  nsCachedStyleData::GetStyleData works roughly the same way.
   // See the comments there (in nsRuleNode.h) for more details about
@@ -320,17 +320,17 @@ nsStyleContext::SetStyle(nsStyleStructID
     } else {
       mCachedStyleData.mInheritedData =
           new (presContext) nsInheritedStyleData;
       resetOrInherit =
           reinterpret_cast<char*>(mCachedStyleData.mInheritedData);
     }
   }
   char* dataSlot = resetOrInherit + info.mInheritResetOffset;
-  *reinterpret_cast<nsStyleStruct**>(dataSlot) = aStruct;
+  *reinterpret_cast<void**>(dataSlot) = aStruct;
 }
 
 void
 nsStyleContext::ApplyStyleFixups(nsPresContext* aPresContext)
 {
   // See if we have any text decorations.
   // First see if our parent has text decorations.  If our parent does, then we inherit the bit.
   if (mParent && mParent->HasTextDecorations())
--- a/layout/style/nsStyleContext.h
+++ b/layout/style/nsStyleContext.h
@@ -104,17 +104,17 @@ public:
   nsIAtom* GetPseudoType() const { return mPseudoTag; }
 
   NS_HIDDEN_(already_AddRefed<nsStyleContext>)
   FindChildWithRules(const nsIAtom* aPseudoTag, nsRuleNode* aRules);
 
   NS_HIDDEN_(PRBool)    Equals(const nsStyleContext* aOther) const;
   PRBool    HasTextDecorations() { return !!(mBits & NS_STYLE_HAS_TEXT_DECORATIONS); }
 
-  NS_HIDDEN_(void) SetStyle(nsStyleStructID aSID, nsStyleStruct* aStruct);
+  NS_HIDDEN_(void) SetStyle(nsStyleStructID aSID, void* aStruct);
 
   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.
    */
@@ -129,39 +129,36 @@ public:
    * modified.
    *
    * 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.
-   *
-   * See also |nsIFrame::GetStyleData| and the other global
-   * |GetStyleData| in nsIFrame.h.
    */
-  NS_HIDDEN_(const nsStyleStruct*) NS_FASTCALL GetStyleData(nsStyleStructID aSID);
+  NS_HIDDEN_(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();
    */
 
   #define STYLE_STRUCT(name_, checkdata_cb_, ctor_args_)                      \
     NS_HIDDEN_(const nsStyle##name_ *) NS_FASTCALL GetStyle##name_();
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT
 
 
-  NS_HIDDEN_(const nsStyleStruct*) PeekStyleData(nsStyleStructID aSID);
+  NS_HIDDEN_(const void*) PeekStyleData(nsStyleStructID aSID);
 
-  NS_HIDDEN_(nsStyleStruct*) GetUniqueStyleData(const nsStyleStructID& aSID);
+  NS_HIDDEN_(void*) GetUniqueStyleData(const nsStyleStructID& aSID);
 
   NS_HIDDEN_(nsChangeHint) CalcStyleDifference(nsStyleContext* aOther);
 
 #ifdef DEBUG
   NS_HIDDEN_(void) DumpRegressionData(nsPresContext* aPresContext, FILE* out,
                                       PRInt32 aIndent);
 
   NS_HIDDEN_(void) List(FILE* out, PRInt32 aIndent);
--- a/layout/style/nsStyleStruct.h
+++ b/layout/style/nsStyleStruct.h
@@ -77,23 +77,19 @@ class imgIRequest;
 #define NS_STYLE_HAS_TEXT_DECORATIONS     0x01000000
 
 // Additional bits for nsRuleNode's mDependentBits:
 #define NS_RULE_NODE_GC_MARK              0x02000000
 #define NS_RULE_NODE_IS_IMPORTANT         0x08000000
 #define NS_RULE_NODE_LEVEL_MASK           0xf0000000
 #define NS_RULE_NODE_LEVEL_SHIFT          28
 
-// The actual structs start here
-struct nsStyleStruct {
-};
-
 // The lifetime of these objects is managed by the presshell's arena.
 
-struct nsStyleFont : public nsStyleStruct {
+struct nsStyleFont {
   nsStyleFont(const nsFont& aFont, nsPresContext *aPresContext);
   nsStyleFont(const nsStyleFont& aStyleFont);
   nsStyleFont(nsPresContext *aPresContext);
   ~nsStyleFont(void) {}
 
   nsChangeHint CalcDifference(const nsStyleFont& aOther) const;
 #ifdef DEBUG
   static nsChangeHint MaxDifference();
@@ -118,17 +114,17 @@ struct nsStyleFont : public nsStyleStruc
   PRInt8  mScriptLevel;          // [inherited]
   // The value mSize would have had if scriptminsize had never been applied
   nscoord mScriptUnconstrainedSize;
   nscoord mScriptMinSize;        // [inherited] length
   float   mScriptSizeMultiplier; // [inherited]
 #endif
 };
 
-struct nsStyleColor : public nsStyleStruct {
+struct nsStyleColor {
   nsStyleColor(nsPresContext* aPresContext);
   nsStyleColor(const nsStyleColor& aOther);
   ~nsStyleColor(void) {}
 
   nsChangeHint CalcDifference(const nsStyleColor& aOther) const;
 #ifdef DEBUG
   static nsChangeHint MaxDifference();
 #endif
@@ -141,17 +137,17 @@ struct nsStyleColor : public nsStyleStru
     aContext->FreeToShell(sizeof(nsStyleColor), this);
   }
 
   // Don't add ANY members to this struct!  We can achieve caching in the rule
   // tree (rather than the style tree) by letting color stay by itself! -dwh
   nscolor mColor;                 // [inherited]
 };
 
-struct nsStyleBackground : public nsStyleStruct {
+struct nsStyleBackground {
   nsStyleBackground(nsPresContext* aPresContext);
   nsStyleBackground(const nsStyleBackground& aOther);
   ~nsStyleBackground();
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -206,17 +202,17 @@ struct nsStyleBackground : public nsStyl
 #define BORDER_COLOR_SPECIAL      0xE0
 #define BORDER_STYLE_MASK         0x1F
 
 #define NS_SPACING_MARGIN   0
 #define NS_SPACING_PADDING  1
 #define NS_SPACING_BORDER   2
 
 
-struct nsStyleMargin: public nsStyleStruct {
+struct nsStyleMargin {
   nsStyleMargin(void);
   nsStyleMargin(const nsStyleMargin& aMargin);
   ~nsStyleMargin(void) {}
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW;
   void Destroy(nsPresContext* aContext);
 
   void RecalcData();
@@ -237,17 +233,17 @@ struct nsStyleMargin: public nsStyleStru
   }
 
 protected:
   PRPackedBool  mHasCachedMargin;
   nsMargin      mCachedMargin;
 };
 
 
-struct nsStylePadding: public nsStyleStruct {
+struct nsStylePadding {
   nsStylePadding(void);
   nsStylePadding(const nsStylePadding& aPadding);
   ~nsStylePadding(void) {}
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW;
   void Destroy(nsPresContext* aContext);
 
   void RecalcData();
@@ -317,17 +313,17 @@ struct nsBorderColors {
 // Outline offset is rounded to the nearest integer number of pixels, but values
 // between zero and one device pixels are always rounded up to one device pixel.
 // Note that the offset can be negative.
 #define NS_ROUND_OFFSET_TO_PIXELS(l,tpp) \
   (((l) == 0) ? 0 : \
     ((l) > 0) ? PR_MAX( (tpp), ((l) + ((tpp) / 2)) / (tpp) * (tpp)) : \
                 PR_MIN(-(tpp), ((l) - ((tpp) / 2)) / (tpp) * (tpp)))
 
-struct nsStyleBorder: public nsStyleStruct {
+struct nsStyleBorder {
   nsStyleBorder(nsPresContext* aContext);
   nsStyleBorder(const nsStyleBorder& aBorder);
   ~nsStyleBorder(void) {
     if (mBorderColors) {
       for (PRInt32 i = 0; i < 4; i++)
         delete mBorderColors[i];
       delete []mBorderColors;
     }
@@ -498,17 +494,17 @@ protected:
   PRUint8       mBorderStyle[4];  // [reset] See nsStyleConsts.h
   nscolor       mBorderColor[4];  // [reset] the colors to use for a simple border.  not used
                                   // if -moz-border-colors is specified
 
   nscoord       mTwipsPerPixel;
 };
 
 
-struct nsStyleOutline: public nsStyleStruct {
+struct nsStyleOutline {
   nsStyleOutline(nsPresContext* aPresContext);
   nsStyleOutline(const nsStyleOutline& aOutline);
   ~nsStyleOutline(void) {}
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -599,17 +595,17 @@ protected:
 
   PRPackedBool  mHasCachedOutline;
   PRUint8       mOutlineStyle;    // [reset] See nsStyleConsts.h
 
   nscoord       mTwipsPerPixel;
 };
 
 
-struct nsStyleList : public nsStyleStruct {
+struct nsStyleList {
   nsStyleList(void);
   nsStyleList(const nsStyleList& aStyleList);
   ~nsStyleList(void);
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -623,17 +619,17 @@ struct nsStyleList : public nsStyleStruc
 #endif
   
   PRUint8   mListStyleType;             // [inherited] See nsStyleConsts.h
   PRUint8   mListStylePosition;         // [inherited] 
   nsCOMPtr<imgIRequest> mListStyleImage; // [inherited]
   nsRect        mImageRegion;           // [inherited] the rect to use within an image  
 };
 
-struct nsStylePosition : public nsStyleStruct {
+struct nsStylePosition {
   nsStylePosition(void);
   nsStylePosition(const nsStylePosition& aOther);
   ~nsStylePosition(void);
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -652,17 +648,17 @@ struct nsStylePosition : public nsStyleS
   nsStyleCoord  mMaxWidth;              // [reset] coord, percent, null, enum
   nsStyleCoord  mHeight;                // [reset] coord, percent, auto
   nsStyleCoord  mMinHeight;             // [reset] coord, percent
   nsStyleCoord  mMaxHeight;             // [reset] coord, percent, null
   PRUint8       mBoxSizing;             // [reset] see nsStyleConsts.h
   nsStyleCoord  mZIndex;                // [reset] 
 };
 
-struct nsStyleTextReset : public nsStyleStruct {
+struct nsStyleTextReset {
   nsStyleTextReset(void);
   nsStyleTextReset(const nsStyleTextReset& aOther);
   ~nsStyleTextReset(void);
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -676,17 +672,17 @@ struct nsStyleTextReset : public nsStyle
 #endif
   
   PRUint8 mTextDecoration;              // [reset] see nsStyleConsts.h
   PRUint8 mUnicodeBidi;                 // [reset] see nsStyleConsts.h
 
   nsStyleCoord  mVerticalAlign;         // [reset] see nsStyleConsts.h for enums
 };
 
-struct nsStyleText : public nsStyleStruct {
+struct nsStyleText {
   nsStyleText(void);
   nsStyleText(const nsStyleText& aOther);
   ~nsStyleText(void);
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -714,17 +710,17 @@ struct nsStyleText : public nsStyleStruc
   }
 
   PRBool WhiteSpaceCanWrap() const {
     return mWhiteSpace == NS_STYLE_WHITESPACE_NORMAL ||
            mWhiteSpace == NS_STYLE_WHITESPACE_MOZ_PRE_WRAP;
   }
 };
 
-struct nsStyleVisibility : public nsStyleStruct {
+struct nsStyleVisibility {
   nsStyleVisibility(nsPresContext* aPresContext);
   nsStyleVisibility(const nsStyleVisibility& aVisibility);
   ~nsStyleVisibility() {}
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -746,17 +742,17 @@ struct nsStyleVisibility : public nsStyl
 	}
 
 	PRBool IsVisibleOrCollapsed() const {
 		return ((mVisible == NS_STYLE_VISIBILITY_VISIBLE) ||
 						(mVisible == NS_STYLE_VISIBILITY_COLLAPSE));
 	}
 };
 
-struct nsStyleDisplay : public nsStyleStruct {
+struct nsStyleDisplay {
   nsStyleDisplay();
   nsStyleDisplay(const nsStyleDisplay& aOther); 
   ~nsStyleDisplay() {}
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -838,17 +834,17 @@ struct nsStyleDisplay : public nsStyleSt
   // support 'overflow: hidden' to mean 'overflow: -moz-hidden-unscrollable'.
   PRBool IsTableClip() const {
     return mOverflowX == NS_STYLE_OVERFLOW_CLIP ||
            (mOverflowX == NS_STYLE_OVERFLOW_HIDDEN &&
             mOverflowY == NS_STYLE_OVERFLOW_HIDDEN);
   }
 };
 
-struct nsStyleTable: public nsStyleStruct {
+struct nsStyleTable {
   nsStyleTable(void);
   nsStyleTable(const nsStyleTable& aOther);
   ~nsStyleTable(void);
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -863,17 +859,17 @@ struct nsStyleTable: public nsStyleStruc
   
   PRUint8       mLayoutStrategy;// [reset] see nsStyleConsts.h NS_STYLE_TABLE_LAYOUT_*
   PRUint8       mFrame;         // [reset] see nsStyleConsts.h NS_STYLE_TABLE_FRAME_*
   PRUint8       mRules;         // [reset] see nsStyleConsts.h NS_STYLE_TABLE_RULES_*
   PRInt32       mCols;          // [reset] an integer if set, or see nsStyleConsts.h NS_STYLE_TABLE_COLS_*
   PRInt32       mSpan;          // [reset] the number of columns spanned by a colgroup or col
 };
 
-struct nsStyleTableBorder: public nsStyleStruct {
+struct nsStyleTableBorder {
   nsStyleTableBorder(nsPresContext* aContext);
   nsStyleTableBorder(const nsStyleTableBorder& aOther);
   ~nsStyleTableBorder(void);
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -929,17 +925,17 @@ private:
 struct nsStyleCounterData {
   nsString  mCounter;
   PRInt32   mValue;
 };
 
 
 #define DELETE_ARRAY_IF(array)  if (array) { delete[] array; array = nsnull; }
 
-struct nsStyleQuotes : public nsStyleStruct {
+struct nsStyleQuotes {
   nsStyleQuotes();
   nsStyleQuotes(const nsStyleQuotes& aQuotes);
   ~nsStyleQuotes();
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -999,17 +995,17 @@ struct nsStyleQuotes : public nsStyleStr
     return NS_ERROR_ILLEGAL_VALUE;
   }
 
 protected:
   PRUint32            mQuotesCount;
   nsString*           mQuotes;
 };
 
-struct nsStyleContent: public nsStyleStruct {
+struct nsStyleContent {
   nsStyleContent(void);
   nsStyleContent(const nsStyleContent& aContent);
   ~nsStyleContent(void);
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -1104,17 +1100,17 @@ protected:
 
   PRUint32            mIncrementCount;
   nsStyleCounterData* mIncrements;
 
   PRUint32            mResetCount;
   nsStyleCounterData* mResets;
 };
 
-struct nsStyleUIReset: public nsStyleStruct {
+struct nsStyleUIReset {
   nsStyleUIReset(void);
   nsStyleUIReset(const nsStyleUIReset& aOther);
   ~nsStyleUIReset(void);
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -1135,17 +1131,17 @@ struct nsStyleUIReset: public nsStyleStr
 struct nsCursorImage {
   nsCOMPtr<imgIRequest> mImage;
   PRBool mHaveHotspot;
   float mHotspotX, mHotspotY;
 
   nsCursorImage();
 };
 
-struct nsStyleUserInterface: public nsStyleStruct {
+struct nsStyleUserInterface {
   nsStyleUserInterface(void);
   nsStyleUserInterface(const nsStyleUserInterface& aOther);
   ~nsStyleUserInterface(void);
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -1170,17 +1166,17 @@ struct nsStyleUserInterface: public nsSt
                               //   mCursor.  Zero-length array is represented
                               //   by null pointer.
 
   // Does not free mCursorArray; the caller is responsible for calling
   // |delete [] mCursorArray| first if it is needed.
   void CopyCursorArrayFrom(const nsStyleUserInterface& aSource);
 };
 
-struct nsStyleXUL : public nsStyleStruct {
+struct nsStyleXUL {
   nsStyleXUL();
   nsStyleXUL(const nsStyleXUL& aSource);
   ~nsStyleXUL();
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -1196,17 +1192,17 @@ struct nsStyleXUL : public nsStyleStruct
   float         mBoxFlex;               // [reset] see nsStyleConsts.h
   PRUint32      mBoxOrdinal;            // [reset] see nsStyleConsts.h
   PRUint8       mBoxAlign;              // [reset] see nsStyleConsts.h
   PRUint8       mBoxDirection;          // [reset] see nsStyleConsts.h
   PRUint8       mBoxOrient;             // [reset] see nsStyleConsts.h
   PRUint8       mBoxPack;               // [reset] see nsStyleConsts.h
 };
 
-struct nsStyleColumn : public nsStyleStruct {
+struct nsStyleColumn {
   nsStyleColumn();
   nsStyleColumn(const nsStyleColumn& aSource);
   ~nsStyleColumn();
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -1246,17 +1242,17 @@ struct nsStyleSVGPaint
   nsStyleSVGPaint& operator=(const nsStyleSVGPaint& aOther);
   PRBool operator==(const nsStyleSVGPaint& aOther) const; 
 
   PRBool operator!=(const nsStyleSVGPaint& aOther) const {
     return !(*this == aOther);
   }
 };
 
-struct nsStyleSVG : public nsStyleStruct {
+struct nsStyleSVG {
   nsStyleSVG();
   nsStyleSVG(const nsStyleSVG& aSource);
   ~nsStyleSVG();
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
@@ -1291,17 +1287,17 @@ struct nsStyleSVG : public nsStyleStruct
   PRUint8          mPointerEvents;    // [inherited] see nsStyleConsts.h
   PRUint8          mShapeRendering;   // [inherited] see nsStyleConsts.h
   PRUint8          mStrokeLinecap;    // [inherited] see nsStyleConsts.h
   PRUint8          mStrokeLinejoin;   // [inherited] see nsStyleConsts.h
   PRUint8          mTextAnchor;       // [inherited] see nsStyleConsts.h
   PRUint8          mTextRendering;    // [inherited] see nsStyleConsts.h
 };
 
-struct nsStyleSVGReset : public nsStyleStruct {
+struct nsStyleSVGReset {
   nsStyleSVGReset();
   nsStyleSVGReset(const nsStyleSVGReset& aSource);
   ~nsStyleSVGReset();
 
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(sz);
   }
   void Destroy(nsPresContext* aContext) {
--- a/layout/style/nsStyleStructFwd.h
+++ b/layout/style/nsStyleStructFwd.h
@@ -55,14 +55,12 @@ enum nsStyleStructID {
 #define STYLE_STRUCT(name, checkdata_cb, ctor_args) eStyleStruct_##name,
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 
 nsStyleStructID_Length /* one past the end; length of 0-based list */
 
 };
 
-struct nsStyleStruct;
-
 // A bit corresponding to each struct ID
 #define NS_STYLE_INHERIT_BIT(sid_)        (1 << PRInt32(eStyleStruct_##sid_))
 
 #endif /* nsStyleStructFwd_h_ */
--- a/layout/style/test/test_style_struct_copy_constructors.html
+++ b/layout/style/test/test_style_struct_copy_constructors.html
@@ -1,14 +1,14 @@
 <!DOCTYPE HTML>
 <html>
 <!--
 -->
 <head>
-  <title>Test for nsStyleStruct copy constructors</title>
+  <title>Test for style struct copy constructors</title>
   <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
   <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
   <script type="text/javascript" src="property_database.js"></script>
   <style type="text/css" id="stylesheet"></style>
   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
 </head>
 <body>
 <p id="display"><span id="one"></span><span id="two"></span><span id="parent"><span id="child"></span></span></p>
@@ -16,17 +16,17 @@
 
 <div id="testnode"><span id="element"></span></div>
 
   
 </div>
 <pre id="test">
 <script class="testbody" type="text/javascript">
 
-/** Test for nsStyleStruct copy constructors **/
+/** Test for style struct copy constructors **/
 
 /**
  * XXX Why doesn't putting a bug in the nsStyleFont copy-constructor for
  * font-weight (initializing to normal) trigger a failure of this test?
  * It works for leaving -moz-image-region uninitialized (both halves),
  * overwriting text-decoration (only the first half, since it's not
  * inherited), and leaving visibility uninitialized (only the second
  * half; passes the first half ok).