Bug 334571 Coverity 702, NS_SIDES array limit check - replace NS_FOR_CSS_SIDES defines with enum. r=zwol,mats
authortimeless
Tue, 27 Apr 2010 18:15:02 +0200
changeset 41419 51954c20c9f7f209df0f78d3b8bc2bbbfff4958c
parent 41418 7aac8fafc4de6924e3926e8db07af115f0c4c229
child 41420 d83245839ca627ebfc9480562a072a2b1f6b3686
push id13008
push usermpalmgren@mozilla.com
push dateTue, 27 Apr 2010 16:26:15 +0000
treeherdermozilla-central@8102627c8c62 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerszwol, mats
bugs334571
milestone1.9.3a5pre
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
Bug 334571 Coverity 702, NS_SIDES array limit check - replace NS_FOR_CSS_SIDES defines with enum. r=zwol,mats
gfx/public/gfxCore.h
gfx/public/nsMargin.h
gfx/src/nsRect.cpp
gfx/thebes/public/gfxRect.h
gfx/thebes/src/gfxContext.cpp
layout/base/nsCSSRendering.cpp
layout/base/nsCSSRenderingBorders.cpp
layout/base/nsCSSRenderingBorders.h
layout/base/nsLayoutUtils.cpp
layout/base/nsLayoutUtils.h
layout/base/nsStyleConsts.h
layout/generic/nsContainerFrame.cpp
layout/style/nsCSSStruct.cpp
layout/style/nsComputedDOMStyle.cpp
layout/style/nsComputedDOMStyle.h
layout/style/nsRuleNode.cpp
layout/style/nsRuleNode.h
layout/style/nsStyleAnimation.cpp
layout/style/nsStyleCoord.h
layout/style/nsStyleStruct.h
layout/tables/celldata.h
layout/tables/nsCellMap.cpp
layout/tables/nsCellMap.h
layout/tables/nsTableCellFrame.cpp
layout/tables/nsTableCellFrame.h
layout/tables/nsTableFrame.cpp
--- a/gfx/public/gfxCore.h
+++ b/gfx/public/gfxCore.h
@@ -36,20 +36,25 @@
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef gfxCore_h__
 #define gfxCore_h__
 
 #include "nscore.h"
 
 // Side constants for use in various places
-#define NS_SIDE_TOP     0
-#define NS_SIDE_RIGHT   1
-#define NS_SIDE_BOTTOM  2
-#define NS_SIDE_LEFT    3
+namespace mozilla {
+  namespace css {
+    enum Side {eSideTop, eSideRight, eSideBottom, eSideLeft};
+  }
+}
+#define NS_SIDE_TOP     mozilla::css::eSideTop
+#define NS_SIDE_RIGHT   mozilla::css::eSideRight
+#define NS_SIDE_BOTTOM  mozilla::css::eSideBottom
+#define NS_SIDE_LEFT    mozilla::css::eSideLeft
 
 #if defined(MOZ_ENABLE_LIBXUL) || !defined(MOZILLA_INTERNAL_API)
 #  define NS_GFX
 #  define NS_GFX_(type) type
 #  define NS_GFX_STATIC_MEMBER_(type) type
 #elif defined(_IMPL_NS_GFX)
 #  define NS_GFX NS_EXPORT
 #  define NS_GFX_(type) NS_EXPORT_(type)
--- a/gfx/public/nsMargin.h
+++ b/gfx/public/nsMargin.h
@@ -59,29 +59,25 @@ struct nsMargin {
               nscoord aRight, nscoord aBottom) {left += aLeft; top += aTop;
                                                 right += aRight; bottom += aBottom;}
 
   nscoord LeftRight() const { return left + right; }
   nscoord TopBottom() const { return top + bottom; }
 
   nsPoint TopLeft() const { return nsPoint(left, top); }
 
-#if (NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3)
-  nscoord& side(PRUint8 aSide) {
+  nscoord& side(mozilla::css::Side aSide) {
     NS_PRECONDITION(aSide <= NS_SIDE_LEFT, "Out of range side");
     return *(&top + aSide);
   }
 
-  nscoord side(PRUint8 aSide) const {
+  nscoord side(mozilla::css::Side aSide) const {
     NS_PRECONDITION(aSide <= NS_SIDE_LEFT, "Out of range side");
     return *(&top + aSide);
   }
-#else
-#error "Somebody changed the side constants."
-#endif
 
   // Overloaded operators. Note that '=' isn't defined so we'll get the
   // compiler generated default assignment operator
   PRBool operator==(const nsMargin& aMargin) const {
     return (PRBool) ((left == aMargin.left) && (top == aMargin.top) &&
                      (right == aMargin.right) && (bottom == aMargin.bottom));
   }
   PRBool operator!=(const nsMargin& aMargin) const {
@@ -123,22 +119,22 @@ struct nsIntMargin {
               PRInt32 aRight, PRInt32 aBottom) {left = aLeft; top = aTop;
                                                 right = aRight; bottom = aBottom;}
 
   PRInt32 LeftRight() const { return left + right; }
   PRInt32 TopBottom() const { return top + bottom; }
 
   nsPoint TopLeft() const { return nsPoint(left, top); }
 
-  PRInt32& side(PRUint8 aSide) {
+  PRInt32& side(mozilla::css::Side aSide) {
     NS_PRECONDITION(aSide <= NS_SIDE_LEFT, "Out of range side");
     return *(&top + aSide);
   }
 
-  PRInt32 side(PRUint8 aSide) const {
+  PRInt32 side(mozilla::css::Side aSide) const {
     NS_PRECONDITION(aSide <= NS_SIDE_LEFT, "Out of range side");
     return *(&top + aSide);
   }
 
   PRBool operator!=(const nsIntMargin& aMargin) const {
     return (PRBool) ((left != aMargin.left) || (top != aMargin.top) ||
                      (right != aMargin.right) || (bottom != aMargin.bottom));
   }
--- a/gfx/src/nsRect.cpp
+++ b/gfx/src/nsRect.cpp
@@ -33,16 +33,20 @@
  * 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 ***** */
 
 #include "nsRect.h"
 #include "nsString.h"
 #include "nsIDeviceContext.h"
+#include "prlog.h"
+
+// the mozilla::css::Side sequence must match the nsMargin nscoord sequence
+PR_STATIC_ASSERT((NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3));
 
 // Containment
 PRBool nsRect::Contains(nscoord aX, nscoord aY) const
 {
   return (PRBool) ((aX >= x) && (aY >= y) &&
                    (aX < XMost()) && (aY < YMost()));
 }
 
--- a/gfx/thebes/public/gfxRect.h
+++ b/gfx/thebes/public/gfxRect.h
@@ -35,30 +35,47 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef GFX_RECT_H
 #define GFX_RECT_H
 
 #include "gfxTypes.h"
 #include "gfxPoint.h"
+#include "gfxCore.h"
 #include "nsDebug.h" 
 
-struct THEBES_API gfxCorner {
-    typedef int Corner;
-    enum {
-        // this order is important!
-        TOP_LEFT = 0,
-        TOP_RIGHT = 1,
-        BOTTOM_RIGHT = 2,
-        BOTTOM_LEFT = 3,
-        NUM_CORNERS = 4
-    };
-};
+namespace mozilla {
+    namespace css {
+        enum Corner {
+            // this order is important!
+            eCornerTopLeft = 0,
+            eCornerTopRight = 1,
+            eCornerBottomRight = 2,
+            eCornerBottomLeft = 3,
+            eNumCorners = 4
+        };
+    }
+}
+#define NS_CORNER_TOP_LEFT mozilla::css::eCornerTopLeft
+#define NS_CORNER_TOP_RIGHT mozilla::css::eCornerTopRight
+#define NS_CORNER_BOTTOM_RIGHT mozilla::css::eCornerBottomRight
+#define NS_CORNER_BOTTOM_LEFT mozilla::css::eCornerBottomLeft
+#define NS_NUM_CORNERS mozilla::css::eNumCorners
 
+#define NS_FOR_CSS_CORNERS(var_)                         \
+    for (mozilla::css::Corner var_ = NS_CORNER_TOP_LEFT; \
+         var_ <= NS_CORNER_BOTTOM_LEFT;                  \
+         var_++)
+
+static inline mozilla::css::Corner operator++(mozilla::css::Corner& corner, int) {
+    NS_PRECONDITION(corner < NS_CORNER_TOP_LEFT, "Out of range corner");
+    corner = mozilla::css::Corner(corner + 1);
+    return corner;
+}
 
 struct THEBES_API gfxRect {
     // pt? point?
     gfxPoint pos;
     gfxSize size;
 
     gfxRect() {}
     gfxRect(const gfxRect& s) : pos(s.pos), size(s.size) {}
@@ -159,29 +176,55 @@ struct THEBES_API gfxRect {
     void RoundOut();
 
     // grabbing specific points
     gfxPoint TopLeft() const { return gfxPoint(pos); }
     gfxPoint TopRight() const { return pos + gfxSize(size.width, 0.0); }
     gfxPoint BottomLeft() const { return pos + gfxSize(0.0, size.height); }
     gfxPoint BottomRight() const { return pos + size; }
 
-    gfxPoint Corner(gfxCorner::Corner corner) const {
+    gfxPoint AtCorner(mozilla::css::Corner corner) const {
         switch (corner) {
-            case gfxCorner::TOP_LEFT: return TopLeft();
-            case gfxCorner::TOP_RIGHT: return TopRight();
-            case gfxCorner::BOTTOM_LEFT: return BottomLeft();
-            case gfxCorner::BOTTOM_RIGHT: return BottomRight();
+            case NS_CORNER_TOP_LEFT: return TopLeft();
+            case NS_CORNER_TOP_RIGHT: return TopRight();
+            case NS_CORNER_BOTTOM_RIGHT: return BottomRight();
+            case NS_CORNER_BOTTOM_LEFT: return BottomLeft();
             default:
                 NS_ERROR("Invalid corner!");
                 break;
         }
         return gfxPoint(0.0, 0.0);
     }
 
+    gfxPoint CCWCorner(mozilla::css::Side side) const {
+        switch (side) {
+            case NS_SIDE_TOP: return TopLeft();
+            case NS_SIDE_RIGHT: return TopRight();
+            case NS_SIDE_BOTTOM: return BottomRight();
+            case NS_SIDE_LEFT: return BottomLeft();
+            default:
+                NS_ERROR("Invalid side!");
+                break;
+        }
+        return gfxPoint(0.0, 0.0);
+    }
+
+    gfxPoint CWCorner(mozilla::css::Side side) const {
+        switch (side) {
+            case NS_SIDE_TOP: return TopRight();
+            case NS_SIDE_RIGHT: return BottomRight();
+            case NS_SIDE_BOTTOM: return BottomLeft();
+            case NS_SIDE_LEFT: return TopLeft();
+            default:
+                NS_ERROR("Invalid side!");
+                break;
+        }
+        return gfxPoint(0.0, 0.0);
+    }
+
     /* Conditions this border to Cairo's max coordinate space.
      * The caller can check IsEmpty() after Condition() -- if it's TRUE,
      * the caller can possibly avoid doing any extra rendering.
      */
     void Condition();
 
     void Scale(gfxFloat k) {
         NS_ASSERTION(k >= 0.0, "Invalid (negative) scale factor");
@@ -205,52 +248,52 @@ struct THEBES_API gfxRect {
         pos.x /= k;
         pos.y /= k;
         size.width /= k;
         size.height /= k;
     }
 };
 
 struct THEBES_API gfxCornerSizes {
-    gfxSize sizes[gfxCorner::NUM_CORNERS];
+    gfxSize sizes[NS_NUM_CORNERS];
 
     gfxCornerSizes () { }
 
     gfxCornerSizes (gfxFloat v) {
-        for (int i = 0; i < gfxCorner::NUM_CORNERS; i++)
+        for (int i = 0; i < NS_NUM_CORNERS; i++)
             sizes[i].SizeTo(v, v);
     }
 
     gfxCornerSizes (gfxFloat tl, gfxFloat tr, gfxFloat br, gfxFloat bl) {
-        sizes[gfxCorner::TOP_LEFT].SizeTo(tl, tl);
-        sizes[gfxCorner::TOP_RIGHT].SizeTo(tr, tr);
-        sizes[gfxCorner::BOTTOM_RIGHT].SizeTo(br, br);
-        sizes[gfxCorner::BOTTOM_LEFT].SizeTo(bl, bl);
+        sizes[NS_CORNER_TOP_LEFT].SizeTo(tl, tl);
+        sizes[NS_CORNER_TOP_RIGHT].SizeTo(tr, tr);
+        sizes[NS_CORNER_BOTTOM_RIGHT].SizeTo(br, br);
+        sizes[NS_CORNER_BOTTOM_LEFT].SizeTo(bl, bl);
     }
 
     gfxCornerSizes (const gfxSize& tl, const gfxSize& tr, const gfxSize& br, const gfxSize& bl) {
-        sizes[gfxCorner::TOP_LEFT] = tl;
-        sizes[gfxCorner::TOP_RIGHT] = tr;
-        sizes[gfxCorner::BOTTOM_RIGHT] = br;
-        sizes[gfxCorner::BOTTOM_LEFT] = bl;
+        sizes[NS_CORNER_TOP_LEFT] = tl;
+        sizes[NS_CORNER_TOP_RIGHT] = tr;
+        sizes[NS_CORNER_BOTTOM_RIGHT] = br;
+        sizes[NS_CORNER_BOTTOM_LEFT] = bl;
     }
 
-    const gfxSize& operator[] (gfxCorner::Corner index) const {
+    const gfxSize& operator[] (mozilla::css::Corner index) const {
         return sizes[index];
     }
 
-    gfxSize& operator[] (gfxCorner::Corner index) {
+    gfxSize& operator[] (mozilla::css::Corner index) {
         return sizes[index];
     }
 
-    const gfxSize TopLeft() const { return sizes[gfxCorner::TOP_LEFT]; }
-    gfxSize& TopLeft() { return sizes[gfxCorner::TOP_LEFT]; }
+    const gfxSize TopLeft() const { return sizes[NS_CORNER_TOP_LEFT]; }
+    gfxSize& TopLeft() { return sizes[NS_CORNER_TOP_LEFT]; }
 
-    const gfxSize TopRight() const { return sizes[gfxCorner::TOP_RIGHT]; }
-    gfxSize& TopRight() { return sizes[gfxCorner::TOP_RIGHT]; }
+    const gfxSize TopRight() const { return sizes[NS_CORNER_TOP_RIGHT]; }
+    gfxSize& TopRight() { return sizes[NS_CORNER_TOP_RIGHT]; }
 
-    const gfxSize BottomLeft() const { return sizes[gfxCorner::BOTTOM_LEFT]; }
-    gfxSize& BottomLeft() { return sizes[gfxCorner::BOTTOM_LEFT]; }
+    const gfxSize BottomLeft() const { return sizes[NS_CORNER_BOTTOM_LEFT]; }
+    gfxSize& BottomLeft() { return sizes[NS_CORNER_BOTTOM_LEFT]; }
 
-    const gfxSize BottomRight() const { return sizes[gfxCorner::BOTTOM_RIGHT]; }
-    gfxSize& BottomRight() { return sizes[gfxCorner::BOTTOM_RIGHT]; }
+    const gfxSize BottomRight() const { return sizes[NS_CORNER_BOTTOM_RIGHT]; }
+    gfxSize& BottomRight() { return sizes[NS_CORNER_BOTTOM_RIGHT]; }
 };
 #endif /* GFX_RECT_H */
--- a/gfx/thebes/src/gfxContext.cpp
+++ b/gfx/thebes/src/gfxContext.cpp
@@ -888,31 +888,31 @@ gfxContext::RoundedRectangle(const gfxRe
                                     { -1,  0 },
                                     {  0, +1 } };
 
     twoFloats *cornerMults = draw_clockwise ? cwCornerMults : ccwCornerMults;
 
     gfxPoint pc, p0, p1, p2, p3;
 
     if (draw_clockwise)
-        cairo_move_to(mCairo, rect.pos.x + corners[gfxCorner::TOP_LEFT].width, rect.pos.y);
+        cairo_move_to(mCairo, rect.pos.x + corners[NS_CORNER_TOP_LEFT].width, rect.pos.y);
     else
-        cairo_move_to(mCairo, rect.pos.x + rect.size.width - corners[gfxCorner::TOP_RIGHT].width, rect.pos.y);
+        cairo_move_to(mCairo, rect.pos.x + rect.size.width - corners[NS_CORNER_TOP_RIGHT].width, rect.pos.y);
 
-    for (int i = 0; i < gfxCorner::NUM_CORNERS; i++) {
+    NS_FOR_CSS_CORNERS(i) {
         // the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw)
-        int c = draw_clockwise ? ((i+1) % 4) : ((4-i) % 4);
+        mozilla::css::Corner c = mozilla::css::Corner(draw_clockwise ? ((i+1) % 4) : ((4-i) % 4));
 
         // i+2 and i+3 respectively.  These are used to index into the corner
         // multiplier table, and were deduced by calculating out the long form
         // of each corner and finding a pattern in the signs and values.
         int i2 = (i+2) % 4;
         int i3 = (i+3) % 4;
 
-        pc = rect.Corner(c);
+        pc = rect.AtCorner(c);
 
         if (corners[c].width > 0.0 && corners[c].height > 0.0) {
             p0.x = pc.x + cornerMults[i].a * corners[c].width;
             p0.y = pc.y + cornerMults[i].b * corners[c].height;
 
             p3.x = pc.x + cornerMults[i3].a * corners[c].width;
             p3.y = pc.y + cornerMults[i3].b * corners[c].height;
 
--- a/layout/base/nsCSSRendering.cpp
+++ b/layout/base/nsCSSRendering.cpp
@@ -371,17 +371,17 @@ static void DrawBorderImageComponent(nsI
                                      const nsRect& aFill,
                                      const nsIntRect& aSrc,
                                      PRUint8 aHFill,
                                      PRUint8 aVFill,
                                      const nsSize& aUnitSize,
                                      const nsStyleBorder& aStyleBorder,
                                      PRUint8 aIndex);
 
-static nscolor MakeBevelColor(PRIntn whichSide, PRUint8 style,
+static nscolor MakeBevelColor(mozilla::css::Side whichSide, PRUint8 style,
                               nscolor aBackgroundColor,
                               nscolor aBorderColor);
 
 static InlineBackgroundData* gInlineBGData = nsnull;
 
 // Initialize any static variables used by nsCSSRendering.
 nsresult nsCSSRendering::Init()
 {
@@ -399,17 +399,17 @@ void nsCSSRendering::Shutdown()
   delete gInlineBGData;
   gInlineBGData = nsnull;
 }
 
 /**
  * Make a bevel color
  */
 static nscolor
-MakeBevelColor(PRIntn whichSide, PRUint8 style,
+MakeBevelColor(mozilla::css::Side whichSide, PRUint8 style,
                nscolor aBackgroundColor, nscolor aBorderColor)
 {
 
   nscolor colors[2];
   nscolor theColor;
 
   // Given a background color and a border color
   // calculate the color used for the shading
@@ -1471,17 +1471,17 @@ nsCSSRendering::PaintBackground(nsPresCo
 
   PaintBackgroundWithSC(aPresContext, aRenderingContext, aForFrame,
                         aDirtyRect, aBorderArea, sc,
                         *aForFrame->GetStyleBorder(), aFlags,
                         aBGClipRect);
 }
 
 static PRBool
-IsOpaqueBorderEdge(const nsStyleBorder& aBorder, PRUint32 aSide)
+IsOpaqueBorderEdge(const nsStyleBorder& aBorder, mozilla::css::Side aSide)
 {
   if (aBorder.GetActualBorder().side(aSide) == 0)
     return PR_TRUE;
   switch (aBorder.GetBorderStyle(aSide)) {
   case NS_STYLE_BORDER_STYLE_SOLID:
   case NS_STYLE_BORDER_STYLE_GROOVE:
   case NS_STYLE_BORDER_STYLE_RIDGE:
   case NS_STYLE_BORDER_STYLE_INSET:
@@ -1513,17 +1513,17 @@ IsOpaqueBorderEdge(const nsStyleBorder& 
 /**
  * Returns true if all border edges are either missing or opaque.
  */
 static PRBool
 IsOpaqueBorder(const nsStyleBorder& aBorder)
 {
   if (aBorder.mBorderColors)
     return PR_FALSE;
-  for (PRUint32 i = 0; i < 4; ++i) {
+  NS_FOR_CSS_SIDES(i) {
     if (!IsOpaqueBorderEdge(aBorder, i))
       return PR_FALSE;
   }
   return PR_TRUE;
 }
 
 static inline void
 SetupDirtyRects(const nsRect& aBGClipArea, const nsRect& aCallerDirtyRect,
@@ -3076,17 +3076,17 @@ nsCSSRendering::DrawTableBorderSegment(n
       DrawSolidBorderSegment(aContext, aBorder, twipsPerPixel, aStartBevelSide, aStartBevelOffset,
                              aEndBevelSide, aEndBevelOffset);
     }
     else {
       nscoord startBevel = (aStartBevelOffset > 0)
                             ? RoundFloatToPixel(0.5f * (float)aStartBevelOffset, twipsPerPixel, PR_TRUE) : 0;
       nscoord endBevel =   (aEndBevelOffset > 0)
                             ? RoundFloatToPixel(0.5f * (float)aEndBevelOffset, twipsPerPixel, PR_TRUE) : 0;
-      PRUint8 ridgeGrooveSide = (horizontal) ? NS_SIDE_TOP : NS_SIDE_LEFT;
+      mozilla::css::Side ridgeGrooveSide = (horizontal) ? NS_SIDE_TOP : NS_SIDE_LEFT;
       // FIXME: In theory, this should use the visited-dependent
       // background color, but I don't care.
       aContext.SetColor (
         MakeBevelColor(ridgeGrooveSide, ridgeGroove, aBGColor->mBackgroundColor, aBorderColor));
       nsRect rect(aBorder);
       nscoord half;
       if (horizontal) { // top, bottom
         half = RoundFloatToPixel(0.5f * (float)aBorder.height, twipsPerPixel);
--- a/layout/base/nsCSSRenderingBorders.cpp
+++ b/layout/base/nsCSSRenderingBorders.cpp
@@ -92,18 +92,18 @@
  */
 
 static void ComputeBorderCornerDimensions(const gfxRect& aOuterRect,
                                           const gfxRect& aInnerRect,
                                           const gfxCornerSizes& aRadii,
                                           gfxCornerSizes *aDimsResult);
 
 // given a side index, get the previous and next side index
-#define NEXT_SIDE(_s) (((_s) + 1) & 3)
-#define PREV_SIDE(_s) (((_s) + 3) & 3)
+#define NEXT_SIDE(_s) mozilla::css::Side(((_s) + 1) & 3)
+#define PREV_SIDE(_s) mozilla::css::Side(((_s) + 3) & 3)
 
 // from the given base color and the background color, turn
 // color into a color for the given border pattern style
 static gfxRGBA MakeBorderColor(const gfxRGBA& aColor,
                                const gfxRGBA& aBackgroundColor,
                                BorderColorStyle aBorderColorStyle);
 
 
@@ -132,20 +132,20 @@ CheckFourFloatsEqual(const gfxFloat *val
 
 static bool
 IsZeroSize(const gfxSize& sz) {
   return sz.width == 0.0 || sz.height == 0.0;
 }
 
 static bool
 AllCornersZeroSize(const gfxCornerSizes& corners) {
-  return IsZeroSize(corners[0]) &&
-    IsZeroSize(corners[1]) &&
-    IsZeroSize(corners[2]) &&
-    IsZeroSize(corners[3]);
+  return IsZeroSize(corners[NS_CORNER_TOP_LEFT]) &&
+    IsZeroSize(corners[NS_CORNER_TOP_RIGHT]) &&
+    IsZeroSize(corners[NS_CORNER_BOTTOM_RIGHT]) &&
+    IsZeroSize(corners[NS_CORNER_BOTTOM_LEFT]);
 }
 
 typedef enum {
   // Normal solid square corner.  Will be rectangular, the size of the
   // adjacent sides.  If the corner has a border radius, the corner
   // will always be solid, since we don't do dotted/dashed etc.
   CORNER_NORMAL,
 
@@ -281,88 +281,88 @@ nsCSSBorderRenderer::AreBorderSideFinalS
       return ((aSides & ~(SIDE_BIT_TOP | SIDE_BIT_LEFT)) == 0 ||
               (aSides & ~(SIDE_BIT_BOTTOM | SIDE_BIT_RIGHT)) == 0);
   }
 
   return PR_TRUE;
 }
 
 PRBool
-nsCSSBorderRenderer::IsSolidCornerStyle(PRUint8 aStyle, gfxCorner::Corner aCorner)
+nsCSSBorderRenderer::IsSolidCornerStyle(PRUint8 aStyle, mozilla::css::Corner aCorner)
 {
   switch (aStyle) {
     case NS_STYLE_BORDER_STYLE_DOTTED:
     case NS_STYLE_BORDER_STYLE_DASHED:
     case NS_STYLE_BORDER_STYLE_SOLID:
       return PR_TRUE;
 
     case NS_STYLE_BORDER_STYLE_INSET:
     case NS_STYLE_BORDER_STYLE_OUTSET:
-      return (aCorner == gfxCorner::TOP_LEFT || aCorner == gfxCorner::BOTTOM_RIGHT);
+      return (aCorner == NS_CORNER_TOP_LEFT || aCorner == NS_CORNER_BOTTOM_RIGHT);
 
     case NS_STYLE_BORDER_STYLE_GROOVE:
     case NS_STYLE_BORDER_STYLE_RIDGE:
-      return mOneUnitBorder && (aCorner == gfxCorner::TOP_LEFT || aCorner == gfxCorner::BOTTOM_RIGHT);
+      return mOneUnitBorder && (aCorner == NS_CORNER_TOP_LEFT || aCorner == NS_CORNER_BOTTOM_RIGHT);
 
     case NS_STYLE_BORDER_STYLE_DOUBLE:
       return mOneUnitBorder;
 
     default:
       return PR_FALSE;
   }
 }
 
 BorderColorStyle
-nsCSSBorderRenderer::BorderColorStyleForSolidCorner(PRUint8 aStyle, gfxCorner::Corner aCorner)
+nsCSSBorderRenderer::BorderColorStyleForSolidCorner(PRUint8 aStyle, mozilla::css::Corner aCorner)
 {
   // note that this function assumes that the corner is already solid,
   // as per the earlier function
   switch (aStyle) {
     case NS_STYLE_BORDER_STYLE_DOTTED:
     case NS_STYLE_BORDER_STYLE_DASHED:
     case NS_STYLE_BORDER_STYLE_SOLID:
     case NS_STYLE_BORDER_STYLE_DOUBLE:
       return BorderColorStyleSolid;
 
     case NS_STYLE_BORDER_STYLE_INSET:
     case NS_STYLE_BORDER_STYLE_GROOVE:
-      if (aCorner == gfxCorner::TOP_LEFT)
+      if (aCorner == NS_CORNER_TOP_LEFT)
         return BorderColorStyleDark;
-      else if (aCorner == gfxCorner::BOTTOM_RIGHT)
+      else if (aCorner == NS_CORNER_BOTTOM_RIGHT)
         return BorderColorStyleLight;
       break;
 
     case NS_STYLE_BORDER_STYLE_OUTSET:
     case NS_STYLE_BORDER_STYLE_RIDGE:
-      if (aCorner == gfxCorner::TOP_LEFT)
+      if (aCorner == NS_CORNER_TOP_LEFT)
         return BorderColorStyleLight;
-      else if (aCorner == gfxCorner::BOTTOM_RIGHT)
+      else if (aCorner == NS_CORNER_BOTTOM_RIGHT)
         return BorderColorStyleDark;
       break;
   }
 
   return BorderColorStyleNone;
 }
 
 void
-nsCSSBorderRenderer::DoCornerSubPath(PRUint8 aCorner)
+nsCSSBorderRenderer::DoCornerSubPath(mozilla::css::Corner aCorner)
 {
   gfxPoint offset(0.0, 0.0);
 
   if (aCorner == C_TR || aCorner == C_BR)
     offset.x = mOuterRect.size.width - mBorderCornerDimensions[aCorner].width;
   if (aCorner == C_BR || aCorner == C_BL)
     offset.y = mOuterRect.size.height - mBorderCornerDimensions[aCorner].height;
 
   mContext->Rectangle(gfxRect(mOuterRect.pos + offset,
                               mBorderCornerDimensions[aCorner]));
 }
 
 void
-nsCSSBorderRenderer::DoSideClipWithoutCornersSubPath(PRUint8 aSide)
+nsCSSBorderRenderer::DoSideClipWithoutCornersSubPath(mozilla::css::Side aSide)
 {
   gfxPoint offset(0.0, 0.0);
 
   // The offset from the outside rect to the start of this side's
   // box.  For the top and bottom sides, the height of the box
   // must be the border height; the x start must take into account
   // the corner size (which may be bigger than the right or left
   // side's width).  The same applies to the right and left sides.
@@ -377,17 +377,18 @@ nsCSSBorderRenderer::DoSideClipWithoutCo
   } else if (aSide == NS_SIDE_LEFT) {
     offset.y = mBorderCornerDimensions[C_TL].height;
   }
 
   // The sum of the width & height of the corners adjacent to the
   // side.  This relies on the relationship between side indexing and
   // corner indexing; that is, 0 == SIDE_TOP and 0 == CORNER_TOP_LEFT,
   // with both proceeding clockwise.
-  gfxSize sideCornerSum = mBorderCornerDimensions[aSide] + mBorderCornerDimensions[NEXT_SIDE(aSide)];
+  gfxSize sideCornerSum = mBorderCornerDimensions[mozilla::css::Corner(aSide)]
+                        + mBorderCornerDimensions[mozilla::css::Corner(NEXT_SIDE(aSide))];
   gfxRect rect(mOuterRect.pos + offset,
                mOuterRect.size - sideCornerSum);
 
   if (aSide == NS_SIDE_TOP || aSide == NS_SIDE_BOTTOM)
     rect.size.height = mBorderWidths[aSide];
   else
     rect.size.width = mBorderWidths[aSide];
 
@@ -430,17 +431,17 @@ MaybeMoveToMidPoint(gfxPoint& aP0, gfxPo
   if (ps.x != 0.0 && ps.y != 0.0) {
     gfxFloat k = NS_MIN((aMidPoint.x - aP0.x) / ps.x,
                         (aMidPoint.y - aP1.y) / ps.y);
     aP1 = aP0 + ps * k;
   }
 }
 
 void
-nsCSSBorderRenderer::DoSideClipSubPath(PRUint8 aSide)
+nsCSSBorderRenderer::DoSideClipSubPath(mozilla::css::Side aSide)
 {
   // the clip proceeds clockwise from the top left corner;
   // so "start" in each case is the start of the region from that side.
   //
   // the final path will be formed like:
   // s0 ------- e0
   // |         /
   // s1 ----- e1
@@ -454,50 +455,50 @@ nsCSSBorderRenderer::DoSideClipSubPath(P
   PRBool isDashed      = IS_DASHED_OR_DOTTED(mBorderStyles[aSide]);
   PRBool startIsDashed = IS_DASHED_OR_DOTTED(mBorderStyles[PREV_SIDE(aSide)]);
   PRBool endIsDashed   = IS_DASHED_OR_DOTTED(mBorderStyles[NEXT_SIDE(aSide)]);
 #undef IS_DASHED_OR_DOTTED
 
   SideClipType startType = SIDE_CLIP_TRAPEZOID;
   SideClipType endType = SIDE_CLIP_TRAPEZOID;
 
-  if (!IsZeroSize(mBorderRadii[aSide]))
+  if (!IsZeroSize(mBorderRadii[mozilla::css::Corner(aSide)]))
     startType = SIDE_CLIP_TRAPEZOID_FULL;
   else if (startIsDashed && isDashed)
     startType = SIDE_CLIP_RECTANGLE;
 
-  if (!IsZeroSize(mBorderRadii[NEXT_SIDE(aSide)]))
+  if (!IsZeroSize(mBorderRadii[mozilla::css::Corner(NEXT_SIDE(aSide))]))
     endType = SIDE_CLIP_TRAPEZOID_FULL;
   else if (endIsDashed && isDashed)
     endType = SIDE_CLIP_RECTANGLE;
 
   gfxPoint midPoint = mInnerRect.pos + mInnerRect.size / 2.0;
 
-  start[0] = mOuterRect.Corner(aSide);
-  start[1] = mInnerRect.Corner(aSide);
+  start[0] = mOuterRect.CCWCorner(aSide);
+  start[1] = mInnerRect.CCWCorner(aSide);
 
-  end[0] = mOuterRect.Corner(NEXT_SIDE(aSide));
-  end[1] = mInnerRect.Corner(NEXT_SIDE(aSide));
+  end[0] = mOuterRect.CWCorner(aSide);
+  end[1] = mInnerRect.CWCorner(aSide);
 
   if (startType == SIDE_CLIP_TRAPEZOID_FULL) {
     MaybeMoveToMidPoint(start[0], start[1], midPoint);
   } else if (startType == SIDE_CLIP_RECTANGLE) {
     if (aSide == NS_SIDE_TOP || aSide == NS_SIDE_BOTTOM)
-      start[1] = gfxPoint(mOuterRect.Corner(aSide).x, mInnerRect.Corner(aSide).y);
+      start[1] = gfxPoint(mOuterRect.CCWCorner(aSide).x, mInnerRect.CCWCorner(aSide).y);
     else
-      start[1] = gfxPoint(mInnerRect.Corner(aSide).x, mOuterRect.Corner(aSide).y);
+      start[1] = gfxPoint(mInnerRect.CCWCorner(aSide).x, mOuterRect.CCWCorner(aSide).y);
   }
 
   if (endType == SIDE_CLIP_TRAPEZOID_FULL) {
     MaybeMoveToMidPoint(end[0], end[1], midPoint);
   } else if (endType == SIDE_CLIP_RECTANGLE) {
     if (aSide == NS_SIDE_TOP || aSide == NS_SIDE_BOTTOM)
-      end[0] = gfxPoint(mInnerRect.Corner(NEXT_SIDE(aSide)).x, mOuterRect.Corner(NEXT_SIDE(aSide)).y);
+      end[0] = gfxPoint(mInnerRect.CWCorner(aSide).x, mOuterRect.CWCorner(aSide).y);
     else
-      end[0] = gfxPoint(mOuterRect.Corner(NEXT_SIDE(aSide)).x, mInnerRect.Corner(NEXT_SIDE(aSide)).y);
+      end[0] = gfxPoint(mOuterRect.CWCorner(aSide).x, mInnerRect.CWCorner(aSide).y);
   }
 
   mContext->MoveTo(start[0]);
   mContext->LineTo(end[0]);
   mContext->LineTo(end[1]);
   mContext->LineTo(start[1]);
   mContext->ClosePath();
 }
@@ -904,17 +905,17 @@ nsCSSBorderRenderer::DrawBorderSides(PRI
     ComputeInnerRadii(radii, borderWidths[i], &radii);
 
     // And now soRect is the same as siRect, for the next line in.
     soRect = siRect;
   }
 }
 
 void
-nsCSSBorderRenderer::DrawDashedSide(PRUint8 aSide)
+nsCSSBorderRenderer::DrawDashedSide(mozilla::css::Side aSide)
 {
   gfxFloat dashWidth;
   gfxFloat dash[2];
 
   PRUint8 style = mBorderStyles[aSide];
   gfxFloat borderWidth = mBorderWidths[aSide];
   nscolor borderColor = mBorderColors[aSide];
 
@@ -949,18 +950,18 @@ nsCSSBorderRenderer::DrawDashedSide(PRUi
     NS_ERROR("DrawDashedSide called with style other than DASHED or DOTTED; someone's not playing nice");
     return;
   }
 
   SF("dash: %f %f\n", dash[0], dash[1]);
 
   mContext->SetDash(dash, 2, 0.0);
 
-  gfxPoint start = mOuterRect.Corner(aSide);
-  gfxPoint end = mOuterRect.Corner(NEXT_SIDE(aSide));
+  gfxPoint start = mOuterRect.CCWCorner(aSide);
+  gfxPoint end = mOuterRect.CWCorner(aSide);
 
   if (aSide == NS_SIDE_TOP) {
     start.x += mBorderCornerDimensions[C_TL].width;
     end.x -= mBorderCornerDimensions[C_TR].width;
 
     start.y += borderWidth / 2.0;
     end.y += borderWidth / 2.0;
   } else if (aSide == NS_SIDE_RIGHT) {
@@ -1076,32 +1077,32 @@ nsCSSBorderRenderer::DrawBorders()
      * If we have a 1px-wide border, the corners are going to be
      * negligible, so don't bother doing anything fancy.  Just extend
      * the top and bottom borders to the right 1px and the left border
      * to the bottom 1px.  We do this by twiddling the corner dimensions,
      * which causes the right to happen later on.  Only do this if we have
      * a 1.0 unit border all around and no border radius.
      */
 
-    for (int corner = 0; corner < gfxCorner::NUM_CORNERS; corner++) {
-      const PRIntn sides[2] = { corner, PREV_SIDE(corner) };
+    NS_FOR_CSS_CORNERS(corner) {
+      const mozilla::css::Side sides[2] = { mozilla::css::Side(corner), PREV_SIDE(corner) };
 
       if (!IsZeroSize(mBorderRadii[corner]))
         continue;
 
       if (mBorderWidths[sides[0]] == 1.0 && mBorderWidths[sides[1]] == 1.0) {
-        if (corner == gfxCorner::TOP_LEFT || corner == gfxCorner::TOP_RIGHT)
+        if (corner == NS_CORNER_TOP_LEFT || corner == NS_CORNER_TOP_RIGHT)
           mBorderCornerDimensions[corner].width = 0.0;
         else
           mBorderCornerDimensions[corner].height = 0.0;
       }
     }
 
     // First, the corners
-    for (int corner = 0; corner < gfxCorner::NUM_CORNERS; corner++) {
+    NS_FOR_CSS_CORNERS(corner) {
       // if there's no corner, don't do all this work for it
       if (IsZeroSize(mBorderCornerDimensions[corner]))
         continue;
 
       const PRIntn sides[2] = { corner, PREV_SIDE(corner) };
       PRIntn sideBits = (1 << sides[0]) | (1 << sides[1]);
 
       PRBool simpleCornerStyle = mCompositeColors[sides[0]] == NULL &&
@@ -1145,17 +1146,17 @@ nsCSSBorderRenderer::DrawBorders()
         // avoid the temporary, but that situation doesn't happen all
         // that often in practice (we double buffer to no-alpha
         // surfaces).
 
         mContext->PushGroup(gfxASurface::CONTENT_COLOR_ALPHA);
         mContext->SetOperator(gfxContext::OPERATOR_ADD);
 
         for (int cornerSide = 0; cornerSide < 2; cornerSide++) {
-          PRUint8 side = sides[cornerSide];
+          mozilla::css::Side side = mozilla::css::Side(sides[cornerSide]);
           PRUint8 style = mBorderStyles[side];
 
           SF("corner: %d cornerSide: %d side: %d style: %d\n", corner, cornerSide, side, style);
 
           mContext->Save();
 
           mContext->NewPath();
           DoSideClipSubPath(side);
--- a/layout/base/nsCSSRenderingBorders.h
+++ b/layout/base/nsCSSRenderingBorders.h
@@ -54,20 +54,20 @@
 
 //some shorthand for side bits
 #define SIDE_BIT_TOP (1 << NS_SIDE_TOP)
 #define SIDE_BIT_RIGHT (1 << NS_SIDE_RIGHT)
 #define SIDE_BIT_BOTTOM (1 << NS_SIDE_BOTTOM)
 #define SIDE_BIT_LEFT (1 << NS_SIDE_LEFT)
 #define SIDE_BITS_ALL (SIDE_BIT_TOP|SIDE_BIT_RIGHT|SIDE_BIT_BOTTOM|SIDE_BIT_LEFT)
 
-#define C_TL (gfxCorner::TOP_LEFT)
-#define C_TR (gfxCorner::TOP_RIGHT)
-#define C_BR (gfxCorner::BOTTOM_RIGHT)
-#define C_BL (gfxCorner::BOTTOM_LEFT)
+#define C_TL NS_CORNER_TOP_LEFT
+#define C_TR NS_CORNER_TOP_RIGHT
+#define C_BR NS_CORNER_BOTTOM_RIGHT
+#define C_BL NS_CORNER_BOTTOM_LEFT
 
 /*
  * Helper class that handles border rendering.
  *
  * appUnitsPerPixel -- current value of AUPP
  * destContext -- the gfxContext to which the border should be rendered
  * outsideRect -- the rectangle on the outer edge of the border
  *
@@ -136,39 +136,39 @@ struct nsCSSBorderRenderer {
   PRPackedBool mOneUnitBorder;
   PRPackedBool mNoBorderRadius;
 
   // For all the sides in the bitmask, would they be rendered
   // in an identical color and style?
   PRBool AreBorderSideFinalStylesSame(PRUint8 aSides);
 
   // For the given style, is the given corner a solid color?
-  PRBool IsSolidCornerStyle(PRUint8 aStyle, gfxCorner::Corner aCorner);
+  PRBool IsSolidCornerStyle(PRUint8 aStyle, mozilla::css::Corner aCorner);
 
   // For the given solid corner, what color style should be used?
-  BorderColorStyle BorderColorStyleForSolidCorner(PRUint8 aStyle, gfxCorner::Corner aCorner);
+  BorderColorStyle BorderColorStyleForSolidCorner(PRUint8 aStyle, mozilla::css::Corner aCorner);
 
   //
   // Path generation functions
   //
 
   // add the path for drawing the given corner to the context
-  void DoCornerSubPath(PRUint8 aCorner);
+  void DoCornerSubPath(mozilla::css::Corner aCorner);
   // add the path for drawing the given side without any adjacent corners to the context
-  void DoSideClipWithoutCornersSubPath(PRUint8 aSide);
+  void DoSideClipWithoutCornersSubPath(mozilla::css::Side aSide);
 
   // Create a clip path for the wedge that this side of
   // the border should take up.  This is only called
   // when we're drawing separate border sides, so we know
   // that ADD compositing is taking place.
   //
   // This code needs to make sure that the individual pieces
   // don't ever (mathematically) overlap; the pixel overlap
   // is taken care of by the ADD compositing.
-  void DoSideClipSubPath(PRUint8 aSide);
+  void DoSideClipSubPath(mozilla::css::Side aSide);
 
   // Given a set of sides to fill and a color, do so in the fastest way.
   //
   // Stroke tends to be faster for smaller borders because it doesn't go
   // through the tessellator, which has initialization overhead.  If
   // we're rendering all sides, we can use stroke at any thickness; we
   // also do TL/BR pairs at 1px thickness using stroke.
   //
@@ -191,17 +191,17 @@ struct nsCSSBorderRenderer {
   // draw the border for the given sides, using the style of the first side
   // present in the bitmask
   void DrawBorderSides (PRIntn aSides);
 
   // function used by the above to handle -moz-border-colors
   void DrawBorderSidesCompositeColors(PRIntn aSides, const nsBorderColors *compositeColors);
 
   // draw the given dashed side
-  void DrawDashedSide (PRUint8 aSide);
+  void DrawDashedSide (mozilla::css::Side aSide);
 
   // draw the entire border
   void DrawBorders ();
 
   // utility function used for background painting as well as borders
   static void ComputeInnerRadii(const gfxCornerSizes& aRadii,
                                 const gfxFloat *aBorderSizes,
                                 gfxCornerSizes *aInnerRadiiRet);
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -3154,33 +3154,33 @@ nsLayoutUtils::HasNonZeroCorner(const ns
   NS_FOR_CSS_HALF_CORNERS(corner) {
     if (NonZeroStyleCoord(aCorners.Get(corner)))
       return PR_TRUE;
   }
   return PR_FALSE;
 }
 
 // aCorner is a "full corner" value, i.e. NS_CORNER_TOP_LEFT etc
-static PRBool IsCornerAdjacentToSide(PRUint8 aCorner, PRUint8 aSide)
+static PRBool IsCornerAdjacentToSide(PRUint8 aCorner, mozilla::css::Side aSide)
 {
-  PR_STATIC_ASSERT(NS_SIDE_TOP == NS_CORNER_TOP_LEFT);
-  PR_STATIC_ASSERT(NS_SIDE_RIGHT == NS_CORNER_TOP_RIGHT);
-  PR_STATIC_ASSERT(NS_SIDE_BOTTOM == NS_CORNER_BOTTOM_RIGHT);
-  PR_STATIC_ASSERT(NS_SIDE_LEFT == NS_CORNER_BOTTOM_LEFT);
-  PR_STATIC_ASSERT(NS_SIDE_TOP == ((NS_CORNER_TOP_RIGHT - 1)&3));
-  PR_STATIC_ASSERT(NS_SIDE_RIGHT == ((NS_CORNER_BOTTOM_RIGHT - 1)&3));
-  PR_STATIC_ASSERT(NS_SIDE_BOTTOM == ((NS_CORNER_BOTTOM_LEFT - 1)&3));
-  PR_STATIC_ASSERT(NS_SIDE_LEFT == ((NS_CORNER_TOP_LEFT - 1)&3));
+  PR_STATIC_ASSERT((int)NS_SIDE_TOP == NS_CORNER_TOP_LEFT);
+  PR_STATIC_ASSERT((int)NS_SIDE_RIGHT == NS_CORNER_TOP_RIGHT);
+  PR_STATIC_ASSERT((int)NS_SIDE_BOTTOM == NS_CORNER_BOTTOM_RIGHT);
+  PR_STATIC_ASSERT((int)NS_SIDE_LEFT == NS_CORNER_BOTTOM_LEFT);
+  PR_STATIC_ASSERT((int)NS_SIDE_TOP == ((NS_CORNER_TOP_RIGHT - 1)&3));
+  PR_STATIC_ASSERT((int)NS_SIDE_RIGHT == ((NS_CORNER_BOTTOM_RIGHT - 1)&3));
+  PR_STATIC_ASSERT((int)NS_SIDE_BOTTOM == ((NS_CORNER_BOTTOM_LEFT - 1)&3));
+  PR_STATIC_ASSERT((int)NS_SIDE_LEFT == ((NS_CORNER_TOP_LEFT - 1)&3));
 
   return aSide == aCorner || aSide == ((aCorner - 1)&3);
 }
 
 /* static */ PRBool
 nsLayoutUtils::HasNonZeroCornerOnSide(const nsStyleCorners& aCorners,
-                                      PRUint8 aSide)
+                                      mozilla::css::Side aSide)
 {
   PR_STATIC_ASSERT(NS_CORNER_TOP_LEFT_X/2 == NS_CORNER_TOP_LEFT);
   PR_STATIC_ASSERT(NS_CORNER_TOP_LEFT_Y/2 == NS_CORNER_TOP_LEFT);
   PR_STATIC_ASSERT(NS_CORNER_TOP_RIGHT_X/2 == NS_CORNER_TOP_RIGHT);
   PR_STATIC_ASSERT(NS_CORNER_TOP_RIGHT_Y/2 == NS_CORNER_TOP_RIGHT);
   PR_STATIC_ASSERT(NS_CORNER_BOTTOM_RIGHT_X/2 == NS_CORNER_BOTTOM_RIGHT);
   PR_STATIC_ASSERT(NS_CORNER_BOTTOM_RIGHT_Y/2 == NS_CORNER_BOTTOM_RIGHT);
   PR_STATIC_ASSERT(NS_CORNER_BOTTOM_LEFT_X/2 == NS_CORNER_BOTTOM_LEFT);
--- a/layout/base/nsLayoutUtils.h
+++ b/layout/base/nsLayoutUtils.h
@@ -1028,17 +1028,17 @@ public:
    */
   static PRBool HasNonZeroCorner(const nsStyleCorners& aCorners);
 
   /**
    * Determine if there is any corner radius on corners adjacent to the
    * given side.
    */
   static PRBool HasNonZeroCornerOnSide(const nsStyleCorners& aCorners,
-                                       PRUint8 aSide);
+                                       mozilla::css::Side aSide);
 
   /**
    * Determine if a widget is likely to require transparency or translucency.
    *   @param aBackgroundFrame The frame that the background is set on. For
    *                           <window>s, this will be the canvas frame.
    *   @param aCSSRootFrame    The frame that holds CSS properties affecting
    *                           the widget's transparency. For menupopups,
    *                           aBackgroundFrame and aCSSRootFrame will be the
--- a/layout/base/nsStyleConsts.h
+++ b/layout/base/nsStyleConsts.h
@@ -37,36 +37,36 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 /* constants used in the style struct data provided by nsStyleContext */
 
 #ifndef nsStyleConsts_h___
 #define nsStyleConsts_h___
 
+#include "gfxRect.h"
 #include "nsFont.h"
 
 // cairo doesn't support invert
 // #define GFX_HAS_INVERT
 
 // XXX fold this into nsStyleContext and group by nsStyleXXX struct
 
 // Indices into border/padding/margin arrays
-#define NS_SIDE_TOP     0
-#define NS_SIDE_RIGHT   1
-#define NS_SIDE_BOTTOM  2
-#define NS_SIDE_LEFT    3
+#define NS_SIDE_TOP     mozilla::css::eSideTop
+#define NS_SIDE_RIGHT   mozilla::css::eSideRight
+#define NS_SIDE_BOTTOM  mozilla::css::eSideBottom
+#define NS_SIDE_LEFT    mozilla::css::eSideLeft
 
-#define NS_FOR_CSS_SIDES(var_) for (PRInt32 var_ = 0; var_ < 4; ++var_)
-
-// Indices into "full corner" arrays (nsCSSCornerSizes e.g.)
-#define NS_CORNER_TOP_LEFT     0
-#define NS_CORNER_TOP_RIGHT    1
-#define NS_CORNER_BOTTOM_RIGHT 2
-#define NS_CORNER_BOTTOM_LEFT  3
+#define NS_FOR_CSS_SIDES(var_) for (mozilla::css::Side var_ = NS_SIDE_TOP; var_ <= NS_SIDE_LEFT; var_++)
+static inline mozilla::css::Side operator++(mozilla::css::Side& side, int) {
+    NS_PRECONDITION(side < NS_SIDE_LEFT, "Out of range side");
+    side = mozilla::css::Side(side + 1);
+    return side;
+}
 
 #define NS_FOR_CSS_FULL_CORNERS(var_) for (PRInt32 var_ = 0; var_ < 4; ++var_)
 
 // Indices into "half corner" arrays (nsStyleCorners e.g.)
 #define NS_CORNER_TOP_LEFT_X      0
 #define NS_CORNER_TOP_LEFT_Y      1
 #define NS_CORNER_TOP_RIGHT_X     2
 #define NS_CORNER_TOP_RIGHT_Y     3
--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -599,17 +599,17 @@ nsContainerFrame::DoInlineIntrinsicWidth
                                          nsLayoutUtils::IntrinsicWidthType aType)
 {
   if (GetPrevInFlow())
     return; // Already added.
 
   NS_PRECONDITION(aType == nsLayoutUtils::MIN_WIDTH ||
                   aType == nsLayoutUtils::PREF_WIDTH, "bad type");
 
-  PRUint8 startSide, endSide;
+  mozilla::css::Side startSide, endSide;
   if (GetStyleVisibility()->mDirection == NS_STYLE_DIRECTION_LTR) {
     startSide = NS_SIDE_LEFT;
     endSide = NS_SIDE_RIGHT;
   } else {
     startSide = NS_SIDE_RIGHT;
     endSide = NS_SIDE_LEFT;
   }
 
--- a/layout/style/nsCSSStruct.cpp
+++ b/layout/style/nsCSSStruct.cpp
@@ -52,16 +52,17 @@
 #include "nsCSSProps.h"
 #include "nsFont.h"
 
 #include "nsStyleConsts.h"
 
 #include "nsCOMPtr.h"
 #include "nsReadableUtils.h"
 #include "nsPrintfCString.h"
+#include "prlog.h"
 
 // --- nsCSSFont -----------------
 
 nsCSSFont::nsCSSFont(void)
 {
   MOZ_COUNT_CTOR(nsCSSFont);
 }
 
@@ -168,19 +169,17 @@ nsCSSRect::~nsCSSRect()
 void nsCSSRect::SetAllSidesTo(const nsCSSValue& aValue)
 {
   mTop = aValue;
   mRight = aValue;
   mBottom = aValue;
   mLeft = aValue;
 }
 
-#if (NS_SIDE_TOP != 0) || (NS_SIDE_RIGHT != 1) || (NS_SIDE_BOTTOM != 2) || (NS_SIDE_LEFT != 3)
-#error "Somebody changed the side constants."
-#endif
+PR_STATIC_ASSERT((NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3));
 
 /* static */ const nsCSSRect::side_type nsCSSRect::sides[4] = {
   &nsCSSRect::mTop,
   &nsCSSRect::mRight,
   &nsCSSRect::mBottom,
   &nsCSSRect::mLeft,
 };
 
@@ -208,20 +207,18 @@ nsCSSCornerSizes::~nsCSSCornerSizes()
 void
 nsCSSCornerSizes::Reset()
 {
   NS_FOR_CSS_FULL_CORNERS(corner) {
     this->GetFullCorner(corner).Reset();
   }
 }
 
-#if NS_CORNER_TOP_LEFT != 0 || NS_CORNER_TOP_RIGHT != 1 || \
-    NS_CORNER_BOTTOM_RIGHT != 2 || NS_CORNER_BOTTOM_LEFT != 3
-#error "Somebody changed the corner constants."
-#endif
+PR_STATIC_ASSERT(NS_CORNER_TOP_LEFT == 0 && NS_CORNER_TOP_RIGHT == 1 && \
+    NS_CORNER_BOTTOM_RIGHT == 2 && NS_CORNER_BOTTOM_LEFT == 3);
 
 /* static */ const nsCSSCornerSizes::corner_type
 nsCSSCornerSizes::corners[4] = {
   &nsCSSCornerSizes::mTopLeft,
   &nsCSSCornerSizes::mTopRight,
   &nsCSSCornerSizes::mBottomRight,
   &nsCSSCornerSizes::mBottomLeft,
 };
--- a/layout/style/nsComputedDOMStyle.cpp
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -3303,17 +3303,17 @@ nsComputedDOMStyle::GetROCSSValueList(PR
   nsDOMCSSValueList *valueList = new nsDOMCSSValueList(aCommaDelimited,
                                                        PR_TRUE);
   NS_ASSERTION(valueList != 0, "ran out of memory");
 
   return valueList;
 }
 
 nsresult
-nsComputedDOMStyle::GetOffsetWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetOffsetWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 {
   const nsStyleDisplay* display = GetStyleDisplay();
 
   AssertFlushedPendingReflows();
 
   nsresult rv = NS_OK;
   switch (display->mPosition) {
     case NS_STYLE_POSITION_STATIC:
@@ -3330,17 +3330,17 @@ nsComputedDOMStyle::GetOffsetWidthFor(PR
       NS_ERROR("Invalid position");
       break;
   }
 
   return rv;
 }
 
 nsresult
-nsComputedDOMStyle::GetAbsoluteOffset(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetAbsoluteOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 {
   nsROCSSPrimitiveValue *val = GetROCSSPrimitiveValue();
   NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
 
   nsIFrame* container = GetContainingBlockFor(mOuterFrame);
   if (container) {
     nsMargin margin = mOuterFrame->GetUsedMargin();
     nsMargin border = container->GetUsedBorder();
@@ -3390,25 +3390,21 @@ nsComputedDOMStyle::GetAbsoluteOffset(PR
   } else {
     // XXX no frame.  This property makes no sense
     val->SetAppUnits(0);
   }
 
   return CallQueryInterface(val, aValue);
 }
 
-
-#if (NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3)
-#define NS_OPPOSITE_SIDE(s_) (((s_) + 2) & 3)
-#else
-#error "Somebody changed the side constants."
-#endif
+PR_STATIC_ASSERT((NS_SIDE_TOP == 0) && (NS_SIDE_RIGHT == 1) && (NS_SIDE_BOTTOM == 2) && (NS_SIDE_LEFT == 3));
+#define NS_OPPOSITE_SIDE(s_) mozilla::css::Side(((s_) + 2) & 3)
 
 nsresult
-nsComputedDOMStyle::GetRelativeOffset(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetRelativeOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 {
   nsROCSSPrimitiveValue *val = GetROCSSPrimitiveValue();
   NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
 
   const nsStylePosition* positionData = GetStylePosition();
   PRInt32 sign = 1;
   nsStyleCoord coord = positionData->mOffset.Get(aSide);
 
@@ -3429,29 +3425,29 @@ nsComputedDOMStyle::GetRelativeOffset(PR
   }
 
   val->SetAppUnits(sign * StyleCoordToNSCoord(coord, baseGetter, 0));
 
   return CallQueryInterface(val, aValue);
 }
 
 nsresult
-nsComputedDOMStyle::GetStaticOffset(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetStaticOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 
 {
   nsROCSSPrimitiveValue *val = GetROCSSPrimitiveValue();
   NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
 
   SetValueToCoord(val, GetStylePosition()->mOffset.Get(aSide));
 
   return CallQueryInterface(val, aValue);
 }
 
 nsresult
-nsComputedDOMStyle::GetPaddingWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetPaddingWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 {
   nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
   NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
 
   if (!mInnerFrame) {
     SetValueToCoord(val, GetStylePadding()->mPadding.Get(aSide));
   } else {
     AssertFlushedPendingReflows();
@@ -3489,17 +3485,17 @@ nsComputedDOMStyle::GetLineHeightCoord(n
   aCoord = NSToCoordRound((float(aCoord) *
                            (float(font->mSize) / float(font->mFont.size))) /
                           mPresShell->GetPresContext()->TextZoom());
 
   return PR_TRUE;
 }
 
 nsresult
-nsComputedDOMStyle::GetBorderColorsFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetBorderColorsFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 {
   const nsStyleBorder *border = GetStyleBorder();
 
   if (border->mBorderColors) {
     nsBorderColors* borderColors = border->mBorderColors[aSide];
     if (borderColors) {
       nsDOMCSSValueList *valueList = GetROCSSValueList(PR_FALSE);
       NS_ENSURE_TRUE(valueList, NS_ERROR_OUT_OF_MEMORY);
@@ -3536,17 +3532,17 @@ nsComputedDOMStyle::GetBorderColorsFor(P
   NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
 
   val->SetIdent(eCSSKeyword_none);
 
   return CallQueryInterface(val, aValue);
 }
 
 nsresult
-nsComputedDOMStyle::GetBorderWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetBorderWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 {
   nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
   NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
 
   nscoord width;
   if (mInnerFrame) {
     AssertFlushedPendingReflows();
     width = mInnerFrame->GetUsedBorder().side(aSide);
@@ -3554,17 +3550,17 @@ nsComputedDOMStyle::GetBorderWidthFor(PR
     width = GetStyleBorder()->GetActualBorderWidth(aSide);
   }
   val->SetAppUnits(width);
 
   return CallQueryInterface(val, aValue);
 }
 
 nsresult
-nsComputedDOMStyle::GetBorderColorFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetBorderColorFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 {
   nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
   NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
 
   nscolor color;
   PRBool foreground;
   GetStyleBorder()->GetBorderColor(aSide, color, foreground);
   if (foreground) {
@@ -3576,34 +3572,34 @@ nsComputedDOMStyle::GetBorderColorFor(PR
     delete val;
     return rv;
   }
 
   return CallQueryInterface(val, aValue);
 }
 
 nsresult
-nsComputedDOMStyle::GetMarginWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetMarginWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 {
   nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
   NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
 
   if (!mInnerFrame) {
     SetValueToCoord(val, GetStyleMargin()->mMargin.Get(aSide));
   } else {
     AssertFlushedPendingReflows();
 
     val->SetAppUnits(mInnerFrame->GetUsedMargin().side(aSide));
   }
 
   return CallQueryInterface(val, aValue);
 }
 
 nsresult
-nsComputedDOMStyle::GetBorderStyleFor(PRUint8 aSide, nsIDOMCSSValue** aValue)
+nsComputedDOMStyle::GetBorderStyleFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue)
 {
   nsROCSSPrimitiveValue* val = GetROCSSPrimitiveValue();
   NS_ENSURE_TRUE(val, NS_ERROR_OUT_OF_MEMORY);
 
   val->SetIdent(
     nsCSSProps::ValueToKeywordEnum(GetStyleBorder()->GetBorderStyle(aSide),
                                    nsCSSProps::kBorderStyleKTable));
 
--- a/layout/style/nsComputedDOMStyle.h
+++ b/layout/style/nsComputedDOMStyle.h
@@ -111,35 +111,35 @@ private:
   }
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 
   nsresult GetEllipseRadii(const nsStyleCorners& aRadius,
                            PRUint8 aFullCorner,
                            nsIDOMCSSValue** aValue);
 
-  nsresult GetOffsetWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetOffsetWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
-  nsresult GetAbsoluteOffset(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetAbsoluteOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
-  nsresult GetRelativeOffset(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetRelativeOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
-  nsresult GetStaticOffset(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetStaticOffset(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
-  nsresult GetPaddingWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetPaddingWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
-  nsresult GetBorderColorsFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetBorderColorsFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
-  nsresult GetBorderStyleFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetBorderStyleFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
-  nsresult GetBorderWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetBorderWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
-  nsresult GetBorderColorFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetBorderColorFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
-  nsresult GetMarginWidthFor(PRUint8 aSide, nsIDOMCSSValue** aValue);
+  nsresult GetMarginWidthFor(mozilla::css::Side aSide, nsIDOMCSSValue** aValue);
 
   PRBool GetLineHeightCoord(nscoord& aCoord);
 
   nsresult GetCSSShadowArray(nsCSSShadowArray* aArray,
                              const nscolor& aDefaultColor,
                              PRBool aIsBoxShadow,
                              nsIDOMCSSValue** aValue);
 
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -2304,17 +2304,17 @@ nsRuleNode::SetDefaultOnRoot(const nsSty
  * input).
  */
 void
 nsRuleNode::AdjustLogicalBoxProp(nsStyleContext* aContext,
                                  const nsCSSValue& aLTRSource,
                                  const nsCSSValue& aRTLSource,
                                  const nsCSSValue& aLTRLogicalValue,
                                  const nsCSSValue& aRTLLogicalValue,
-                                 PRUint8 aSide,
+                                 mozilla::css::Side aSide,
                                  nsCSSRect& aValueRect,
                                  PRBool& aCanStoreInRuleTree)
 {
   PRBool LTRlogical = aLTRSource.GetUnit() == eCSSUnit_Enumerated &&
                       aLTRSource.GetIntValue() == NS_BOXPROP_SOURCE_LOGICAL;
   PRBool RTLlogical = aRTLSource.GetUnit() == eCSSUnit_Enumerated &&
                       aRTLSource.GetIntValue() == NS_BOXPROP_SOURCE_LOGICAL;
   if (LTRlogical || RTLlogical) {
--- a/layout/style/nsRuleNode.h
+++ b/layout/style/nsRuleNode.h
@@ -644,17 +644,17 @@ protected:
                              nscoord aMinFontSize,
                              nsStyleFont* aFont);
 
   void AdjustLogicalBoxProp(nsStyleContext* aContext,
                             const nsCSSValue& aLTRSource,
                             const nsCSSValue& aRTLSource,
                             const nsCSSValue& aLTRLogicalValue,
                             const nsCSSValue& aRTLLogicalValue,
-                            PRUint8 aSide,
+                            mozilla::css::Side aSide,
                             nsCSSRect& aValueRect,
                             PRBool& aCanStoreInRuleTree);
 
   inline RuleDetail CheckSpecifiedProperties(const nsStyleStructID aSID, const nsRuleDataStruct& aRuleDataStruct);
 
   const void* GetParentData(const nsStyleStructID aSID);
   #define STYLE_STRUCT(name_, checkdata_cb_, ctor_args_)  \
     const nsStyle##name_* GetParent##name_();
--- a/layout/style/nsStyleAnimation.cpp
+++ b/layout/style/nsStyleAnimation.cpp
@@ -1231,17 +1231,17 @@ StyleDataAtOffset(const void* aStyleStru
 inline void*
 StyleDataAtOffset(void* aStyleStruct, ptrdiff_t aOffset)
 {
   return reinterpret_cast<char*>(aStyleStruct) + aOffset;
 }
 
 static void
 ExtractBorderColor(nsStyleContext* aStyleContext, const void* aStyleBorder,
-                   PRUint8 aSide, nsStyleAnimation::Value& aComputedValue)
+                   mozilla::css::Side aSide, nsStyleAnimation::Value& aComputedValue)
 {
   nscolor color;
   PRBool foreground;
   static_cast<const nsStyleBorder*>(aStyleBorder)->
     GetBorderColor(aSide, color, foreground);
   if (foreground) {
     // FIXME: should add test for this
     color = aStyleContext->GetStyleColor()->mColor;
@@ -1663,17 +1663,17 @@ nsStyleAnimation::ExtractComputedValue(n
       PR_STATIC_ASSERT(eStyleAnimType_Sides_Right - eStyleAnimType_Sides_Top
                          == NS_SIDE_RIGHT);
       PR_STATIC_ASSERT(eStyleAnimType_Sides_Bottom - eStyleAnimType_Sides_Top
                          == NS_SIDE_BOTTOM);
       PR_STATIC_ASSERT(eStyleAnimType_Sides_Left - eStyleAnimType_Sides_Top
                          == NS_SIDE_LEFT);
       const nsStyleCoord &coord = static_cast<const nsStyleSides*>(
         StyleDataAtOffset(styleStruct, ssOffset))->
-          Get(animType - eStyleAnimType_Sides_Top);
+          Get(mozilla::css::Side(animType - eStyleAnimType_Sides_Top));
       return StyleCoordToValue(coord, aComputedValue);
     }
     case eStyleAnimType_Corner_TopLeft:
     case eStyleAnimType_Corner_TopRight:
     case eStyleAnimType_Corner_BottomRight:
     case eStyleAnimType_Corner_BottomLeft: {
       PR_STATIC_ASSERT(0 == NS_CORNER_TOP_LEFT);
       PR_STATIC_ASSERT(eStyleAnimType_Corner_TopRight -
--- a/layout/style/nsStyleCoord.h
+++ b/layout/style/nsStyleCoord.h
@@ -129,33 +129,31 @@ public:
 class nsStyleSides {
 public:
   nsStyleSides(void);
 
 //  nsStyleSides&  operator=(const nsStyleSides& aCopy);  // use compiler's version
   PRBool         operator==(const nsStyleSides& aOther) const;
   PRBool         operator!=(const nsStyleSides& aOther) const;
 
-  // aSide is always one of NS_SIDE_* defined in nsStyleConsts.h
-
-  inline nsStyleUnit GetUnit(PRUint8 aSide) const;
+  inline nsStyleUnit GetUnit(mozilla::css::Side aSide) const;
   inline nsStyleUnit GetLeftUnit(void) const;
   inline nsStyleUnit GetTopUnit(void) const;
   inline nsStyleUnit GetRightUnit(void) const;
   inline nsStyleUnit GetBottomUnit(void) const;
 
-  inline nsStyleCoord Get(PRUint8 aSide) const;
+  inline nsStyleCoord Get(mozilla::css::Side aSide) const;
   inline nsStyleCoord GetLeft() const;
   inline nsStyleCoord GetTop() const;
   inline nsStyleCoord GetRight() const;
   inline nsStyleCoord GetBottom() const;
 
   void  Reset(void);
 
-  inline void Set(PRUint8 aSide, const nsStyleCoord& aCoord);
+  inline void Set(mozilla::css::Side aSide, const nsStyleCoord& aCoord);
   inline void SetLeft(const nsStyleCoord& aCoord);
   inline void SetTop(const nsStyleCoord& aCoord);
   inline void SetRight(const nsStyleCoord& aCoord);
   inline void SetBottom(const nsStyleCoord& aCoord);
 
 protected:
   PRUint8       mUnits[4];
   nsStyleUnion  mValues[4];
@@ -281,17 +279,17 @@ inline void nsStyleCoord::GetUnionValue(
 // -------------------------
 // nsStyleSides inlines
 //
 inline PRBool nsStyleSides::operator!=(const nsStyleSides& aOther) const
 {
   return !((*this) == aOther);
 }
 
-inline nsStyleUnit nsStyleSides::GetUnit(PRUint8 aSide) const
+inline nsStyleUnit nsStyleSides::GetUnit(mozilla::css::Side aSide) const
 {
   return (nsStyleUnit)mUnits[aSide];
 }
 
 inline nsStyleUnit nsStyleSides::GetLeftUnit(void) const
 {
   return GetUnit(NS_SIDE_LEFT);
 }
@@ -306,17 +304,17 @@ inline nsStyleUnit nsStyleSides::GetRigh
   return GetUnit(NS_SIDE_RIGHT);
 }
 
 inline nsStyleUnit nsStyleSides::GetBottomUnit(void) const
 {
   return GetUnit(NS_SIDE_BOTTOM);
 }
 
-inline nsStyleCoord nsStyleSides::Get(PRUint8 aSide) const
+inline nsStyleCoord nsStyleSides::Get(mozilla::css::Side aSide) const
 {
   return nsStyleCoord(mValues[aSide], nsStyleUnit(mUnits[aSide]));
 }
 
 inline nsStyleCoord nsStyleSides::GetLeft() const
 {
   return Get(NS_SIDE_LEFT);
 }
@@ -331,17 +329,17 @@ inline nsStyleCoord nsStyleSides::GetRig
   return Get(NS_SIDE_RIGHT);
 }
 
 inline nsStyleCoord nsStyleSides::GetBottom() const
 {
   return Get(NS_SIDE_BOTTOM);
 }
 
-inline void nsStyleSides::Set(PRUint8 aSide, const nsStyleCoord& aCoord)
+inline void nsStyleSides::Set(mozilla::css::Side aSide, const nsStyleCoord& aCoord)
 {
   mUnits[aSide] = aCoord.GetUnit();
   aCoord.GetUnionValue(mValues[aSide]);
 }
 
 inline void nsStyleSides::SetLeft(const nsStyleCoord& aCoord)
 {
   Set(NS_SIDE_LEFT, aCoord);
--- a/layout/style/nsStyleStruct.h
+++ b/layout/style/nsStyleStruct.h
@@ -61,16 +61,17 @@
 #include "nsCOMArray.h"
 #include "nsTArray.h"
 #include "nsIAtom.h"
 #include "nsIURI.h"
 #include "nsCSSValue.h"
 #include "nsStyleTransformMatrix.h"
 #include "nsAlgorithm.h"
 #include "imgIRequest.h"
+#include "gfxRect.h"
 
 class nsIFrame;
 class imgIRequest;
 class imgIContainer;
 
 // Includes nsStyleStructID.
 #include "nsStyleStructFwd.h"
 
@@ -732,44 +733,44 @@ struct nsStyleBorder {
     if (!mBorderColors) {
       mBorderColors = new nsBorderColors*[4];
       if (mBorderColors)
         for (PRInt32 i = 0; i < 4; i++)
           mBorderColors[i] = nsnull;
     }
   }
 
-  void ClearBorderColors(PRUint8 aSide) {
+  void ClearBorderColors(mozilla::css::Side aSide) {
     if (mBorderColors && mBorderColors[aSide]) {
       delete mBorderColors[aSide];
       mBorderColors[aSide] = nsnull;
     }
   }
 
   // Return whether aStyle is a visible style.  Invisible styles cause
   // the relevant computed border width to be 0.
   // Note that this does *not* consider the effects of 'border-image':
   // if border-style is none, but there is a loaded border image,
   // HasVisibleStyle will be false even though there *is* a border.
-  PRBool HasVisibleStyle(PRUint8 aSide)
+  PRBool HasVisibleStyle(mozilla::css::Side aSide)
   {
     return IsVisibleBorderStyle(GetBorderStyle(aSide));
   }
 
   // aBorderWidth is in twips
-  void SetBorderWidth(PRUint8 aSide, nscoord aBorderWidth)
+  void SetBorderWidth(mozilla::css::Side aSide, nscoord aBorderWidth)
   {
     nscoord roundedWidth =
       NS_ROUND_BORDER_TO_PIXELS(aBorderWidth, mTwipsPerPixel);
     mBorder.side(aSide) = roundedWidth;
     if (HasVisibleStyle(aSide))
       mComputedBorder.side(aSide) = roundedWidth;
   }
 
-  void SetBorderImageWidthOverride(PRUint8 aSide, nscoord aBorderWidth)
+  void SetBorderImageWidthOverride(mozilla::css::Side aSide, nscoord aBorderWidth)
   {
     mBorderImageWidth.side(aSide) =
       NS_ROUND_BORDER_TO_PIXELS(aBorderWidth, mTwipsPerPixel);
   }
 
   // Get the actual border, in twips.  (If there is no border-image
   // loaded, this is the same as GetComputedBorder.  If there is a
   // border-image loaded, it uses the border-image width overrides if
@@ -784,54 +785,54 @@ struct nsStyleBorder {
   {
     return mComputedBorder;
   }
 
   // Get the actual border width for a particular side, in appunits.  Note that
   // this is zero if and only if there is no border to be painted for this
   // side.  That is, this value takes into account the border style and the
   // value is rounded to the nearest device pixel by NS_ROUND_BORDER_TO_PIXELS.
-  nscoord GetActualBorderWidth(PRUint8 aSide) const
+  nscoord GetActualBorderWidth(mozilla::css::Side aSide) const
   {
     return GetActualBorder().side(aSide);
   }
 
-  PRUint8 GetBorderStyle(PRUint8 aSide) const
+  PRUint8 GetBorderStyle(mozilla::css::Side aSide) const
   {
     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
     return (mBorderStyle[aSide] & BORDER_STYLE_MASK);
   }
 
-  void SetBorderStyle(PRUint8 aSide, PRUint8 aStyle)
+  void SetBorderStyle(mozilla::css::Side aSide, PRUint8 aStyle)
   {
     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
     mBorderStyle[aSide] &= ~BORDER_STYLE_MASK;
     mBorderStyle[aSide] |= (aStyle & BORDER_STYLE_MASK);
     mComputedBorder.side(aSide) =
       (HasVisibleStyle(aSide) ? mBorder.side(aSide) : 0);
   }
 
   // Defined in nsStyleStructInlines.h
   inline PRBool IsBorderImageLoaded() const;
   inline nsresult RequestDecode();
 
-  void GetBorderColor(PRUint8 aSide, nscolor& aColor,
+  void GetBorderColor(mozilla::css::Side aSide, nscolor& aColor,
                       PRBool& aForeground) const
   {
     aForeground = PR_FALSE;
     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
     if ((mBorderStyle[aSide] & BORDER_COLOR_SPECIAL) == 0)
       aColor = mBorderColor[aSide];
     else if (mBorderStyle[aSide] & BORDER_COLOR_FOREGROUND)
       aForeground = PR_TRUE;
     else
       NS_NOTREACHED("OUTLINE_COLOR_INITIAL should not be set here");
   }
 
-  void SetBorderColor(PRUint8 aSide, nscolor aColor)
+  void SetBorderColor(mozilla::css::Side aSide, nscolor aColor)
   {
     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
     mBorderColor[aSide] = aColor;
     mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL;
   }
 
   // These are defined in nsStyleStructInlines.h
   inline void SetBorderImage(imgIRequest* aImage);
@@ -860,17 +861,17 @@ struct nsStyleBorder {
       nsBorderColors* last = mBorderColors[aIndex];
       while (last->mNext)
         last = last->mNext;
       last->mNext = colorEntry;
     }
     mBorderStyle[aIndex] &= ~BORDER_COLOR_SPECIAL;
   }
 
-  void SetBorderToForeground(PRUint8 aSide)
+  void SetBorderToForeground(mozilla::css::Side aSide)
   {
     NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side");
     mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL;
     mBorderStyle[aSide] |= BORDER_COLOR_FOREGROUND;
   }
 
 protected:
   // mComputedBorder holds the CSS2.1 computed border-width values.  In
--- a/layout/tables/celldata.h
+++ b/layout/tables/celldata.h
@@ -34,16 +34,17 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 #ifndef CellData_h__
 #define CellData_h__
 
 #include "nsISupports.h"
 #include "nsCoord.h"
+#include "gfxCore.h"
 
 class nsTableCellFrame;
 class nsCellMap;
 class BCCellData;
 
 
 #define MAX_ROWSPAN 8190 // the cellmap can not handle more
 #define MAX_COLSPAN 1000 // limit as IE and opera do
@@ -222,21 +223,21 @@ public:
 
   nscoord GetTopEdge(BCBorderOwner& aOwner,
                      PRBool&        aStart) const;
 
   void SetTopEdge(BCBorderOwner aOwner,
                   nscoord       aSize,
                   PRBool        aStart);
 
-  BCPixelSize GetCorner(PRUint8&       aCornerOwner,
+  BCPixelSize GetCorner(mozilla::css::Side&       aCornerOwner,
                         PRPackedBool&  aBevel) const;
 
   void SetCorner(BCPixelSize aSubSize,
-                 PRUint8 aOwner,
+                 mozilla::css::Side aOwner,
                  PRBool  aBevel);
 
   PRBool IsLeftStart() const;
 
   void SetLeftStart(PRBool aValue);
 
   PRBool IsTopStart() const;
 
@@ -250,17 +251,17 @@ protected:
                               //   dominant plane (for example, if corner is
                               //   owned by the segment to its top or bottom,
                               //   then the size is the max of the border
                               //   sizes of the segments to its left or right.
   unsigned mLeftOwner:     4; // owner of left border
   unsigned mTopOwner:      4; // owner of top border
   unsigned mLeftStart:     1; // set if this is the start of a vertical border segment
   unsigned mTopStart:      1; // set if this is the start of a horizontal border segment
-  unsigned mCornerSide:    2; // side of the owner of the upper left corner relative to the corner
+  mozilla::css::Side mCornerSide: 2; // side of the owner of the upper left corner relative to the corner
   unsigned mCornerBevel:   1; // is the corner beveled (only two segments, perpendicular, not dashed or dotted).
 };
 
 // BCCellData entries replace CellData entries in the cell map if the border collapsing model is in
 // effect. BCData for a row and col entry contains the left and top borders of cell at that row and
 // col and the corner connecting the two. The right borders of the cells in the last col and the bottom
 // borders of the last row are stored in separate BCData entries in the cell map.
 class BCCellData : public CellData
@@ -411,17 +412,18 @@ inline void CellData::SetOverlap(PRBool 
     }
   }
 }
 
 inline BCData::BCData()
 {
   mLeftOwner = mTopOwner = eCellOwner;
   mLeftStart = mTopStart = 1;
-  mLeftSize = mCornerSide = mCornerSubSize = mTopSize = 0;
+  mLeftSize = mCornerSubSize = mTopSize = 0;
+  mCornerSide = NS_SIDE_TOP;
   mCornerBevel = PR_FALSE;
 }
 
 inline BCData::~BCData()
 {
 }
 
 inline nscoord BCData::GetLeftEdge(BCBorderOwner& aOwner,
@@ -455,26 +457,26 @@ inline void BCData::SetTopEdge(BCBorderO
                                nscoord        aSize,
                                PRBool         aStart)
 {
   mTopOwner = aOwner;
   mTopSize  = (aSize > MAX_BORDER_WIDTH) ? MAX_BORDER_WIDTH : aSize;
   mTopStart = aStart;
 }
 
-inline BCPixelSize BCData::GetCorner(PRUint8&       aOwnerSide,
+inline BCPixelSize BCData::GetCorner(mozilla::css::Side&       aOwnerSide,
                                      PRPackedBool&  aBevel) const
 {
   aOwnerSide = mCornerSide;
   aBevel     = (PRBool)mCornerBevel;
   return mCornerSubSize;
 }
 
 inline void BCData::SetCorner(BCPixelSize aSubSize,
-                              PRUint8 aOwnerSide,
+                              mozilla::css::Side aOwnerSide,
                               PRBool  aBevel)
 {
   mCornerSubSize = aSubSize;
   mCornerSide    = aOwnerSide;
   mCornerBevel   = aBevel;
 }
 
 inline PRBool BCData::IsLeftStart() const
--- a/layout/tables/nsCellMap.cpp
+++ b/layout/tables/nsCellMap.cpp
@@ -737,17 +737,17 @@ nsTableCellMap::Dump(char* aString) cons
   while (cellMap) {
     cellMap->Dump(nsnull != mBCInfo);
     cellMap = cellMap->GetNextSibling();
   }
   if (nsnull != mBCInfo) {
     printf("***** bottom borders *****\n");
     nscoord       size;
     BCBorderOwner owner;
-    PRUint8       side;
+    mozilla::css::Side side;
     PRBool        segStart;
     PRPackedBool  bevel;
     PRInt32       colIndex;
     PRInt32 numCols = mBCInfo->mBottomBorders.Length();
     for (PRInt32 i = 0; i <= 2; i++) {
 
       printf("\n          ");
       for (colIndex = 0; colIndex < numCols; colIndex++) {
@@ -977,17 +977,17 @@ nsTableCellMap::SetNotTopStart(PRUint8  
   }
 }
 
 // store the aSide border segment at coord = (aRowIndex, aColIndex). For top/left, store
 // the info at coord. For bottom/left store it at the adjacent location so that it is
 // top/left at that location. If the new location is at the right or bottom edge of the
 // table, then store it one of the special arrays (right most borders, bottom most borders).
 void
-nsTableCellMap::SetBCBorderEdge(PRUint8       aSide,
+nsTableCellMap::SetBCBorderEdge(mozilla::css::Side aSide,
                                 nsCellMap&    aCellMap,
                                 PRUint32      aCellMapStart,
                                 PRUint32      aRowIndex,
                                 PRUint32      aColIndex,
                                 PRUint32      aLength,
                                 BCBorderOwner aOwner,
                                 nscoord       aSize,
                                 PRBool        aChanged)
@@ -1073,17 +1073,17 @@ nsTableCellMap::SetBCBorderEdge(PRUint8 
 // (aRowIndex, aColIndex). For eTopRight, store it in the entry to the right where
 // it would be top left. For eBottomRight, store it in the entry to the bottom. etc.
 void
 nsTableCellMap::SetBCBorderCorner(Corner      aCorner,
                                   nsCellMap&  aCellMap,
                                   PRUint32    aCellMapStart,
                                   PRUint32    aRowIndex,
                                   PRUint32    aColIndex,
-                                  PRUint8     aOwner,
+                                  mozilla::css::Side aOwner,
                                   nscoord     aSubSize,
                                   PRBool      aBevel,
                                   PRBool      aIsBottomRight)
 {
   if (!mBCInfo) ABORT0();
 
   if (aIsBottomRight) {
     mBCInfo->mLowerRightCorner.SetCorner(aSubSize, aOwner, aBevel);
@@ -2563,17 +2563,17 @@ void nsCellMap::Dump(PRBool aIsBorderCol
         }
       } else {
         printf("----  ");
       }
     }
     if (aIsBorderCollapse) {
       nscoord       size;
       BCBorderOwner owner;
-      PRUint8       side;
+      mozilla::css::Side side;
       PRBool        segStart;
       PRPackedBool  bevel;
       for (PRInt32 i = 0; i <= 2; i++) {
         printf("\n          ");
         for (colIndex = 0; colIndex < colCount; colIndex++) {
           BCCellData* cd = (BCCellData *)row[colIndex];
           if (cd) {
             if (0 == i) {
--- a/layout/tables/nsCellMap.h
+++ b/layout/tables/nsCellMap.h
@@ -230,32 +230,32 @@ public:
   void ExpandZeroColSpans();
 
   void SetNotTopStart(PRUint8    aSide,
                       nsCellMap& aCellMap,
                       PRUint32   aYPos,
                       PRUint32   aXPos,
                       PRBool     aIsLowerRight = PR_FALSE);
 
-  void SetBCBorderEdge(PRUint8       aEdge,
+  void SetBCBorderEdge(mozilla::css::Side aEdge,
                        nsCellMap&    aCellMap,
                        PRUint32      aCellMapStart,
                        PRUint32      aYPos,
                        PRUint32      aXPos,
                        PRUint32      aLength,
                        BCBorderOwner aOwner,
                        nscoord       aSize,
                        PRBool        aChanged);
 
   void SetBCBorderCorner(Corner      aCorner,
                          nsCellMap&  aCellMap,
                          PRUint32    aCellMapStart,
                          PRUint32    aYPos,
                          PRUint32    aXPos,
-                         PRUint8     aOwner,
+                         mozilla::css::Side aOwner,
                          nscoord     aSubSize,
                          PRBool      aBevel,
                          PRBool      aIsBottomRight = PR_FALSE);
 
   /** dump a representation of the cell map to stdout for debugging */
 #ifdef NS_DEBUG
   void Dump(char* aString = nsnull) const;
 #endif
--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -1107,32 +1107,32 @@ nsBCTableCellFrame::GetBorderWidth(nsMar
   aBorder.top    = BC_BORDER_BOTTOM_HALF_COORD(aPixelsToTwips, mTopBorder);
   aBorder.right  = BC_BORDER_LEFT_HALF_COORD(aPixelsToTwips, mRightBorder);
   aBorder.bottom = BC_BORDER_TOP_HALF_COORD(aPixelsToTwips, mBottomBorder);
   aBorder.left   = BC_BORDER_RIGHT_HALF_COORD(aPixelsToTwips, mLeftBorder);
   return &aBorder;
 }
 
 BCPixelSize
-nsBCTableCellFrame::GetBorderWidth(PRUint8 aSide) const
+nsBCTableCellFrame::GetBorderWidth(mozilla::css::Side aSide) const
 {
   switch(aSide) {
   case NS_SIDE_TOP:
     return BC_BORDER_BOTTOM_HALF(mTopBorder);
   case NS_SIDE_RIGHT:
     return BC_BORDER_LEFT_HALF(mRightBorder);
   case NS_SIDE_BOTTOM:
     return BC_BORDER_TOP_HALF(mBottomBorder);
   default:
     return BC_BORDER_RIGHT_HALF(mLeftBorder);
   }
 }
 
 void
-nsBCTableCellFrame::SetBorderWidth(PRUint8 aSide,
+nsBCTableCellFrame::SetBorderWidth(mozilla::css::Side aSide,
                                    BCPixelSize aValue)
 {
   switch(aSide) {
   case NS_SIDE_TOP:
     mTopBorder = aValue;
     break;
   case NS_SIDE_RIGHT:
     mRightBorder = aValue;
--- a/layout/tables/nsTableCellFrame.h
+++ b/layout/tables/nsTableCellFrame.h
@@ -313,20 +313,20 @@ public:
   virtual nsIAtom* GetType() const;
 
   virtual nsMargin GetUsedBorder() const;
 
   // Get the *inner half of the border only*, in twips.
   virtual nsMargin* GetBorderWidth(nsMargin& aBorder) const;
 
   // Get the *inner half of the border only*, in pixels.
-  BCPixelSize GetBorderWidth(PRUint8 aSide) const;
+  BCPixelSize GetBorderWidth(mozilla::css::Side aSide) const;
 
   // Set the full (both halves) width of the border
-  void SetBorderWidth(PRUint8 aSide, BCPixelSize aPixelValue);
+  void SetBorderWidth(mozilla::css::Side aSide, BCPixelSize aPixelValue);
 
   virtual void GetSelfOverflow(nsRect& aOverflowArea);
 
 #ifdef DEBUG
   NS_IMETHOD GetFrameName(nsAString& aResult) const;
 #endif
 
   virtual void PaintBackground(nsIRenderingContext& aRenderingContext,
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -3893,18 +3893,18 @@ struct BCMapCellInfo
   nsTableFrame*         mTableFrame;
   PRInt32               mNumTableRows;
   PRInt32               mNumTableCols;
   BCPropertyData*       mTableBCData;
 
   // storage of table ltr information, the border collapse code swaps the sides
   // to account for rtl tables, this is done through mStartSide and mEndSide
   PRPackedBool          mTableIsLTR;
-  PRUint8               mStartSide;
-  PRUint8               mEndSide;
+  mozilla::css::Side    mStartSide;
+  mozilla::css::Side    mEndSide;
 
   // a cell can only belong to one rowgroup
   nsTableRowGroupFrame* mRowGroup;
 
   // a cell with a rowspan has a top and a bottom row, and rows in between
   nsTableRowFrame*      mTopRow;
   nsTableRowFrame*      mBottomRow;
   nsTableRowFrame*      mCurrentRowFrame;
@@ -4395,17 +4395,17 @@ static PRUint8 styleToPriority[13] = { 0
   * @param aFrame           - query the info for this frame
   * @param aSide            - the side of the frame
   * @param aStyle           - the border style
   * @param aColor           - the border color
   * @param aTableIsLTR      - table direction is LTR
   */
 static void
 GetColorAndStyle(const nsIFrame*  aFrame,
-                 PRUint8          aSide,
+                 mozilla::css::Side aSide,
                  PRUint8&         aStyle,
                  nscolor&         aColor,
                  PRBool           aTableIsLTR)
 {
   NS_PRECONDITION(aFrame, "null frame");
   // initialize out arg
   aColor = 0;
   const nsStyleBorder* styleData = aFrame->GetStyleBorder();
@@ -4431,17 +4431,17 @@ GetColorAndStyle(const nsIFrame*  aFrame
   * @param aFrame           - query the info for this frame
   * @param aSide            - the side of the frame
   * @param aStyle           - the border style
   * @param aColor           - the border color
   * @param aTableIsLTR      - table direction is LTR
   */
 static void
 GetPaintStyleInfo(const nsIFrame*  aFrame,
-                  PRUint8          aSide,
+                  mozilla::css::Side aSide,
                   PRUint8&         aStyle,
                   nscolor&         aColor,
                   PRBool           aTableIsLTR)
 {
   GetColorAndStyle(aFrame, aSide, aStyle, aColor, aTableIsLTR);
   if (NS_STYLE_BORDER_STYLE_INSET    == aStyle) {
     aStyle = NS_STYLE_BORDER_STYLE_RIDGE;
   }
@@ -4457,17 +4457,17 @@ GetPaintStyleInfo(const nsIFrame*  aFram
   * @param aStyle           - the border style
   * @param aColor           - the border color
   * @param aTableIsLTR      - table direction is LTR
   * @param aWidth           - the border width in px.
   * @param aTwipsToPixels   - conversion factor from twips to pixel
   */
 static void
 GetColorAndStyle(const nsIFrame*  aFrame,
-                 PRUint8          aSide,
+                 mozilla::css::Side aSide,
                  PRUint8&         aStyle,
                  nscolor&         aColor,
                  PRBool           aTableIsLTR,
                  BCPixelSize&     aWidth)
 {
   GetColorAndStyle(aFrame, aSide, aStyle, aColor, aTableIsLTR);
   if ((NS_STYLE_BORDER_STYLE_NONE == aStyle) ||
       (NS_STYLE_BORDER_STYLE_HIDDEN == aStyle)) {
@@ -4605,17 +4605,17 @@ CompareBorders(PRBool              aIsCo
 static BCCellBorder
 CompareBorders(const nsIFrame*  aTableFrame,
                const nsIFrame*  aColGroupFrame,
                const nsIFrame*  aColFrame,
                const nsIFrame*  aRowGroupFrame,
                const nsIFrame*  aRowFrame,
                const nsIFrame*  aCellFrame,
                PRBool           aTableIsLTR,
-               PRUint8          aSide,
+               mozilla::css::Side aSide,
                PRBool           aAja)
 {
   BCCellBorder border, tempBorder;
   PRBool horizontal = (NS_SIDE_TOP == aSide) || (NS_SIDE_BOTTOM == aSide);
 
   // start with the table as dominant if present
   if (aTableFrame) {
     GetColorAndStyle(aTableFrame, aSide, border.style, border.color, aTableIsLTR, border.width);
@@ -4666,62 +4666,62 @@ CompareBorders(const nsIFrame*  aTableFr
     GetColorAndStyle(aCellFrame, aSide, tempBorder.style, tempBorder.color, aTableIsLTR, tempBorder.width);
     tempBorder.owner = (aAja) ? eAjaCellOwner : eCellOwner;
     border = CompareBorders(!CELL_CORNER, border, tempBorder, PR_FALSE);
   }
   return border;
 }
 
 static PRBool
-Perpendicular(PRUint8 aSide1,
-              PRUint8 aSide2)
+Perpendicular(mozilla::css::Side aSide1,
+              mozilla::css::Side aSide2)
 {
   switch (aSide1) {
   case NS_SIDE_TOP:
     return (NS_SIDE_BOTTOM != aSide2);
   case NS_SIDE_RIGHT:
     return (NS_SIDE_LEFT != aSide2);
   case NS_SIDE_BOTTOM:
     return (NS_SIDE_TOP != aSide2);
   default: // NS_SIDE_LEFT
     return (NS_SIDE_RIGHT != aSide2);
   }
 }
 
 // XXX allocate this as number-of-cols+1 instead of number-of-cols+1 * number-of-rows+1
 struct BCCornerInfo
 {
-  BCCornerInfo() { ownerColor = 0; ownerWidth = subWidth = ownerSide = ownerElem = subSide =
-                   subElem = hasDashDot = numSegs = bevel = 0;
+  BCCornerInfo() { ownerColor = 0; ownerWidth = subWidth = ownerElem = subSide =
+                   subElem = hasDashDot = numSegs = bevel = 0; ownerSide = NS_SIDE_TOP;
                    ownerStyle = 0xFF; subStyle = NS_STYLE_BORDER_STYLE_SOLID;  }
-  void Set(PRUint8       aSide,
+  void Set(mozilla::css::Side aSide,
            BCCellBorder  border);
 
-  void Update(PRUint8       aSide,
+  void Update(mozilla::css::Side aSide,
               BCCellBorder  border);
 
   nscolor   ownerColor;     // color of borderOwner
   PRUint16  ownerWidth;     // pixel width of borderOwner
   PRUint16  subWidth;       // pixel width of the largest border intersecting the border perpendicular
                             // to ownerSide
-  PRUint32  ownerSide:2;    // side (e.g NS_SIDE_TOP, NS_SIDE_RIGHT, etc) of the border owning
+  mozilla::css::Side ownerSide:2; // side (e.g NS_SIDE_TOP, NS_SIDE_RIGHT, etc) of the border owning
                             // the corner relative to the corner
   PRUint32  ownerElem:3;    // elem type (e.g. eTable, eGroup, etc) owning the corner
   PRUint32  ownerStyle:8;   // border style of ownerElem
   PRUint32  subSide:2;      // side of border with subWidth relative to the corner
   PRUint32  subElem:3;      // elem type (e.g. eTable, eGroup, etc) of sub owner
   PRUint32  subStyle:8;     // border style of subElem
   PRUint32  hasDashDot:1;   // does a dashed, dotted segment enter the corner, they cannot be beveled
   PRUint32  numSegs:3;      // number of segments entering corner
   PRUint32  bevel:1;        // is the corner beveled (uses the above two fields together with subWidth)
   PRUint32  unused:1;
 };
 
 void
-BCCornerInfo::Set(PRUint8       aSide,
+BCCornerInfo::Set(mozilla::css::Side aSide,
                   BCCellBorder  aBorder)
 {
   ownerElem  = aBorder.owner;
   ownerStyle = aBorder.style;
   ownerWidth = aBorder.width;
   ownerColor = aBorder.color;
   ownerSide  = aSide;
   hasDashDot = 0;
@@ -4735,32 +4735,32 @@ BCCornerInfo::Set(PRUint8       aSide,
   subWidth   = 0;
   // the following will get set later
   subSide    = ((aSide == NS_SIDE_LEFT) || (aSide == NS_SIDE_RIGHT)) ? NS_SIDE_TOP : NS_SIDE_LEFT;
   subElem    = eTableOwner;
   subStyle   = NS_STYLE_BORDER_STYLE_SOLID;
 }
 
 void
-BCCornerInfo::Update(PRUint8       aSide,
+BCCornerInfo::Update(mozilla::css::Side aSide,
                      BCCellBorder  aBorder)
 {
   PRBool existingWins = PR_FALSE;
   if (0xFF == ownerStyle) { // initial value indiating that it hasn't been set yet
     Set(aSide, aBorder);
   }
   else {
     PRBool horizontal = (NS_SIDE_LEFT == aSide) || (NS_SIDE_RIGHT == aSide); // relative to the corner
     BCCellBorder oldBorder, tempBorder;
     oldBorder.owner  = (BCBorderOwner) ownerElem;
     oldBorder.style =  ownerStyle;
     oldBorder.width =  ownerWidth;
     oldBorder.color =  ownerColor;
 
-    PRUint8 oldSide  = ownerSide;
+    mozilla::css::Side oldSide  = ownerSide;
 
     tempBorder = CompareBorders(CELL_CORNER, oldBorder, aBorder, horizontal, &existingWins);
 
     ownerElem  = tempBorder.owner;
     ownerStyle = tempBorder.style;
     ownerWidth = tempBorder.width;
     ownerColor = tempBorder.color;
     if (existingWins) { // existing corner is dominant
@@ -5524,17 +5524,17 @@ nsTableFrame::CalcBCBorders()
       info.SetTableTopLeftContBCBorder();
     }
     else {
       // see if the top border needs to be the start of a segment due to a
       // vertical border owning the corner
       if (info.mColIndex > 0) {
         BCData& data = info.mCellData->mData;
         if (!data.IsTopStart()) {
-          PRUint8 cornerSide;
+          mozilla::css::Side cornerSide;
           PRPackedBool bevel;
           data.GetCorner(cornerSide, bevel);
           if ((NS_SIDE_TOP == cornerSide) || (NS_SIDE_BOTTOM == cornerSide)) {
             data.SetTopStart(PR_TRUE);
           }
         }
       }
     }
@@ -5926,17 +5926,17 @@ struct BCVerticalSeg
   nsTableRowGroupFrame* mFirstRowGroup; // row group at the start of the segment
   nsTableRowFrame*      mFirstRow;      // row at the start of the segment
   nsTableCellFrame*     mLastCell;      // cell at the current end of the
                                         // segment
 
 
   PRUint8               mOwner;         // owner of the border, defines the
                                         // style
-  PRUint8               mTopBevelSide;  // direction to bevel at the top
+  mozilla::css::Side    mTopBevelSide;  // direction to bevel at the top
   nscoord               mTopBevelOffset; // how much to bevel at the top
   BCPixelSize           mBottomHorSegHeight; // height of the crossing
                                         //horizontal border
   nscoord               mBottomOffset;  // how much longer is the segment due
                                         // to the horizontal border, by this
                                         // amount the next segment needs to be
                                         // shifted.
   PRBool                mIsBottomBevel; // should we bevel at the bottom
@@ -5957,20 +5957,20 @@ struct BCHorizontalSeg
    void Paint(BCPaintBorderIterator& aIter,
               nsIRenderingContext&   aRenderingContext);
 
   nscoord            mOffsetX;       // x-offset with respect to the table edge
   nscoord            mOffsetY;       // y-offset with respect to the table edge
   nscoord            mLength;        // horizontal length including corners
   BCPixelSize        mWidth;         // border width in pixels
   nscoord            mLeftBevelOffset;   // how much to bevel at the left
-  PRUint8            mLeftBevelSide;     // direction to bevel at the left
-  PRBool             mIsRightBevel;        // should we bevel at the right end
+  mozilla::css::Side mLeftBevelSide;     // direction to bevel at the left
+  PRBool             mIsRightBevel;      // should we bevel at the right end
   nscoord            mRightBevelOffset;  // how much to bevel at the right
-  PRUint8            mRightBevelSide;    // direction to bevel at the right
+  mozilla::css::Side mRightBevelSide;    // direction to bevel at the right
   nscoord            mEndOffset;         // how much longer is the segment due
                                          // to the vertical border, by this
                                          // amount the next segment needs to be
                                          // shifted.
   PRUint8            mOwner;             // owner of the border, defines the
                                          // style
   nsTableCellFrame*  mFirstCell;         // cell at the start of the segment
   nsTableCellFrame*  mAjaCell;           // neighboring cell to the first cell
@@ -6462,17 +6462,17 @@ BCPaintBorderIterator::Next()
   * @param aCornerOwnerSide - which side owns the corner
   * @param aCornerSubWidth  - how wide is the nonwinning side of the corner
   * @param aHorWidth        - how wide is the horizontal edge of the corner
   * @param aIsStartOfSeg    - does this corner start a new segment
   * @param aIsBevel         - is this corner beveled
   * @return                 - offset in twips
   */
 static nscoord
-CalcVerCornerOffset(PRUint8     aCornerOwnerSide,
+CalcVerCornerOffset(mozilla::css::Side aCornerOwnerSide,
                     BCPixelSize aCornerSubWidth,
                     BCPixelSize aHorWidth,
                     PRBool      aIsStartOfSeg,
                     PRBool      aIsBevel)
 {
   nscoord offset = 0;
   // XXX These should be replaced with appropriate side-specific macros (which?)
   BCPixelSize smallHalf, largeHalf;
@@ -6503,17 +6503,17 @@ CalcVerCornerOffset(PRUint8     aCornerO
   * @param aCornerSubWidth  - how wide is the nonwinning side of the corner
   * @param aVerWidth        - how wide is the vertical edge of the corner
   * @param aIsStartOfSeg    - does this corner start a new segment
   * @param aIsBevel         - is this corner beveled
   * @param aTableIsLTR      - direction, the computation depends on ltr or rtl
   * @return                 - offset in twips
   */
 static nscoord
-CalcHorCornerOffset(PRUint8     aCornerOwnerSide,
+CalcHorCornerOffset(mozilla::css::Side aCornerOwnerSide,
                     BCPixelSize aCornerSubWidth,
                     BCPixelSize aVerWidth,
                     PRBool      aIsStartOfSeg,
                     PRBool      aIsBevel,
                     PRBool      aTableIsLTR)
 {
   nscoord offset = 0;
   // XXX These should be replaced with appropriate side-specific macros (which?)
@@ -6549,17 +6549,18 @@ CalcHorCornerOffset(PRUint8     aCornerO
   }
   return nsPresContext::CSSPixelsToAppUnits(offset);
 }
 
 BCVerticalSeg::BCVerticalSeg()
 {
   mCol = nsnull;
   mFirstCell = mLastCell = mAjaCell = nsnull;
-  mOffsetX = mOffsetY = mLength = mWidth = mTopBevelOffset = mTopBevelSide = 0;
+  mOffsetX = mOffsetY = mLength = mWidth = mTopBevelOffset = 0;
+  mTopBevelSide = NS_SIDE_TOP;
   mOwner = eCellOwner;
 }
 
 /**
  * Start a new vertical segment
  * @param aIter         - iterator containing the structural information
  * @param aBorderOwner  - determines the border style
  * @param aVerSegWidth  - the width of segment in pixel
@@ -6567,17 +6568,17 @@ BCVerticalSeg::BCVerticalSeg()
  *                        at the start
  */
 void
 BCVerticalSeg::Start(BCPaintBorderIterator& aIter,
                      BCBorderOwner          aBorderOwner,
                      BCPixelSize            aVerSegWidth,
                      BCPixelSize            aHorSegHeight)
 {
-  PRUint8      ownerSide   = 0;
+  mozilla::css::Side ownerSide   = NS_SIDE_TOP;
   PRPackedBool bevel       = PR_FALSE;
 
 
   nscoord cornerSubWidth  = (aIter.mBCData) ?
                                aIter.mBCData->GetCorner(ownerSide, bevel) : 0;
 
   PRBool  topBevel        = (aVerSegWidth > 0) ? bevel : PR_FALSE;
   BCPixelSize maxHorSegHeight = PR_MAX(aIter.mPrevHorSegHeight, aHorSegHeight);
@@ -6630,17 +6631,17 @@ BCVerticalSeg::Initialize(BCPaintBorderI
  * @param aIter         - iterator containing the structural information
  * @param aHorSegHeight - the width of the horizontal segment joining the corner
  *                        at the start
  */
 void
 BCVerticalSeg::GetBottomCorner(BCPaintBorderIterator& aIter,
                                BCPixelSize            aHorSegHeight)
 {
-   PRUint8 ownerSide = 0;
+   mozilla::css::Side ownerSide = NS_SIDE_TOP;
    nscoord cornerSubWidth = 0;
    PRPackedBool bevel = PR_FALSE;
    if (aIter.mBCData) {
      cornerSubWidth = aIter.mBCData->GetCorner(ownerSide, bevel);
    }
    mIsBottomBevel = (mWidth > 0) ? bevel : PR_FALSE;
    mBottomHorSegHeight = PR_MAX(aIter.mPrevHorSegHeight, aHorSegHeight);
    mBottomOffset = CalcVerCornerOffset(ownerSide, cornerSubWidth,
@@ -6657,17 +6658,17 @@ BCVerticalSeg::GetBottomCorner(BCPaintBo
  *                        at the start
  */
 void
 BCVerticalSeg::Paint(BCPaintBorderIterator& aIter,
                      nsIRenderingContext&   aRenderingContext,
                      BCPixelSize            aHorSegHeight)
 {
   // get the border style, color and paint the segment
-  PRUint8 side = (aIter.IsDamageAreaRightMost()) ? NS_SIDE_RIGHT :
+  mozilla::css::Side side = (aIter.IsDamageAreaRightMost()) ? NS_SIDE_RIGHT :
                                                     NS_SIDE_LEFT;
   PRInt32 relColIndex = aIter.GetRelativeColIndex();
   nsTableColFrame* col           = mCol; if (!col) ABORT0();
   nsTableCellFrame* cell         = mFirstCell; // ???
   nsIFrame* owner = nsnull;
   PRUint8 style = NS_STYLE_BORDER_STYLE_SOLID;
   nscolor color = 0xFFFFFFFF;
 
@@ -6720,19 +6721,19 @@ BCVerticalSeg::Paint(BCPaintBorderIterat
   }
   BCPixelSize smallHalf, largeHalf;
   DivideBCBorderSize(mWidth, smallHalf, largeHalf);
   nsRect segRect(mOffsetX - nsPresContext::CSSPixelsToAppUnits(largeHalf),
                  mOffsetY,
                  nsPresContext::CSSPixelsToAppUnits(mWidth), mLength);
   nscoord bottomBevelOffset = (mIsBottomBevel) ?
                   nsPresContext::CSSPixelsToAppUnits(mBottomHorSegHeight) : 0;
-  PRUint8 bottomBevelSide = ((aHorSegHeight > 0) ^ !aIter.mTableIsLTR) ?
+  mozilla::css::Side bottomBevelSide = ((aHorSegHeight > 0) ^ !aIter.mTableIsLTR) ?
                             NS_SIDE_RIGHT : NS_SIDE_LEFT;
-  PRUint8 topBevelSide = ((mTopBevelSide == NS_SIDE_RIGHT) ^ !aIter.mTableIsLTR)?
+  mozilla::css::Side topBevelSide = ((mTopBevelSide == NS_SIDE_RIGHT) ^ !aIter.mTableIsLTR)?
                          NS_SIDE_RIGHT : NS_SIDE_LEFT;
   nsCSSRendering::DrawTableBorderSegment(aRenderingContext, style, color,
                                          aIter.mTableBgColor, segRect,
                                          nsPresContext::AppUnitsPerCSSPixel(),
                                          topBevelSide, mTopBevelOffset,
                                          bottomBevelSide, bottomBevelOffset);
 }
 
@@ -6753,33 +6754,33 @@ BCVerticalSeg::IncludeCurrentBorder(BCPa
 {
   mLastCell = aIter.mCell;
   mLength  += aIter.mRow->GetRect().height;
 }
 
 BCHorizontalSeg::BCHorizontalSeg()
 {
   mOffsetX = mOffsetY = mLength = mWidth =  mLeftBevelOffset = 0;
-  mLeftBevelSide = 0;
+  mLeftBevelSide = NS_SIDE_TOP;
   mFirstCell = mAjaCell = nsnull;
 }
 
 /** Initialize a horizontal border segment for painting
   * @param aIter              - iterator storing the current and adjacent frames
   * @param aBorderOwner       - which frame owns the border
   * @param aBottomVerSegWidth - vertical segment width coming from up
   * @param aHorSegHeight      - the height of the segment
   +  */
 void
 BCHorizontalSeg::Start(BCPaintBorderIterator& aIter,
                        BCBorderOwner        aBorderOwner,
                        BCPixelSize          aBottomVerSegWidth,
                        BCPixelSize          aHorSegHeight)
 {
-  PRUint8      cornerOwnerSide = 0;
+  mozilla::css::Side cornerOwnerSide = NS_SIDE_TOP;
   PRPackedBool bevel     = PR_FALSE;
 
   mOwner = aBorderOwner;
   nscoord cornerSubWidth  = (aIter.mBCData) ?
                              aIter.mBCData->GetCorner(cornerOwnerSide,
                                                        bevel) : 0;
 
   PRBool  leftBevel = (aHorSegHeight > 0) ? bevel : PR_FALSE;
@@ -6810,17 +6811,17 @@ BCHorizontalSeg::Start(BCPaintBorderIter
  * @param aIter         - iterator containing the structural information
  * @param aLeftSegWidth - the width of the vertical segment joining the corner
  *                        at the start
  */
 void
 BCHorizontalSeg::GetRightCorner(BCPaintBorderIterator& aIter,
                                 BCPixelSize            aLeftSegWidth)
 {
-  PRUint8 ownerSide = 0;
+  mozilla::css::Side ownerSide = NS_SIDE_TOP;
   nscoord cornerSubWidth = 0;
   PRPackedBool bevel = PR_FALSE;
   if (aIter.mBCData) {
     cornerSubWidth = aIter.mBCData->GetCorner(ownerSide, bevel);
   }
 
   mIsRightBevel = (mWidth > 0) ? bevel : 0;
   PRInt32 relColIndex = aIter.GetRelativeColIndex();
@@ -6838,17 +6839,17 @@ BCHorizontalSeg::GetRightCorner(BCPaintB
  * @param aIter         - iterator containing the structural information
  * @param aRenderingContext - the rendering context
  */
 void
 BCHorizontalSeg::Paint(BCPaintBorderIterator& aIter,
                        nsIRenderingContext&   aRenderingContext)
 {
   // get the border style, color and paint the segment
-  PRUint8 side = (aIter.IsDamageAreaBottomMost()) ? NS_SIDE_BOTTOM :
+  mozilla::css::Side side = (aIter.IsDamageAreaBottomMost()) ? NS_SIDE_BOTTOM :
                                                      NS_SIDE_TOP;
   nsIFrame* rg   = aIter.mRg;  if (!rg) ABORT0();
   nsIFrame* row  = aIter.mRow; if (!row) ABORT0();
   nsIFrame* cell = mFirstCell;
   nsIFrame* col;
   nsIFrame* owner = nsnull;
 
   PRUint8 style = NS_STYLE_BORDER_STYLE_SOLID;
@@ -6963,17 +6964,17 @@ BCPaintBorderIterator::StoreColumnWidth(
   }
 }
 /**
  * Determine if a vertical segment owns the corder
  */
 PRBool
 BCPaintBorderIterator::VerticalSegmentOwnsCorner()
 {
-  PRUint8 cornerOwnerSide = 0;
+  mozilla::css::Side cornerOwnerSide = NS_SIDE_TOP;
   PRPackedBool bevel = PR_FALSE;
   nscoord cornerSubWidth;
   cornerSubWidth = (mBCData) ? mBCData->GetCorner(cornerOwnerSide, bevel) : 0;
   // unitialized ownerside, bevel
   return  (NS_SIDE_TOP == cornerOwnerSide) ||
           (NS_SIDE_BOTTOM == cornerOwnerSide);
 }