diff --git a/mozilla/content/base/src/nsStyleContext.cpp b/mozilla/content/base/src/nsStyleContext.cpp
index eb03ec0ccb8..1cd8ee15641 100644
--- a/mozilla/content/base/src/nsStyleContext.cpp
+++ b/mozilla/content/base/src/nsStyleContext.cpp
@@ -526,7 +526,9 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
     // It's text (!)
     mMolecule.display = NS_STYLE_DISPLAY_INLINE;
     mMolecule.cursor = NS_STYLE_CURSOR_IBEAM;
-    nsIContent* content = aParentFrame->GetContent();
+    nsIContent* content;
+     
+    aParentFrame->GetContent(content);
     nsIAtom* parentTag = content->GetTag();
     parentTag->ToString(buf);
     NS_RELEASE(content);
@@ -539,9 +541,13 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
 //      mFont.mFont.decorations = NS_FONT_DECORATION_UNDERLINE;
       // This simulates a <PRE><A>text inheritance rule
       // Check the parent of the A
-      nsIFrame* parentParentFrame = aParentFrame->GetGeometricParent();
+      nsIFrame* parentParentFrame;
+       
+      aParentFrame->GetGeometricParent(parentParentFrame);
       if (nsnull != parentParentFrame) {
-        nsIContent* parentParentContent = parentParentFrame->GetContent();
+        nsIContent* parentParentContent;
+         
+        parentParentFrame->GetContent(parentParentContent);
         nsIAtom* parentParentTag = parentParentContent->GetTag();
         parentParentTag->ToString(buf);
         NS_RELEASE(parentParentTag);
@@ -607,7 +613,7 @@ NS_NewStyleContext(nsIStyleContext** aInstancePtrResult,
 
   nsIStyleContext* parent = nsnull;
   if (nsnull != aParentFrame) {
-    parent = aParentFrame->GetStyleContext(aPresContext);
+    aParentFrame->GetStyleContext(aPresContext, parent);
     NS_ASSERTION(nsnull != parent, "parent frame must have style context");
   }
 
diff --git a/mozilla/content/base/src/nsStyleSet.cpp b/mozilla/content/base/src/nsStyleSet.cpp
index 31eb9f37ced..94ea2a5c0e7 100644
--- a/mozilla/content/base/src/nsStyleSet.cpp
+++ b/mozilla/content/base/src/nsStyleSet.cpp
@@ -454,7 +454,7 @@ nsIStyleContext* StyleSetImpl::ResolveStyleFor(nsIPresContext* aPresContext,
   nsIStyleContext* parentContext = nsnull;
   
   if (nsnull != aParentFrame) {
-    parentContext = aParentFrame->GetStyleContext(aPresContext);
+    aParentFrame->GetStyleContext(aPresContext, parentContext);
     NS_ASSERTION(nsnull != parentContext, "parent must have style context");
   }
 
diff --git a/mozilla/content/html/style/src/nsCSSLayout.cpp b/mozilla/content/html/style/src/nsCSSLayout.cpp
index b21ce611ba6..cfed2ce1fde 100644
--- a/mozilla/content/html/style/src/nsCSSLayout.cpp
+++ b/mozilla/content/html/style/src/nsCSSLayout.cpp
@@ -54,8 +54,11 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
   PRIntn kidCount = aChildCount;
   while (--kidCount >= 0) {
     nscoord kidAscent = *aAscents++;
-    nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
-    nsIContent* kidContent = kid->GetContent();
+    nsIStyleContext* kidSC;
+    nsIContent* kidContent;
+
+    kid->GetStyleContext(aCX, kidSC);
+    kid->GetContent(kidContent);
     nsStyleMolecule* kidMol =
       (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     PRIntn verticalAlign = kidMol->verticalAlign;
@@ -124,7 +127,7 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
     y += kidRect.height;
     if (y > maxY) maxY = y;
 
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 
   nscoord lineHeight = maxY - minY;
@@ -135,8 +138,11 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
     kid = aFirstChild;
     while (--kidCount >= 0) {
       // Get kid's vertical align style data
-      nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
-      nsIContent* kidContent = kid->GetContent();
+      nsIStyleContext* kidSC;
+      nsIContent* kidContent;
+
+      kid->GetStyleContext(aCX, kidSC);
+      kid->GetContent(kidContent);
       nsStyleMolecule* kidMol =
         (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       PRIntn verticalAlign = kidMol->verticalAlign;
@@ -154,7 +160,7 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
         }
       }
 
-      kid = kid->GetNextSibling();
+      kid->GetNextSibling(kid);
     }
   }
 
@@ -197,7 +203,7 @@ void nsCSSLayout::HorizontallyPlaceChildren(nsIPresContext* aCX,
   while (--aChildCount >= 0) {
     kid->GetOrigin(origin);
     kid->MoveTo(origin.x + dx, origin.y);
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 }
 
@@ -213,8 +219,11 @@ void nsCSSLayout::RelativePositionChildren(nsIPresContext* aCX,
   nsPoint origin;
   nsIFrame* kid = aFirstChild;
   while (--aChildCount >= 0) {
-    nsIContent* kidContent = kid->GetContent();
-    nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
+    nsIContent* kidContent;
+    nsIStyleContext* kidSC;
+
+    kid->GetContent(kidContent);
+    kid->GetStyleContext(aCX, kidSC);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     if (NS_STYLE_POSITION_RELATIVE == kidMol->positionFlags) {
       kid->GetOrigin(origin);
@@ -224,6 +233,6 @@ void nsCSSLayout::RelativePositionChildren(nsIPresContext* aCX,
     }
     NS_RELEASE(kidContent);
     NS_RELEASE(kidSC);
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 }
diff --git a/mozilla/content/html/style/src/nsCSSStyleSheet.cpp b/mozilla/content/html/style/src/nsCSSStyleSheet.cpp
index bacdabafd92..685c07443e8 100644
--- a/mozilla/content/html/style/src/nsCSSStyleSheet.cpp
+++ b/mozilla/content/html/style/src/nsCSSStyleSheet.cpp
@@ -215,11 +215,13 @@ PRInt32 CSSStyleSheetImpl::RulesMatching(nsIPresContext* aPresContext,
       selector = selector->mNext;
       nsIFrame* frame = aParentFrame;
       while ((nsnull != selector) && (nsnull != frame)) { // check compound selectors
-        nsIContent* content = frame->GetContent();
+        nsIContent* content;
+         
+        frame->GetContent(content);
         if (SelectorMatches(selector, content)) {
           selector = selector->mNext;
         }
-        frame = frame->GetGeometricParent();
+        frame->GetGeometricParent(frame);
         NS_RELEASE(content);
       }
       if (nsnull == selector) { // ran out, it matched
diff --git a/mozilla/layout/base/nsPresContext.cpp b/mozilla/layout/base/nsPresContext.cpp
index 8615e15b419..ef54a55f0d0 100644
--- a/mozilla/layout/base/nsPresContext.cpp
+++ b/mozilla/layout/base/nsPresContext.cpp
@@ -190,7 +190,9 @@ void ImageLoader::UpdateFrames()
     nsIFrame* frame = (nsIFrame*) mFrames.ElementAt(i);
 
     // XXX installed colormap should be presentation-context/window state
-    nsIWidget* window = frame->GetWindow();
+    nsIWidget* window;
+     
+    frame->GetWindow(window);
     if (!gXXXInstalledColorMap && mImage) {
       nsColorMap* cmap = mImage->GetColorMap();
       if ((nsnull != cmap) && (cmap->NumColors > 0)) {
@@ -203,7 +205,9 @@ void ImageLoader::UpdateFrames()
     nsPoint offset;
     nsRect bounds;
     frame->GetRect(bounds);
-    nsIView* view = frame->GetOffsetFromView(offset);
+    nsIView* view;
+     
+    frame->GetOffsetFromView(offset, view);
     nsIViewManager* vm = view->GetViewManager();
     bounds.x = offset.x;
     bounds.y = offset.y;
@@ -360,7 +364,9 @@ nsIImage* nsPresContext::LoadImage(const nsString& aURL, nsIFrame* aForFrame)
   if (nsnull == mImageGroup) {
     // XXX this is bad; if we allow for subwindows that have different
     // rendering context's this won't work
-    nsIWidget* window = aForFrame->GetWindow();
+    nsIWidget* window;
+     
+    aForFrame->GetWindow(window);
     nsIRenderingContext* drawCtx = window->GetRenderingContext();
     drawCtx->Scale(mDeviceContext->GetAppUnitsToDevUnits(),
                    mDeviceContext->GetAppUnitsToDevUnits());
diff --git a/mozilla/layout/base/public/nsIFrame.h b/mozilla/layout/base/public/nsIFrame.h
index 25db0e7323b..a3a81a50bb5 100644
--- a/mozilla/layout/base/public/nsIFrame.h
+++ b/mozilla/layout/base/public/nsIFrame.h
@@ -34,12 +34,10 @@ class nsIView;
 class nsIWidget;
 class nsReflowCommand;
 
-struct nsStyleStruct;
-struct nsGUIEvent;
-
 struct nsPoint;
 struct nsRect;
 struct nsReflowMetrics;
+struct nsStyleStruct;
 
 // IID for the nsIFrame interface {12B193D0-9F70-11d1-8500-00A02468FAB6}
 #define NS_IFRAME_IID         \
@@ -81,13 +79,13 @@ public:
    * QueryInterface() defined in nsISupports. This is the only member
    * function of nsISupports that is public.
    */
-  NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
+  NS_IMETHOD  QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
 
   /**
    * Deletes this frame and each of its child frames (recursively calls
    * DeleteFrame() for each child)
    */
-  virtual void DeleteFrame() = 0;
+  NS_IMETHOD  DeleteFrame() = 0;
 
   /**
    * Get the content object associated with this frame. Adds a reference to
@@ -95,66 +93,73 @@ public:
    *
    * @see nsISupports#Release()
    */
-  virtual nsIContent*   GetContent() const = 0;
+  NS_IMETHOD  GetContent(nsIContent*& aContent) const = 0;
 
   /**
    * Get/Set the frame's index in parent.
    */
-  virtual PRInt32       GetIndexInParent() const = 0;
-  virtual void          SetIndexInParent(PRInt32 aIndexInParent) = 0;
+  NS_IMETHOD  GetIndexInParent(PRInt32& aIndexInParent) const = 0;
+  NS_IMETHOD  SetIndexInParent(PRInt32 aIndexInParent) = 0;
 
   /**
    * Get the style context associated with this frame. Note that GetStyleContext()
    * adds a reference to the style context so the caller must do a release.
    *
-   * @see #nsISupports#Release()
+   * @see nsISupports#Release()
    */
-  virtual nsIStyleContext* GetStyleContext(nsIPresContext* aContext) = 0;
-  virtual void             SetStyleContext(nsIStyleContext* aContext) = 0;
-
+  NS_IMETHOD  GetStyleContext(nsIPresContext*   aContext,
+                              nsIStyleContext*& aStyleContext) = 0;
+  NS_IMETHOD  SetStyleContext(nsIStyleContext* aContext) = 0;
 
   /**
-   *
    * Get the style data associated with this frame
-   *
-   *
    */
-  virtual nsStyleStruct* GetStyleData(const nsIID& aSID) = 0;
+  NS_IMETHOD  GetStyleData(const nsIID& aSID, nsStyleStruct*& aStyleStruct) = 0;
 
   /**
    * Accessor functions for geometric and content parent.
    */
-  virtual nsIFrame*     GetContentParent() const = 0;
-  virtual void          SetContentParent(const nsIFrame* aParent) = 0;
-  virtual nsIFrame*     GetGeometricParent() const = 0;
-  virtual void          SetGeometricParent(const nsIFrame* aParent) = 0;
+  NS_IMETHOD  GetContentParent(nsIFrame*& aParent) const = 0;
+  NS_IMETHOD  SetContentParent(const nsIFrame* aParent) = 0;
+  NS_IMETHOD  GetGeometricParent(nsIFrame*& aParent) const = 0;
+  NS_IMETHOD  SetGeometricParent(const nsIFrame* aParent) = 0;
 
   /**
    * Bounding rect of the frame. The values are in twips, and the origin is
    * relative to the upper-left of the geometric parent. The size includes the
    * content area, borders, and padding.
    */
-  virtual nsRect        GetRect() const = 0;
-  virtual void          GetRect(nsRect& aRect) const = 0;
-  virtual void          GetOrigin(nsPoint& aPoint) const = 0;
-  virtual nscoord       GetWidth() const = 0;
-  virtual nscoord       GetHeight() const = 0;
-  virtual void          SetRect(const nsRect& aRect) = 0;
-  virtual void          MoveTo(nscoord aX, nscoord aY) = 0;
-  virtual void          SizeTo(nscoord aWidth, nscoord aHeight) = 0;
+  NS_IMETHOD  GetRect(nsRect& aRect) const = 0;
+  NS_IMETHOD  GetOrigin(nsPoint& aPoint) const = 0;
+  NS_IMETHOD  GetSize(nsSize& aSize) const = 0;
+  NS_IMETHOD  SetRect(const nsRect& aRect) = 0;
+  NS_IMETHOD  MoveTo(nscoord aX, nscoord aY) = 0;
+  NS_IMETHOD  SizeTo(nscoord aWidth, nscoord aHeight) = 0;
+
+  /**
+   * Child frame enumeration
+   */
+  NS_IMETHOD  ChildCount(PRInt32& aChildCount) const = 0;
+  NS_IMETHOD  ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const = 0;
+  NS_IMETHOD  IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const = 0;
+  NS_IMETHOD  FirstChild(nsIFrame*& aFirstChild) const = 0;
+  NS_IMETHOD  NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const = 0;
+  NS_IMETHOD  PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const = 0;
+  NS_IMETHOD  LastChild(nsIFrame*& aLastChild) const = 0;
 
   /**
    * Painting
    */
-  virtual void          Paint(nsIPresContext&      aPresContext,
-                              nsIRenderingContext& aRenderingContext,
-                              const nsRect&        aDirtyRect) = 0;
+  NS_IMETHOD  Paint(nsIPresContext&      aPresContext,
+                    nsIRenderingContext& aRenderingContext,
+                    const nsRect&        aDirtyRect) = 0;
 
   /**
    * Handle an event. 
    */
-  virtual nsEventStatus   HandleEvent(nsIPresContext& aPresContext,
-                                      nsGUIEvent*     aEvent) = 0;
+  NS_IMETHOD  HandleEvent(nsIPresContext& aPresContext,
+                          nsGUIEvent*     aEvent,
+                          nsEventStatus&  aEventStatus) = 0;
 
   /**
    * Get the cursor for a given point in the frame tree. The
@@ -162,20 +167,10 @@ public:
    * no cursor is wanted). In addition, if a cursor is desired
    * then *aFrame is set to the frame that wants the cursor.
    */
-  virtual PRInt32       GetCursorAt(nsIPresContext& aPresContext,
-                                    const nsPoint& aPoint,
-                                    nsIFrame** aFrame) = 0;
-
-  /**
-   * Child frame enumeration
-   */
-  virtual PRInt32       ChildCount() const = 0;
-  virtual nsIFrame*     ChildAt(PRInt32 aIndex) const = 0;
-  virtual PRInt32       IndexOf(const nsIFrame* aChild) const = 0;
-  virtual nsIFrame*     FirstChild() const = 0;
-  virtual nsIFrame*     NextChild(const nsIFrame* aChild) const = 0;
-  virtual nsIFrame*     PrevChild(const nsIFrame* aChild) const = 0;
-  virtual nsIFrame*     LastChild() const = 0;
+  NS_IMETHOD  GetCursorAt(nsIPresContext& aPresContext,
+                          const nsPoint&  aPoint,
+                          nsIFrame**      aFrame,
+                          PRInt32&        aCursor) = 0;
 
   /**
    * Reflow status returned by the reflow methods
@@ -206,10 +201,11 @@ public:
    *          a maximum element size. The maximum element size must be less than or
    *          equal to your desired size.
    */
-  virtual ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                                     nsReflowMetrics& aDesiredSize,
-                                     const nsSize&    aMaxSize,
-                                     nsSize*          aMaxElementSize) = 0;
+  NS_IMETHOD  ResizeReflow(nsIPresContext*  aPresContext,
+                           nsReflowMetrics& aDesiredSize,
+                           const nsSize&    aMaxSize,
+                           nsSize*          aMaxElementSize,
+                           ReflowStatus&    aStatus) = 0;
 
   /**
    * Post-processing reflow method invoked when justification is enabled.
@@ -218,8 +214,8 @@ public:
    * @param aAvailableSpace The amount of available space that the frame
    *         should distribute internally.
    */
-  virtual void          JustifyReflow(nsIPresContext*  aPresContext,
-                                      nscoord          aAvailableSpace) = 0;
+  NS_IMETHOD  JustifyReflow(nsIPresContext* aPresContext,
+                            nscoord         aAvailableSpace) = 0;
 
   /**
    * Incremental reflow. The reflow command contains information about the
@@ -243,10 +239,11 @@ public:
    * @see nsReflowCommand#GetTarget()
    * @see nsReflowCommand#GetType()
    */
-  virtual ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                          nsReflowMetrics& aDesiredSize,
-                                          const nsSize&    aMaxSize,
-                                          nsReflowCommand& aReflowCommand) = 0;
+  NS_IMETHOD  IncrementalReflow(nsIPresContext*  aPresContext,
+                                nsReflowMetrics& aDesiredSize,
+                                const nsSize&    aMaxSize,
+                                nsReflowCommand& aReflowCommand,
+                                ReflowStatus&    aStatus) = 0;
 
   /**
    * This call is invoked when content is appended to the content
@@ -256,9 +253,9 @@ public:
    * the call must generate reflow commands that will incrementally
    * reflow and repair the damaged portion of the frame tree.
    */
-  virtual void ContentAppended(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer) = 0;
+  NS_IMETHOD  ContentAppended(nsIPresShell*   aShell,
+                              nsIPresContext* aPresContext,
+                              nsIContent*     aContainer) = 0;
 
   /**
    * This call is invoked when content is inserted in the content
@@ -271,11 +268,11 @@ public:
    * @param aIndexInParent the index in the content container where
    *          the new content was inserted.
    */
-  virtual void ContentInserted(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer,
-                               nsIContent* aChild,
-                               PRInt32 aIndexInParent) = 0;
+  NS_IMETHOD  ContentInserted(nsIPresShell*   aShell,
+                              nsIPresContext* aPresContext,
+                              nsIContent*     aContainer,
+                              nsIContent*     aChild,
+                              PRInt32         aIndexInParent) = 0;
 
   /**
    * This call is invoked when content is replaced in the content
@@ -288,12 +285,12 @@ public:
    *
    * @param aIndexInParent the index in the content container where
    *          the new content was inserted.  */
-  virtual void ContentReplaced(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer,
-                               nsIContent* aOldChild,
-                               nsIContent* aNewChild,
-                               PRInt32 aIndexInParent) = 0;
+  NS_IMETHOD  ContentReplaced(nsIPresShell*   aShell,
+                              nsIPresContext* aPresContext,
+                              nsIContent*     aContainer,
+                              nsIContent*     aOldChild,
+                              nsIContent*     aNewChild,
+                              PRInt32         aIndexInParent) = 0;
 
   /**
    * This call is invoked when content is deleted from the content
@@ -306,11 +303,11 @@ public:
    * @param aIndexInParent the index in the content container where
    *          the new content was deleted.
    */
-  virtual void ContentDeleted(nsIPresShell* aShell,
-                              nsIPresContext* aPresContext,
-                              nsIContent* aContainer,
-                              nsIContent* aChild,
-                              PRInt32 aIndexInParent) = 0;
+  NS_IMETHOD  ContentDeleted(nsIPresShell*   aShell,
+                             nsIPresContext* aPresContext,
+                             nsIContent*     aContainer,
+                             nsIContent*     aChild,
+                             PRInt32         aIndexInParent) = 0;
 
   /**
    * Return the reflow metrics for this frame. If the frame is a
@@ -320,43 +317,45 @@ public:
    * ascent of the line's children). Note that the metrics returned
    * apply to the frame as it exists at the time of the call.
    */
-  virtual void          GetReflowMetrics(nsIPresContext*  aPresContext,
-                                         nsReflowMetrics& aMetrics) = 0;
+  NS_IMETHOD  GetReflowMetrics(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aMetrics) = 0;
 
   /**
    * Flow member functions. CreateContinuingFrame() is responsible for appending
    * the continuing frame to the flow.
    */
-  virtual PRBool        IsSplittable() const = 0;
-  virtual nsIFrame*     CreateContinuingFrame(nsIPresContext* aPresContext,
-                                              nsIFrame*       aParent) = 0;
-  virtual nsIFrame*     GetPrevInFlow() const = 0;
-  virtual void          SetPrevInFlow(nsIFrame*) = 0;
-  virtual nsIFrame*     GetNextInFlow() const = 0;
-  virtual void          SetNextInFlow(nsIFrame*) = 0;
+  NS_IMETHOD  IsSplittable(PRBool& aIsSplittable) const = 0;
+  NS_IMETHOD  CreateContinuingFrame(nsIPresContext* aPresContext,
+                                    nsIFrame*       aParent,
+                                    nsIFrame*&      aContinuingFrame) = 0;
 
-  virtual void          AppendToFlow(nsIFrame* aAfterFrame) = 0;
-  virtual void          PrependToFlow(nsIFrame* aBeforeFrame) = 0;
-  virtual void          RemoveFromFlow() = 0;
-  virtual void          BreakFromPrevFlow() = 0;
-  virtual void          BreakFromNextFlow() = 0;
+  NS_IMETHOD  GetPrevInFlow(nsIFrame*& aPrevInFlow) const = 0;
+  NS_IMETHOD  SetPrevInFlow(nsIFrame*) = 0;
+  NS_IMETHOD  GetNextInFlow(nsIFrame*& aNextInFlow) const = 0;
+  NS_IMETHOD  SetNextInFlow(nsIFrame*) = 0;
+
+  NS_IMETHOD  AppendToFlow(nsIFrame* aAfterFrame) = 0;
+  NS_IMETHOD  PrependToFlow(nsIFrame* aBeforeFrame) = 0;
+  NS_IMETHOD  RemoveFromFlow() = 0;
+  NS_IMETHOD  BreakFromPrevFlow() = 0;
+  NS_IMETHOD  BreakFromNextFlow() = 0;
 
   /**
    * Accessor functions to get/set the associated view object
    */
-  virtual nsIView*      GetView() const = 0;  // may be null
-  virtual void          SetView(nsIView* aView) = 0;
+  NS_IMETHOD  GetView(nsIView*& aView) const = 0;  // may be null
+  NS_IMETHOD  SetView(nsIView* aView) = 0;
 
   /**
    * Find the first geometric parent that has a view
    */
-  virtual nsIFrame*     GetParentWithView() const = 0;
+  NS_IMETHOD  GetParentWithView(nsIFrame*& aParent) const = 0;
 
   /**
    * Returns the offset from this frame to the closest geometric parent that
    * has a view. Also returns the containing view or null in case of error
    */
-  virtual nsIView*      GetOffsetFromView(nsPoint& aOffset) const = 0;
+  NS_IMETHOD  GetOffsetFromView(nsPoint& aOffset, nsIView*& aView) const = 0;
 
   /**
    * Returns the window that contains this frame. If this frame has a
@@ -364,18 +363,18 @@ public:
    * returned, otherwise this frame's geometric parent is checked
    * recursively upwards.
    */
-  virtual nsIWidget*    GetWindow() const = 0;
+  NS_IMETHOD  GetWindow(nsIWidget*&) const = 0;
 
   /**
    * Sibling pointer used to link together frames
    */
-  virtual nsIFrame*     GetNextSibling() const = 0;
-  virtual void          SetNextSibling(nsIFrame* aNextSibling) = 0;
+  NS_IMETHOD  GetNextSibling(nsIFrame*& aNextSibling) const = 0;
+  NS_IMETHOD  SetNextSibling(nsIFrame* aNextSibling) = 0;
 
   // Debugging
-  virtual void          List(FILE* out = stdout, PRInt32 aIndent = 0) const= 0;
-  virtual void          ListTag(FILE* out = stdout) const = 0;
-  virtual void          VerifyTree() const = 0;
+  NS_IMETHOD  List(FILE* out = stdout, PRInt32 aIndent = 0) const= 0;
+  NS_IMETHOD  ListTag(FILE* out = stdout) const = 0;
+  NS_IMETHOD  VerifyTree() const = 0;
 
   // Show frame borders when rendering
   static NS_LAYOUT void ShowFrameBorders(PRBool aEnable);
diff --git a/mozilla/layout/base/public/nsIRunaround.h b/mozilla/layout/base/public/nsIRunaround.h
index f7fe3a7e549..286339f9199 100644
--- a/mozilla/layout/base/public/nsIRunaround.h
+++ b/mozilla/layout/base/public/nsIRunaround.h
@@ -65,11 +65,12 @@ public:
    *
    * @see nsISpaceManager#Translate()
    */
-  virtual nsIFrame::ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                                               nsISpaceManager* aSpaceManager,
-                                               const nsSize&    aMaxSize,
-                                               nsRect&          aDesiredRect,
-                                               nsSize*          aMaxElementSize) = 0;
+  NS_IMETHOD  ResizeReflow(nsIPresContext*         aPresContext,
+                           nsISpaceManager*        aSpaceManager,
+                           const nsSize&           aMaxSize,
+                           nsRect&                 aDesiredRect,
+                           nsSize*                 aMaxElementSize,
+                           nsIFrame::ReflowStatus& aStatus) = 0;
 
   /**
    * Incremental reflow. The reflow command contains information about the
@@ -100,11 +101,12 @@ public:
    * @param aReflowCommand the reflow command contains information about the
    *          type of change.
    */
-  virtual nsIFrame::ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                                    nsISpaceManager* aSpaceManager,
-                                                    const nsSize&    aMaxSize,
-                                                    nsRect&          aDesiredRect,
-                                                    nsReflowCommand& aReflowCommand) = 0;
+  NS_IMETHOD IncrementalReflow(nsIPresContext*         aPresContext,
+                               nsISpaceManager*        aSpaceManager,
+                               const nsSize&           aMaxSize,
+                               nsRect&                 aDesiredRect,
+                               nsReflowCommand&        aReflowCommand,
+                               nsIFrame::ReflowStatus& aStatus) = 0;
 };
 
 #endif /* nsIRunaround_h___ */
diff --git a/mozilla/layout/base/src/nsContainerFrame.cpp b/mozilla/layout/base/src/nsContainerFrame.cpp
index e1f8cf45427..5283f6180fa 100644
--- a/mozilla/layout/base/src/nsContainerFrame.cpp
+++ b/mozilla/layout/base/src/nsContainerFrame.cpp
@@ -51,7 +51,9 @@ nsContainerFrame::~nsContainerFrame()
   // we do all of this before our base class releases it's hold on the
   // view.
   for (nsIFrame* child = mFirstChild; child; ) {
-    nsIFrame* nextChild = child->GetNextSibling();
+    nsIFrame* nextChild;
+     
+    child->GetNextSibling(nextChild);
     child->DeleteFrame();
     child = nextChild;
   }
@@ -80,108 +82,122 @@ void nsContainerFrame::PrepareContinuingFrame(nsIPresContext* aPresContext,
   NS_RELEASE(styleContext);
 }
 
-nsIFrame*
-nsContainerFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                        nsIFrame*       aParent)
+NS_METHOD nsContainerFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                  nsIFrame*       aParent,
+                                                  nsIFrame*&      aContinuingFrame)
 {
   nsIContentDelegate* contentDelegate = mContent->GetDelegate(aPresContext);
-  nsContainerFrame* continuingFrame = (nsContainerFrame*)
-    contentDelegate->CreateFrame(aPresContext, mContent, mIndexInParent,
-                                 aParent);
+
+  aContinuingFrame = contentDelegate->CreateFrame(aPresContext, mContent,
+                                                  mIndexInParent, aParent);
   NS_RELEASE(contentDelegate);
 
-  PrepareContinuingFrame(aPresContext, aParent, continuingFrame);
-
-  return continuingFrame;
+  PrepareContinuingFrame(aPresContext, aParent, (nsContainerFrame*)aContinuingFrame);
+  return NS_OK;
 }
 
 
 /////////////////////////////////////////////////////////////////////////////
 // Child frame enumeration
 
-PRInt32 nsContainerFrame::ChildCount() const
+NS_METHOD nsContainerFrame::ChildCount(PRInt32& aChildCount) const
 {
-  return mChildCount;
+  aChildCount = mChildCount;
+  return NS_OK;
 }
 
-nsIFrame* nsContainerFrame::ChildAt(PRInt32 aIndex) const
+NS_METHOD nsContainerFrame::ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const
 {
   // Check that the index is in range
   if ((aIndex < 0) || (aIndex >= mChildCount)) {
-    return nsnull;
+    aFrame = nsnull;
+    return NS_OK;
   }
 
-  nsIFrame* result = mFirstChild;
-
-  while ((aIndex-- > 0) && (result != nsnull)) {
-    result = result->GetNextSibling();
+  aFrame = mFirstChild;
+  while ((aIndex-- > 0) && (aFrame != nsnull)) {
+    aFrame->GetNextSibling(aFrame);
   }
-  return result;
+  return NS_OK;
 }
 
-PRInt32 nsContainerFrame::IndexOf(const nsIFrame* aChild) const
+NS_METHOD nsContainerFrame::IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const
 {
-  PRInt32 result = -1;
+  aIndex = -1;  // initialize out parameter
 
-  for (nsIFrame* f = mFirstChild; f != nsnull; f = f->GetNextSibling()) {
-    result++;
+  for (nsIFrame* f = mFirstChild; f != nsnull; f->GetNextSibling(f)) {
+    aIndex++;
 
     if (f == aChild)
       break;
   }
 
-  return result;
+  return NS_OK;
 }
 
-nsIFrame* nsContainerFrame::FirstChild() const
+NS_METHOD nsContainerFrame::FirstChild(nsIFrame*& aFirstChild) const
 {
-  return mFirstChild;
+  aFirstChild = mFirstChild;
+  return NS_OK;
 }
 
-nsIFrame* nsContainerFrame::NextChild(const nsIFrame* aChild) const
+NS_METHOD nsContainerFrame::NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const
 {
   NS_PRECONDITION(aChild != nsnull, "null pointer");
-  return aChild->GetNextSibling();
+  aChild->GetNextSibling(aNextChild);
+  return NS_OK;
 }
 
-nsIFrame* nsContainerFrame::PrevChild(const nsIFrame* aChild) const
+NS_METHOD nsContainerFrame::PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const
 {
   NS_PRECONDITION(aChild != nsnull, "null pointer");
 
-  nsIFrame*  result;
-
   if (mFirstChild == aChild) {
-    result = nsnull;
+    aPrevChild = nsnull;
   } else {
-    result = mFirstChild;
+    aPrevChild = mFirstChild;
 
-    while ((result != nsnull) && (result->GetNextSibling() != aChild))
-      result = result->GetNextSibling();
+    while ((aPrevChild != nsnull)) {
+      nsIFrame* nextChild;
+         
+      aPrevChild->GetNextSibling(nextChild);
+      if (nextChild == aChild) {
+        break;
+      }
+
+      aPrevChild = nextChild;
+    }
   }
 
-  return result;
+  return NS_OK;
 }
 
-nsIFrame* nsContainerFrame::LastChild() const
+NS_METHOD nsContainerFrame::LastChild(nsIFrame*& aLastChild) const
 {
-  nsIFrame* result = mFirstChild;
+  aLastChild = mFirstChild;
 
-  if (result) {
-    while (result->GetNextSibling() != nsnull)
-      result = result->GetNextSibling();
+  if (nsnull != aLastChild) {
+    nsIFrame* nextChild;
+
+    aLastChild->GetNextSibling(nextChild);
+    while (nextChild != nsnull) {
+      aLastChild = nextChild;
+      aLastChild->GetNextSibling(nextChild);
+    }
   }
 
-  return result;
+  return NS_OK;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Painting
 
-void nsContainerFrame::Paint(nsIPresContext&      aPresContext,
-                             nsIRenderingContext& aRenderingContext,
-                             const nsRect&        aDirtyRect)
+NS_METHOD nsContainerFrame::Paint(nsIPresContext&      aPresContext,
+                                  nsIRenderingContext& aRenderingContext,
+                                  const nsRect&        aDirtyRect)
 {
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 // aDirtyRect is in our coordinate system
@@ -192,7 +208,9 @@ void nsContainerFrame::PaintChildren(nsIPresContext&      aPresContext,
 {
   nsIFrame* kid = mFirstChild;
   while (nsnull != kid) {
-    nsIView *pView = kid->GetView();
+    nsIView *pView;
+     
+    kid->GetView(pView);
     if (nsnull == pView) {
       nsRect kidRect;
       kid->GetRect(kidRect);
@@ -212,19 +230,21 @@ void nsContainerFrame::PaintChildren(nsIPresContext&      aPresContext,
         aRenderingContext.PopState();
       }
     }
-    else
+    else {
       NS_RELEASE(pView);
-    kid = kid->GetNextSibling();
+    }
+    kid->GetNextSibling(kid);
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Events
 
-nsEventStatus nsContainerFrame::HandleEvent(nsIPresContext& aPresContext, 
-                                     nsGUIEvent*     aEvent)
+NS_METHOD nsContainerFrame::HandleEvent(nsIPresContext& aPresContext, 
+                                        nsGUIEvent*     aEvent,
+                                        nsEventStatus&  aEventStatus)
 {
-  nsEventStatus  retval = nsEventStatus_eIgnore;
+  aEventStatus = nsEventStatus_eIgnore;
 
   nsIFrame* kid = mFirstChild;
   while (nsnull != kid) {
@@ -232,21 +252,22 @@ nsEventStatus nsContainerFrame::HandleEvent(nsIPresContext& aPresContext,
     kid->GetRect(kidRect);
     if (kidRect.Contains(aEvent->point)) {
       aEvent->point.MoveBy(-kidRect.x, -kidRect.y);
-      retval = kid->HandleEvent(aPresContext, aEvent);
+      kid->HandleEvent(aPresContext, aEvent, aEventStatus);
       aEvent->point.MoveBy(kidRect.x, kidRect.y);
-      return retval;
+      break;
     }
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 
-  return retval;
+  return NS_OK;
 }
 
-PRInt32 nsContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
-                                      const nsPoint& aPoint,
-                                      nsIFrame** aFrame)
+NS_METHOD nsContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
+                                        const nsPoint&  aPoint,
+                                        nsIFrame**      aFrame,
+                                        PRInt32&        aCursor)
 {
-  PRInt32 retval = NS_STYLE_CURSOR_INHERIT;
+  aCursor = NS_STYLE_CURSOR_INHERIT;
 
   nsIFrame* kid = mFirstChild;
   nsPoint tmp;
@@ -255,12 +276,12 @@ PRInt32 nsContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
     kid->GetRect(kidRect);
     if (kidRect.Contains(aPoint)) {
       tmp.MoveTo(aPoint.x - kidRect.x, aPoint.y - kidRect.y);
-      retval = kid->GetCursorAt(aPresContext, tmp, aFrame);
-      return retval;
+      kid->GetCursorAt(aPresContext, tmp, aFrame, aCursor);
+      break;
     }
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
-  return retval;
+  return NS_OK;
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -293,13 +314,13 @@ PRInt32 nsContainerFrame::NextChildOffset() const
 void nsContainerFrame::SetFirstContentOffset(const nsIFrame* aFirstChild)
 {
   NS_PRECONDITION(nsnull != aFirstChild, "bad argument");
-  NS_PRECONDITION(aFirstChild->GetGeometricParent() == this, "bad geometric parent");
+  NS_PRECONDITION(IsChild(aFirstChild), "bad geometric parent");
 
   if (ChildIsPseudoFrame(aFirstChild)) {
     nsContainerFrame* pseudoFrame = (nsContainerFrame*)aFirstChild;
     mFirstContentOffset = pseudoFrame->mFirstContentOffset;
   } else {
-    mFirstContentOffset = aFirstChild->GetIndexInParent();
+    aFirstChild->GetIndexInParent(mFirstContentOffset);
   }
 }
 
@@ -311,7 +332,7 @@ void nsContainerFrame::SetFirstContentOffset(const nsIFrame* aFirstChild)
 void nsContainerFrame::SetLastContentOffset(const nsIFrame* aLastChild)
 {
   NS_PRECONDITION(nsnull != aLastChild, "bad argument");
-  NS_PRECONDITION(aLastChild->GetGeometricParent() == this, "bad geometric parent");
+  NS_PRECONDITION(IsChild(aLastChild), "bad geometric parent");
 
   if (ChildIsPseudoFrame(aLastChild)) {
     nsContainerFrame* pseudoFrame = (nsContainerFrame*)aLastChild;
@@ -321,15 +342,11 @@ void nsContainerFrame::SetLastContentOffset(const nsIFrame* aLastChild)
 #endif
     mLastContentIsComplete = pseudoFrame->mLastContentIsComplete;
   } else {
-    mLastContentOffset = aLastChild->GetIndexInParent();
+    aLastChild->GetIndexInParent(mLastContentOffset);
   }
 #ifdef NS_DEBUG
   if (mLastContentOffset < mFirstContentOffset) {
-    nsIFrame* top = this;
-    while (top->GetGeometricParent() != nsnull) {
-      top = top->GetGeometricParent();
-    }
-    top->List();
+    DumpTree();
   }
 #endif
   NS_ASSERTION(mLastContentOffset >= mFirstContentOffset, "unexpected content mapping");
@@ -344,8 +361,9 @@ PRBool nsContainerFrame::IsPseudoFrame() const
   PRBool  result = PR_FALSE;
 
   if (nsnull != mGeometricParent) {
-    nsIContent* parentContent = mGeometricParent->GetContent();
-
+    nsIContent* parentContent;
+     
+    mGeometricParent->GetContent(parentContent);
     if (parentContent == mContent) {
       result = PR_TRUE;
     }
@@ -358,10 +376,13 @@ PRBool nsContainerFrame::IsPseudoFrame() const
 // Returns true if aChild is being used as a pseudo frame
 PRBool nsContainerFrame::ChildIsPseudoFrame(const nsIFrame* aChild) const
 {
-  NS_PRECONDITION(aChild->GetGeometricParent() == (nsIFrame*)this, "bad geometric parent");
-  nsIContent* childContent = aChild->GetContent();
-  PRBool      result = PRBool(childContent == mContent);
+  NS_PRECONDITION(IsChild(aChild), "bad geometric parent");
 
+  nsIContent* childContent;
+  PRBool      result;
+   
+  aChild->GetContent(childContent);
+  result = PRBool(childContent == mContent);
   NS_RELEASE(childContent);
   return result;
 }
@@ -381,18 +402,22 @@ nsContainerFrame::ReflowChild(nsIFrame*        aKidFrame,
                               const nsSize&    aMaxSize,
                               nsSize*          aMaxElementSize)
 {
-  ReflowStatus status = aKidFrame->ResizeReflow(aPresContext, aDesiredSize,
-                          aMaxSize, aMaxElementSize);
+  ReflowStatus status;
+                                                  
+  aKidFrame->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, status);
 
   if (frComplete == status) {
-    nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow();
+    nsIFrame* kidNextInFlow;
+     
+    aKidFrame->GetNextInFlow(kidNextInFlow);
     if (nsnull != kidNextInFlow) {
       // Remove all of the childs next-in-flows. Make sure that we ask
       // the right parent to do the removal (it's possible that the
       // parent is not this because we are executing pullup code)
-      nsContainerFrame* parent = (nsContainerFrame*)
-        aKidFrame->GetGeometricParent();
-      parent->DeleteChildsNextInFlow(aKidFrame);
+      nsIFrame* parent;
+       
+      aKidFrame->GetGeometricParent(parent);
+      ((nsContainerFrame*)parent)->DeleteChildsNextInFlow(aKidFrame);
     }
   }
   return status;
@@ -421,8 +446,8 @@ nsContainerFrame::ReflowChild(nsIFrame*        aKidFrame,
   // Does the child frame support interface nsIRunaround?
   if (NS_OK == aKidFrame->QueryInterface(kIRunaroundIID, (void**)&reflowRunaround)) {
     // Yes, the child frame wants to interact directly with the space manager
-    status = reflowRunaround->ResizeReflow(aPresContext, aSpaceManager, aMaxSize,
-                                           aDesiredRect, aMaxElementSize);
+    reflowRunaround->ResizeReflow(aPresContext, aSpaceManager, aMaxSize,
+                                  aDesiredRect, aMaxElementSize, status);
   } else {
     // No, use interface nsIFrame instead.
     nsReflowMetrics desiredSize;
@@ -456,8 +481,9 @@ nsContainerFrame::ReflowChild(nsIFrame*        aKidFrame,
     }
 
     nsSize  availSize(rects->width, aMaxSize.height);
-    status = aKidFrame->ResizeReflow(aPresContext, desiredSize, availSize,
-                                     aMaxElementSize);
+
+    aKidFrame->ResizeReflow(aPresContext, desiredSize, availSize,
+                            aMaxElementSize, status);
 
     // Return the desired rect
     aDesiredRect.x = rects->x;
@@ -467,14 +493,17 @@ nsContainerFrame::ReflowChild(nsIFrame*        aKidFrame,
   }
 
   if (frComplete == status) {
-    nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow();
+    nsIFrame* kidNextInFlow;
+     
+    aKidFrame->GetNextInFlow(kidNextInFlow);
     if (nsnull != kidNextInFlow) {
       // Remove all of the childs next-in-flows. Make sure that we ask
       // the right parent to do the removal (it's possible that the
       // parent is not this because we are executing pullup code)
-      nsContainerFrame* parent = (nsContainerFrame*)
-        aKidFrame->GetGeometricParent();
-      parent->DeleteChildsNextInFlow(aKidFrame);
+      nsIFrame* parent;
+       
+      aKidFrame->GetGeometricParent(parent);
+      ((nsContainerFrame*)parent)->DeleteChildsNextInFlow(aKidFrame);
     }
   }
   return status;
@@ -492,28 +521,42 @@ nsContainerFrame::ReflowChild(nsIFrame*        aKidFrame,
  */
 PRBool nsContainerFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
 {
-  NS_PRECONDITION(aChild->GetGeometricParent() == (nsIFrame*)this, "bad geometric parent");
-  NS_PRECONDITION(nsnull != aChild->GetNextInFlow(), "null next-in-flow");
+  NS_PRECONDITION(IsChild(aChild), "bad geometric parent");
 
-  nsIFrame*         nextInFlow = aChild->GetNextInFlow();
-  nsContainerFrame* parent = (nsContainerFrame*)nextInFlow->GetGeometricParent();
+  nsIFrame*         nextInFlow;
+  nsContainerFrame* parent;
+   
+  aChild->GetNextInFlow(nextInFlow);
+  NS_PRECONDITION(nsnull != nextInFlow, "null next-in-flow");
+  nextInFlow->GetGeometricParent((nsIFrame*&)parent);
 
-  // If the next-in-flow has a next-in-flow then delete it too (and
+  // If the next-in-flow has a next-in-flow then delete it, too (and
   // delete it first).
-  if (nsnull != nextInFlow->GetNextInFlow()) {
-    parent->DeleteChildsNextInFlow(nextInFlow);
+  nsIFrame* nextNextInFlow;
+
+  nextInFlow->GetNextInFlow(nextNextInFlow);
+  if (nsnull != nextNextInFlow) {
+    ((nsContainerFrame*)parent)->DeleteChildsNextInFlow(nextInFlow);
   }
 
-  NS_ASSERTION((0 == nextInFlow->ChildCount()) &&
-               (nsnull == nextInFlow->FirstChild()),
-               "deleting !empty next-in-flow");
+#ifdef NS_DEBUG
+  PRInt32   childCount;
+  nsIFrame* firstChild;
+
+  nextInFlow->ChildCount(childCount);
+  nextInFlow->FirstChild(firstChild);
+
+  NS_ASSERTION(childCount == 0, "deleting !empty next-in-flow");
+
+  NS_ASSERTION((0 == childCount) && (nsnull == firstChild), "deleting !empty next-in-flow");
+#endif
 
   // Disconnect the next-in-flow from the flow list
   nextInFlow->BreakFromPrevFlow();
 
   // Take the next-in-flow out of the parent's child list
   if (parent->mFirstChild == nextInFlow) {
-    parent->mFirstChild = nextInFlow->GetNextSibling();
+    nextInFlow->GetNextSibling(parent->mFirstChild);
     if (nsnull != parent->mFirstChild) {
       parent->SetFirstContentOffset(parent->mFirstChild);
       if (parent->IsPseudoFrame()) {
@@ -530,15 +573,19 @@ PRBool nsContainerFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
     // will be repaired.
 
   } else {
+    nsIFrame* nextSibling;
+
     // Because the next-in-flow is not the first child of the parent
     // we know that it shares a parent with aChild. Therefore, we need
     // to capture the next-in-flow's next sibling (in case the
     // next-in-flow is the last next-in-flow for aChild AND the
     // next-in-flow is not the last child in parent)
-    NS_ASSERTION(aChild->GetGeometricParent() == parent, "screwy flow");
-    NS_ASSERTION(aChild->GetNextSibling() == nextInFlow, "unexpected sibling");
+    NS_ASSERTION(((nsContainerFrame*)parent)->IsChild(aChild), "screwy flow");
+    aChild->GetNextSibling(nextSibling);
+    NS_ASSERTION(nextSibling == nextInFlow, "unexpected sibling");
 
-    aChild->SetNextSibling(nextInFlow->GetNextSibling());
+    nextInFlow->GetNextSibling(nextSibling);
+    aChild->SetNextSibling(nextSibling);
   }
 
   // Delete the next-in-flow frame and adjust it's parent's child count
@@ -548,9 +595,11 @@ PRBool nsContainerFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
   if (0 != parent->mChildCount) {
     parent->CheckContentOffsets();
   }
+
+  aChild->GetNextInFlow(nextInFlow);
+  NS_POSTCONDITION(nsnull == nextInFlow, "non null next-in-flow");
 #endif
 
-  NS_POSTCONDITION(nsnull == aChild->GetNextInFlow(), "non null next-in-flow");
   return PR_TRUE;
 }
 
@@ -605,7 +654,12 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
 {
   NS_PRECONDITION(nsnull != aFromChild, "null pointer");
   NS_PRECONDITION(nsnull != aPrevSibling, "pushing first child");
-  NS_PRECONDITION(aPrevSibling->GetNextSibling() == aFromChild, "bad prev sibling");
+#ifdef NS_DEBUG
+  nsIFrame* prevNextSibling;
+
+  aPrevSibling->GetNextSibling(prevNextSibling);
+  NS_PRECONDITION(prevNextSibling == aFromChild, "bad prev sibling");
+#endif
 
   // Disconnect aFromChild from its previous sibling
   aPrevSibling->SetNextSibling(nsnull);
@@ -631,7 +685,7 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
 #endif
     // Compute the number of children being pushed, and for each child change
     // its geometric parent. Remember the last child
-    for (nsIFrame* f = aFromChild; nsnull != f; f = f->GetNextSibling()) {
+    for (nsIFrame* f = aFromChild; nsnull != f; f->GetNextSibling(f)) {
       numChildren++;
 #ifdef NOISY
       printf("  ");
@@ -640,7 +694,11 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
 #endif
       lastChild = f;
       f->SetGeometricParent(nextInFlow);
-      if (this == f->GetContentParent()) {
+
+      nsIFrame* contentParent;
+
+      f->GetContentParent(contentParent);
+      if (this == contentParent) {
         f->SetContentParent(nextInFlow);
       }
     }
@@ -653,14 +711,15 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
     // Update our next-in-flow's first content offset and child count
     nextInFlow->SetFirstContentOffset(aFromChild);
     if (0 == nextInFlow->mChildCount) {
-      NS_ASSERTION(nextInFlow->LastChild() == lastChild, "unexpected last child");
       nextInFlow->SetLastContentOffset(lastChild);
       // If the child is pseudo-frame then SetLastContentOffset will
       // have updated the next-in-flow's mLastContentIsComplete flag,
       // otherwise we have to do it.
       if (!nextInFlow->ChildIsPseudoFrame(lastChild)) {
-        nextInFlow->mLastContentIsComplete =
-          PRBool(nsnull == lastChild->GetNextInFlow());
+        nsIFrame* lastChildNextInFlow;
+
+        lastChild->GetNextInFlow(lastChildNextInFlow);
+        nextInFlow->mLastContentIsComplete = PRBool(nsnull == lastChildNextInFlow);
       }
     }
     nextInFlow->mChildCount += numChildren;
@@ -701,12 +760,12 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
 // Note: mLastContentIsComplete is not set correctly by this routine
 // (we don't always know the correct value at this time)
 nsIFrame* nsContainerFrame::PullUpOneChild(nsContainerFrame* aNextInFlow,
-                                           nsIFrame* aLastChild)
+                                           nsIFrame*         aLastChild)
 {
   NS_PRECONDITION(nsnull != aNextInFlow, "null ptr");
 #ifdef NS_DEBUG
   if (nsnull != aLastChild) {
-    NS_PRECONDITION(nsnull == aLastChild->GetNextSibling(), "bad last child");
+    NS_PRECONDITION(aNextInFlow->IsLastChild(aLastChild), "bad last child");
   }
 #endif
 
@@ -727,7 +786,7 @@ nsIFrame* nsContainerFrame::PullUpOneChild(nsContainerFrame* aNextInFlow,
   // Take the frame away from the next-in-flow. Update it's first
   // content offset and propagate upward the offset if the
   // next-in-flow is a pseudo-frame.
-  aNextInFlow->mFirstChild = kidFrame->GetNextSibling();
+  kidFrame->GetNextSibling(aNextInFlow->mFirstChild);
   aNextInFlow->mChildCount--;
   if (nsnull != aNextInFlow->mFirstChild) {
     aNextInFlow->SetFirstContentOffset(aNextInFlow->mFirstChild);
@@ -743,7 +802,11 @@ nsIFrame* nsContainerFrame::PullUpOneChild(nsContainerFrame* aNextInFlow,
 
   // Now give the frame to this container
   kidFrame->SetGeometricParent(this);
-  if (aNextInFlow == kidFrame->GetContentParent()) {
+
+  nsIFrame* contentParent;
+
+  kidFrame->GetContentParent(contentParent);
+  if (aNextInFlow == contentParent) {
     kidFrame->SetContentParent(this);
   }
   if (nsnull == aLastChild) {
@@ -813,18 +876,26 @@ void nsContainerFrame::AppendChildren(nsIFrame* aChild, PRBool aSetParent)
     // We have no children so aChild becomes the first child
     mFirstChild = aChild;
   } else {
-    LastChild()->SetNextSibling(aChild);
+    nsIFrame* lastChild;
+
+    LastChild(lastChild);
+    lastChild->SetNextSibling(aChild);
   }
 
   // Update our child count and last content offset
   nsIFrame* lastChild;
-  for (nsIFrame* f = aChild; nsnull != f; f = f->GetNextSibling()) {
+  for (nsIFrame* f = aChild; nsnull != f; f->GetNextSibling(f)) {
     lastChild = f;
     mChildCount++;
 
     // Reset the geometric parent if requested
     if (aSetParent) {
-      if (f->GetContentParent() == f->GetGeometricParent()) {
+      nsIFrame* geometricParent;
+      nsIFrame* contentParent;
+
+      f->GetGeometricParent(geometricParent);
+      f->GetContentParent(contentParent);
+      if (contentParent == geometricParent) {
         f->SetContentParent(this);
       }
       f->SetGeometricParent(this);
@@ -837,7 +908,10 @@ void nsContainerFrame::AppendChildren(nsIFrame* aChild, PRBool aSetParent)
   }
   SetLastContentOffset(lastChild);
   if (!ChildIsPseudoFrame(lastChild)) {
-    mLastContentIsComplete = PRBool(nsnull == lastChild->GetNextInFlow());
+    nsIFrame* nextInFlow;
+
+    lastChild->GetNextInFlow(nextInFlow);
+    mLastContentIsComplete = PRBool(nsnull == nextInFlow);
   }
 
 #ifdef NS_DEBUG
@@ -883,7 +957,7 @@ void nsContainerFrame::AdjustOffsetOfEmptyNextInFlows()
 
   while (nsnull != nextInFlow) {
     if (nsnull == nextInFlow->mFirstChild) {
-      NS_ASSERTION(0 == nextInFlow->ChildCount(), "bad child count");
+      NS_ASSERTION(nextInFlow->IsEmpty(), "bad state");
       nextInFlow->mFirstContentOffset = nextOffset;
       // If the next-in-flow is a pseudo-frame then we need to have it
       // update it's parents offsets too.
@@ -908,7 +982,7 @@ void nsContainerFrame::AdjustOffsetOfEmptyNextInFlows()
 /////////////////////////////////////////////////////////////////////////////
 // Debugging
 
-void nsContainerFrame::List(FILE* out, PRInt32 aIndent) const
+NS_METHOD nsContainerFrame::List(FILE* out, PRInt32 aIndent) const
 {
   // Indent
   for (PRInt32 i = aIndent; --i >= 0; ) fputs("  ", out);
@@ -926,13 +1000,13 @@ void nsContainerFrame::List(FILE* out, PRInt32 aIndent) const
   out << mRect;
 
   // Output the children
-  if (ChildCount() > 0) {
+  if (mChildCount > 0) {
     if (!mLastContentIsComplete) {
       fputs(", complete=>false ", out);
     }
 
     fputs("<\n", out);
-    for (nsIFrame* child = FirstChild(); child; child = NextChild(child)) {
+    for (nsIFrame* child = mFirstChild; child; NextChild(child, child)) {
       child->List(out, aIndent + 1);
     }
     for (PRInt32 i = aIndent; --i >= 0; ) fputs("  ", out);
@@ -940,33 +1014,35 @@ void nsContainerFrame::List(FILE* out, PRInt32 aIndent) const
   } else {
     fputs("<>\n", out);
   }
+
+  return NS_OK;
 }
 
-void nsContainerFrame::ListTag(FILE* out) const
+NS_METHOD nsContainerFrame::ListTag(FILE* out) const
 {
   if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
     fputs("*", out);
   }
   nsFrame::ListTag(out);
+  return NS_OK;
 }
 
 #define VERIFY_ASSERT(_expr, _msg)                \
   if (!(_expr)) {                                 \
-    const nsIFrame* top = this;                   \
-    while (top->GetGeometricParent() != nsnull) { \
-      top = top->GetGeometricParent();            \
-    }                                             \
-    top->List();                                  \
+    DumpTree();                       \
   }                                               \
   NS_ASSERTION(_expr, _msg)
 
-void nsContainerFrame::VerifyTree() const
+NS_METHOD nsContainerFrame::VerifyTree() const
 {
 #ifdef NS_DEBUG
   // Check our child count
   PRInt32 len = LengthOf(mFirstChild);
   VERIFY_ASSERT(len == mChildCount, "bad child count");
-  nsIFrame* lastChild = LastChild();
+
+  nsIFrame* lastChild;
+  LastChild(lastChild);
+
   if (len != 0) {
     VERIFY_ASSERT(nsnull != lastChild, "bad last child");
   }
@@ -1003,13 +1079,19 @@ void nsContainerFrame::VerifyTree() const
         offset++;
       }
     } else {
-      VERIFY_ASSERT(offset == child->GetIndexInParent(), "bad child offset");
-      if (nsnull == child->GetNextInFlow()) {
+      PRInt32 indexInParent;
+
+      child->GetIndexInParent(indexInParent);
+      VERIFY_ASSERT(offset == indexInParent, "bad child offset");
+
+      nsIFrame* nextInFlow;
+      child->GetNextInFlow(nextInFlow);
+      if (nsnull == nextInFlow) {
         offset++;
       }
     }
 
-    child = child->GetNextSibling();
+    child->GetNextSibling(child);
   }
 
   // Verify that our last content offset is correct
@@ -1034,6 +1116,7 @@ void nsContainerFrame::VerifyTree() const
     }
   }
 #endif
+  return NS_OK;
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -1045,12 +1128,67 @@ PRInt32 nsContainerFrame::LengthOf(nsIFrame* aFrame)
 
   while (nsnull != aFrame) {
     result++;
-    aFrame = aFrame->GetNextSibling();
+    aFrame->GetNextSibling(aFrame);
   }
 
   return result;
 }
 
+PRBool nsContainerFrame::IsChild(const nsIFrame* aChild) const
+{
+  // Check the geometric parent
+  nsIFrame* parent;
+
+  aChild->GetGeometricParent(parent);
+  if (parent != (nsIFrame*)this) {
+    return PR_FALSE;
+  }
+
+  // Check that aChild is in our sibling list
+  PRInt32 index;
+
+  IndexOf(aChild, index);
+  if (-1 == index) {
+    return PR_FALSE;
+  }
+
+  return PR_TRUE;
+}
+
+PRBool nsContainerFrame::IsLastChild(const nsIFrame* aChild) const
+{
+  // Check the geometric parent
+  nsIFrame* parent;
+
+  aChild->GetGeometricParent(parent);
+  if (parent != (nsIFrame*)this) {
+    return PR_FALSE;
+  }
+
+  // Check that aChild is in our sibling list
+  nsIFrame* lastChild;
+
+  LastChild(lastChild);
+  if (lastChild != aChild) {
+    return PR_FALSE;
+  }
+
+  return PR_TRUE;
+}
+
+void nsContainerFrame::DumpTree() const
+{
+  nsIFrame* root = (nsIFrame*)this;
+  nsIFrame* parent = mGeometricParent;
+
+  while (nsnull != parent) {
+    root = parent;
+    parent->GetGeometricParent(parent);
+  }
+
+  root->List();
+}
+
 void nsContainerFrame::CheckContentOffsets()
 {
   NS_PRECONDITION(nsnull != mFirstChild, "null first child");
@@ -1060,30 +1198,25 @@ void nsContainerFrame::CheckContentOffsets()
     nsContainerFrame* pseudoFrame = (nsContainerFrame*)mFirstChild;
 
     if (pseudoFrame->GetFirstContentOffset() != mFirstContentOffset) {
-      nsIFrame* top = this;
-      while (top->GetGeometricParent() != nsnull) {
-        top = top->GetGeometricParent();
-      }
-      top->List();
+      DumpTree();
     }
     NS_ASSERTION(pseudoFrame->GetFirstContentOffset() == mFirstContentOffset,
                  "bad first content offset");
   } else {
-#ifdef NS_DEBUG
-    if (!(mFirstChild->GetIndexInParent() == mFirstContentOffset)) {
-      nsIFrame* top = this;
-      while (top->GetGeometricParent() != nsnull) {
-        top = top->GetGeometricParent();
-      }
-      top->List();
+    PRInt32 indexInParent;
+
+    mFirstChild->GetIndexInParent(indexInParent);
+    if (indexInParent != mFirstContentOffset) {
+      DumpTree();
     }
-#endif
-    NS_ASSERTION(mFirstChild->GetIndexInParent() == mFirstContentOffset,
-                 "bad first content offset");
+
+    NS_ASSERTION(indexInParent == mFirstContentOffset, "bad first content offset");
   }
 
   // Verify that our last content offset is correct
-  nsIFrame* lastChild = LastChild();
+  nsIFrame* lastChild;
+   
+  LastChild(lastChild);
   if (ChildIsPseudoFrame(lastChild)) {
     nsContainerFrame* pseudoFrame = (nsContainerFrame*)lastChild;
 
@@ -1091,8 +1224,10 @@ void nsContainerFrame::CheckContentOffsets()
                  "bad last content offset");
 
   } else {
-    NS_ASSERTION(lastChild->GetIndexInParent() == mLastContentOffset,
-                 "bad last content offset");
+    PRInt32 indexInParent;
+
+    lastChild->GetIndexInParent(indexInParent);
+    NS_ASSERTION(indexInParent == mLastContentOffset, "bad last content offset");
   }
 }
 
@@ -1160,11 +1295,7 @@ void nsContainerFrame::CheckNextInFlowOffsets()
     }
 #ifdef NS_DEBUG
     if (nextInFlow->GetFirstContentOffset() != nextOffset) {
-      nsIFrame* top = this;
-      while (top->GetGeometricParent() != nsnull) {
-        top = top->GetGeometricParent();
-      }
-      top->List();
+      DumpTree();
     }
 #endif
     NS_ASSERTION(nextInFlow->GetFirstContentOffset() == nextOffset,
@@ -1193,7 +1324,9 @@ nsContainerFrame::SafeToCheckLastContentOffset(nsContainerFrame* aContainer)
     return PR_FALSE;
   }
 
-  nsIFrame* lastChild = aContainer->LastChild();
+  nsIFrame* lastChild;
+   
+  aContainer->LastChild(lastChild);
   if (aContainer->ChildIsPseudoFrame(lastChild)) {
     // If the containers last child is a pseudo-frame then the
     // containers last content offset is determined by the child. Ask
@@ -1218,8 +1351,9 @@ void nsContainerFrame::VerifyLastIsComplete() const
     return;
   }
 
-  nsIFrame* lastKid = LastChild();
+  nsIFrame* lastKid;
 
+  LastChild(lastKid);
   if (ChildIsPseudoFrame(lastKid)) {
     // When my last child is a pseudo-frame it means that our
     // mLastContentIsComplete is a copy of it's.
@@ -1230,17 +1364,14 @@ void nsContainerFrame::VerifyLastIsComplete() const
     // If my last child has a next-in-flow then our
     // mLastContentIsComplete must be false (because our last child is
     // obviously not complete)
-    nsIFrame* lastKidNextInFlow = lastKid->GetNextInFlow();
+    nsIFrame* lastKidNextInFlow;
+     
+    lastKid->GetNextInFlow(lastKidNextInFlow);
     if (nsnull != lastKidNextInFlow) {
       if (mLastContentIsComplete) {
-        const nsIFrame* top = this;
-        while (top->GetGeometricParent() != nsnull) {
-          top = top->GetGeometricParent();
-        }
-        top->List();
+        DumpTree();
       }
-      NS_ASSERTION(mLastContentIsComplete == PR_FALSE,
-                   "bad mLastContentIsComplete");
+      NS_ASSERTION(mLastContentIsComplete == PR_FALSE, "bad mLastContentIsComplete");
     } else {
       // We don't know what state our mLastContentIsComplete should be in.
     }
diff --git a/mozilla/layout/base/src/nsContainerFrame.h b/mozilla/layout/base/src/nsContainerFrame.h
index da03faf7e43..7f471557f69 100644
--- a/mozilla/layout/base/src/nsContainerFrame.h
+++ b/mozilla/layout/base/src/nsContainerFrame.h
@@ -111,62 +111,65 @@ public:
    * set the content offsets, mLastContentOffset, and append the continuing
    * frame to the flow.
    */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
   // Painting
-  virtual void Paint(nsIPresContext&      aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect&        aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext&      aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect&        aDirtyRect);
 
   /**
    * Pass through the event to the correct child frame.
    * Return PR_TRUE if the event is consumed.
    */
-  virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
-                             nsGUIEvent*     aEvent);
+  NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
+                         nsGUIEvent*     aEvent,
+                         nsEventStatus&  aEventStatus);
 
-  virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
-                              const nsPoint& aPoint,
-                              nsIFrame** aFrame);
+  NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
+                         const nsPoint&  aPoint,
+                         nsIFrame**      aFrame,
+                         PRInt32&        aCursor);
 
   // Child frame enumeration.
   // ChildAt() retruns null if the index is not in the range 0 .. ChildCount() - 1.
   // IndexOf() returns -1 if the frame is not in the child list.
-  virtual PRInt32       ChildCount() const;
-  virtual nsIFrame*     ChildAt(PRInt32 aIndex) const;
-  virtual PRInt32       IndexOf(const nsIFrame* aChild) const;
-  virtual nsIFrame*     FirstChild() const;
-  virtual nsIFrame*     NextChild(const nsIFrame* aChild) const;
-  virtual nsIFrame*     PrevChild(const nsIFrame* aChild) const;
-  virtual nsIFrame*     LastChild() const;
+  NS_IMETHOD  ChildCount(PRInt32& aChildCount) const;
+  NS_IMETHOD  ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const;
+  NS_IMETHOD  IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const;
+  NS_IMETHOD  FirstChild(nsIFrame*& aFirstChild) const;
+  NS_IMETHOD  NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const;
+  NS_IMETHOD  PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const;
+  NS_IMETHOD  LastChild(nsIFrame*& aLastChild) const;
 
   // Access functions for starting and end content offsets. These reflect the
   // range of content mapped by the frame.
   //
   // If the container is empty (has no children) the last content offset is
   // undefined
-  PRInt32       GetFirstContentOffset() const {return mFirstContentOffset;}
-  void          SetFirstContentOffset(PRInt32 aOffset) {mFirstContentOffset = aOffset;}
-  PRInt32       GetLastContentOffset() const {return mLastContentOffset;}
-  void          SetLastContentOffset(PRInt32 aOffset) {mLastContentOffset = aOffset;}
+  PRInt32     GetFirstContentOffset() const {return mFirstContentOffset;}
+  void        SetFirstContentOffset(PRInt32 aOffset) {mFirstContentOffset = aOffset;}
+  PRInt32     GetLastContentOffset() const {return mLastContentOffset;}
+  void        SetLastContentOffset(PRInt32 aOffset) {mLastContentOffset = aOffset;}
 
   /** return PR_TRUE if the last mapped child is complete */
-  PRBool        GetLastContentIsComplete() const {return mLastContentIsComplete;}
+  PRBool      GetLastContentIsComplete() const {return mLastContentIsComplete;}
   /** set the state indicating whether the last mapped child is complete */
-  void          SetLastContentIsComplete(PRBool aLIC) {mLastContentIsComplete = aLIC;}
+  void        SetLastContentIsComplete(PRBool aLIC) {mLastContentIsComplete = aLIC;}
 
   // Get the offset for the next child content, i.e. the child after the
   // last child that fit in us
-  PRInt32       NextChildOffset() const;
+  PRInt32     NextChildOffset() const;
 
   // Returns true if this frame is being used a pseudo frame
-  PRBool        IsPseudoFrame() const;
+  PRBool      IsPseudoFrame() const;
 
   // Debugging
-  virtual void  List(FILE* out = stdout, PRInt32 aIndent = 0) const;
-  virtual void  ListTag(FILE* out = stdout) const;
-  virtual void  VerifyTree() const;
+  NS_IMETHOD  List(FILE* out = stdout, PRInt32 aIndent = 0) const;
+  NS_IMETHOD  ListTag(FILE* out = stdout) const;
+  NS_IMETHOD  VerifyTree() const;
 
   /**
    * This is used to propagate this frame's mFirstContentOffset, mLastContentOffset,
@@ -342,6 +345,18 @@ protected:
    */
   static PRInt32 LengthOf(nsIFrame* aChild);
 
+  /**
+   * Returns PR_TRUE if aChild is a child of this frame.
+   */
+  PRBool IsChild(const nsIFrame* aChild) const;
+
+  /**
+   * Returns PR_TRUE if aChild is the last child of this frame.
+   */
+  PRBool IsLastChild(const nsIFrame* aChild) const;
+
+  void DumpTree() const;
+
   /**
    * Before reflow for this container has started we check that all
    * is well.
diff --git a/mozilla/layout/base/src/nsFrame.cpp b/mozilla/layout/base/src/nsFrame.cpp
index 905fad7319d..e5fe8e66281 100644
--- a/mozilla/layout/base/src/nsFrame.cpp
+++ b/mozilla/layout/base/src/nsFrame.cpp
@@ -119,19 +119,21 @@ nsrefcnt nsFrame::Release(void)
 /////////////////////////////////////////////////////////////////////////////
 // nsIFrame
 
-void nsFrame::DeleteFrame()
+NS_METHOD nsFrame::DeleteFrame()
 {
   nsIView* view = mView;
   if (nsnull == view) {
-    nsIFrame* parent = GetParentWithView();
+    nsIFrame* parent;
+     
+    GetParentWithView(parent);
     if (nsnull != parent) {
-      view = parent->GetView();
+      parent->GetView(view);
     }
   }
   if (nsnull != view) {
     nsIViewManager* vm = view->GetViewManager();
     nsIPresContext* cx = vm->GetPresContext();
-    //is this a really good ordering for the releases? MMP
+    // XXX Is this a really good ordering for the releases? MMP
     NS_RELEASE(vm);
     NS_RELEASE(view);
     cx->StopLoadImage(this);
@@ -139,36 +141,42 @@ void nsFrame::DeleteFrame()
   }
 
   delete this;
+  return NS_OK;
 }
 
-nsIContent* nsFrame::GetContent() const
+NS_METHOD nsFrame::GetContent(nsIContent*& aContent) const
 {
   if (nsnull != mContent) {
     NS_ADDREF(mContent);
   }
-  return mContent;
+  aContent = mContent;
+  return NS_OK;
 }
 
-PRInt32 nsFrame::GetIndexInParent() const
+NS_METHOD nsFrame::GetIndexInParent(PRInt32& aIndexInParent) const
 {
-  return mIndexInParent;
+  aIndexInParent = mIndexInParent;
+  return NS_OK;
 }
 
-void nsFrame::SetIndexInParent(PRInt32 aIndexInParent)
+NS_METHOD nsFrame::SetIndexInParent(PRInt32 aIndexInParent)
 {
   mIndexInParent = aIndexInParent;
+  return NS_OK;
 }
 
-nsIStyleContext* nsFrame::GetStyleContext(nsIPresContext* aPresContext)
+NS_METHOD nsFrame::GetStyleContext(nsIPresContext*   aPresContext,
+                                   nsIStyleContext*& aStyleContext)
 {
   if (nsnull == mStyleContext) {
     mStyleContext = aPresContext->ResolveStyleContextFor(mContent, mGeometricParent); // XXX should be content parent???
   }
   NS_IF_ADDREF(mStyleContext);
-  return mStyleContext;
+  aStyleContext = mStyleContext;
+  return NS_OK;
 }
 
-void nsFrame::SetStyleContext(nsIStyleContext* aContext)
+NS_METHOD nsFrame::SetStyleContext(nsIStyleContext* aContext)
 {
   NS_PRECONDITION(nsnull != aContext, "null ptr");
   if (aContext != mStyleContext) {
@@ -178,65 +186,77 @@ void nsFrame::SetStyleContext(nsIStyleContext* aContext)
       NS_ADDREF(aContext);
     }
   }
+
+  return NS_OK;
+}
+
+NS_METHOD nsFrame::GetStyleData(const nsIID& aSID, nsStyleStruct*& aStyleStruct)
+{
+  NS_ASSERTION(mStyleContext!=nsnull,"null style context");
+  if (mStyleContext) {
+    aStyleStruct = mStyleContext->GetData(aSID);
+  } else {
+    aStyleStruct = nsnull;
+  }
+  return NS_OK;
 }
 
 // Geometric and content parent member functions
 
-nsIFrame* nsFrame::GetContentParent() const
+NS_METHOD nsFrame::GetContentParent(nsIFrame*& aParent) const
 {
-  return mContentParent;
+  aParent = mContentParent;
+  return NS_OK;
 }
 
-void nsFrame::SetContentParent(const nsIFrame* aParent)
+NS_METHOD nsFrame::SetContentParent(const nsIFrame* aParent)
 {
   mContentParent = (nsIFrame*)aParent;
+  return NS_OK;
 }
 
-nsIFrame* nsFrame::GetGeometricParent() const
+NS_METHOD nsFrame::GetGeometricParent(nsIFrame*& aParent) const
 {
-  return mGeometricParent;
+  aParent = mGeometricParent;
+  return NS_OK;
 }
 
-void nsFrame::SetGeometricParent(const nsIFrame* aParent)
+NS_METHOD nsFrame::SetGeometricParent(const nsIFrame* aParent)
 {
   mGeometricParent = (nsIFrame*)aParent;
+  return NS_OK;
 }
 
 // Bounding rect member functions
 
-nsRect nsFrame::GetRect() const
-{
-  return mRect;
-}
-
-void nsFrame::GetRect(nsRect& aRect) const
+NS_METHOD nsFrame::GetRect(nsRect& aRect) const
 {
   aRect = mRect;
+  return NS_OK;
 }
 
-void nsFrame::GetOrigin(nsPoint& aPoint) const
+NS_METHOD nsFrame::GetOrigin(nsPoint& aPoint) const
 {
   aPoint.x = mRect.x;
   aPoint.y = mRect.y;
+  return NS_OK;
 }
 
-nscoord nsFrame::GetWidth() const
+NS_METHOD nsFrame::GetSize(nsSize& aSize) const
 {
-  return mRect.width;
+  aSize.width = mRect.width;
+  aSize.height = mRect.height;
+  return NS_OK;
 }
 
-nscoord nsFrame::GetHeight() const
-{
-  return mRect.height;
-}
-
-void nsFrame::SetRect(const nsRect& aRect)
+NS_METHOD nsFrame::SetRect(const nsRect& aRect)
 {
   MoveTo(aRect.x, aRect.y);
   SizeTo(aRect.width, aRect.height);
+  return NS_OK;
 }
 
-void nsFrame::MoveTo(nscoord aX, nscoord aY)
+NS_METHOD nsFrame::MoveTo(nscoord aX, nscoord aY)
 {
   if ((aX != mRect.x) || (aY != mRect.y)) {
     mRect.x = aX;
@@ -247,9 +267,11 @@ void nsFrame::MoveTo(nscoord aX, nscoord aY)
       mView->SetPosition(aX, aY);
     }
   }
+
+  return NS_OK;
 }
 
-void nsFrame::SizeTo(nscoord aWidth, nscoord aHeight)
+NS_METHOD nsFrame::SizeTo(nscoord aWidth, nscoord aHeight)
 {
   if ((aWidth != mRect.width) || (aHeight != mRect.height)) {
     mRect.width = aWidth;
@@ -260,76 +282,89 @@ void nsFrame::SizeTo(nscoord aWidth, nscoord aHeight)
       mView->SetDimensions(aWidth, aHeight);
     }
   }
+
+  return NS_OK;
 }
 
 // Child frame enumeration
 
-PRInt32 nsFrame::ChildCount() const
+NS_METHOD nsFrame::ChildCount(PRInt32& aChildCount) const
 {
-  return 0;
+  aChildCount = 0;
+  return NS_OK;
 }
 
-nsIFrame* nsFrame::ChildAt(PRInt32 aIndex) const
+NS_METHOD nsFrame::ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const
 {
   NS_ERROR("not a container");
-  return nsnull;
+  aFrame = nsnull;
+  return NS_OK;
 }
 
-PRInt32 nsFrame::IndexOf(const nsIFrame* aChild) const
+NS_METHOD nsFrame::IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const
 {
   NS_ERROR("not a container");
-  return -1;
+  aIndex = -1;
+  return NS_OK;
 }
 
-nsIFrame* nsFrame::FirstChild() const
+NS_METHOD nsFrame::FirstChild(nsIFrame*& aFirstChild) const
 {
-  return nsnull;
+  aFirstChild = nsnull;
+  return NS_OK;
 }
 
-nsIFrame* nsFrame::NextChild(const nsIFrame* aChild) const
+NS_METHOD nsFrame::NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const
 {
   NS_ERROR("not a container");
-  return nsnull;
+  aNextChild = nsnull;
+  return NS_OK;
 }
 
-nsIFrame* nsFrame::PrevChild(const nsIFrame* aChild) const
+NS_METHOD nsFrame::PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const
 {
   NS_ERROR("not a container");
-  return nsnull;
+  aPrevChild = nsnull;
+  return NS_OK;
 }
 
-nsIFrame* nsFrame::LastChild() const
+NS_METHOD nsFrame::LastChild(nsIFrame*& aLastChild) const
 {
-  return nsnull;
+  aLastChild = nsnull;
+  return NS_OK;
 }
 
-void nsFrame::Paint(nsIPresContext& aPresContext,
-                    nsIRenderingContext& aRenderingContext,
-                    const nsRect&        aDirtyRect)
+NS_METHOD nsFrame::Paint(nsIPresContext&      aPresContext,
+                         nsIRenderingContext& aRenderingContext,
+                         const nsRect&        aDirtyRect)
 {
+  return NS_OK;
 }
 
-nsEventStatus nsFrame::HandleEvent(nsIPresContext& aPresContext, 
-                            nsGUIEvent* aEvent)
+NS_METHOD nsFrame::HandleEvent(nsIPresContext& aPresContext, 
+                               nsGUIEvent*     aEvent,
+                               nsEventStatus&  aEventStatus)
 {
-  nsEventStatus  retval = nsEventStatus_eIgnore;
-  return retval;
+  aEventStatus = nsEventStatus_eIgnore;
+  return NS_OK;
 }
 
-PRInt32 nsFrame::GetCursorAt(nsIPresContext& aPresContext,
-                             const nsPoint& aPoint,
-                             nsIFrame** aFrame)
+NS_METHOD nsFrame::GetCursorAt(nsIPresContext& aPresContext,
+                               const nsPoint&  aPoint,
+                               nsIFrame**      aFrame,
+                               PRInt32&        aCursor)
 {
-  return NS_STYLE_CURSOR_INHERIT;
+  aCursor = NS_STYLE_CURSOR_INHERIT;
+  return NS_OK;
 }
 
 // Resize and incremental reflow
 
-nsIFrame::ReflowStatus
-nsFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                      nsReflowMetrics& aDesiredSize,
-                      const nsSize&    aMaxSize,
-                      nsSize*          aMaxElementSize)
+NS_METHOD nsFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                nsReflowMetrics& aDesiredSize,
+                                const nsSize&    aMaxSize,
+                                nsSize*          aMaxElementSize,
+                                ReflowStatus&    aStatus)
 {
   aDesiredSize.width = 0;
   aDesiredSize.height = 0;
@@ -339,136 +374,156 @@ nsFrame::ResizeReflow(nsIPresContext*  aPresContext,
     aMaxElementSize->width = 0;
     aMaxElementSize->height = 0;
   }
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-void
-nsFrame::JustifyReflow(nsIPresContext* aPresContext,
-                       nscoord aAvailableSpace)
+NS_METHOD nsFrame::JustifyReflow(nsIPresContext* aPresContext,
+                                 nscoord         aAvailableSpace)
 {
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                           nsReflowMetrics& aDesiredSize,
-                           const nsSize&    aMaxSize,
-                           nsReflowCommand& aReflowCommand)
+NS_METHOD nsFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                     nsReflowMetrics& aDesiredSize,
+                                     const nsSize&    aMaxSize,
+                                     nsReflowCommand& aReflowCommand,
+                                     ReflowStatus&    aStatus)
 {
   NS_ERROR("not a reflow command handler");
   aDesiredSize.width = 0;
   aDesiredSize.height = 0;
   aDesiredSize.ascent = 0;
   aDesiredSize.descent = 0;
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-void nsFrame::ContentAppended(nsIPresShell* aShell,
-                              nsIPresContext* aPresContext,
-                              nsIContent* aContainer)
+NS_METHOD nsFrame::ContentAppended(nsIPresShell*   aShell,
+                                   nsIPresContext* aPresContext,
+                                   nsIContent*     aContainer)
 {
+  return NS_OK;
 }
 
-void nsFrame::ContentInserted(nsIPresShell* aShell,
-                              nsIPresContext* aPresContext,
-                              nsIContent* aContainer,
-                              nsIContent* aChild,
-                              PRInt32 aIndexInParent)
+NS_METHOD nsFrame::ContentInserted(nsIPresShell*   aShell,
+                                   nsIPresContext* aPresContext,
+                                   nsIContent*     aContainer,
+                                   nsIContent*     aChild,
+                                   PRInt32         aIndexInParent)
 {
+  return NS_OK;
 }
 
-void nsFrame::ContentReplaced(nsIPresShell* aShell,
-                              nsIPresContext* aPresContext,
-                              nsIContent* aContainer,
-                              nsIContent* aOldChild,
-                              nsIContent* aNewChild,
-                              PRInt32 aIndexInParent)
+NS_METHOD nsFrame::ContentReplaced(nsIPresShell*   aShell,
+                                   nsIPresContext* aPresContext,
+                                   nsIContent*     aContainer,
+                                   nsIContent*     aOldChild,
+                                   nsIContent*     aNewChild,
+                                   PRInt32         aIndexInParent)
 {
+  return NS_OK;
 }
 
-void nsFrame::ContentDeleted(nsIPresShell* aShell,
-                             nsIPresContext* aPresContext,
-                             nsIContent* aContainer,
-                             nsIContent* aChild,
-                             PRInt32 aIndexInParent)
+NS_METHOD nsFrame::ContentDeleted(nsIPresShell*   aShell,
+                                  nsIPresContext* aPresContext,
+                                  nsIContent*     aContainer,
+                                  nsIContent*     aChild,
+                                  PRInt32         aIndexInParent)
 {
+  return NS_OK;
 }
 
-void nsFrame::GetReflowMetrics(nsIPresContext* aPresContext,
-                               nsReflowMetrics& aMetrics)
+NS_METHOD nsFrame::GetReflowMetrics(nsIPresContext*  aPresContext,
+                                    nsReflowMetrics& aMetrics)
 {
   aMetrics.width = mRect.width;
   aMetrics.height = mRect.height;
   aMetrics.ascent = mRect.height;
   aMetrics.descent = 0;
+  return NS_OK;
 }
 
 // Flow member functions
 
-PRBool nsFrame::IsSplittable() const
+NS_METHOD nsFrame::IsSplittable(PRBool& aIsSplittable) const
 {
-  return PR_FALSE;
+  aIsSplittable = PR_FALSE;
+  return NS_OK;
 }
 
-nsIFrame* nsFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                         nsIFrame*       aParent)
+NS_METHOD nsFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                         nsIFrame*       aParent,
+                                         nsIFrame*&      aContinuingFrame)
 {
   NS_ERROR("not splittable");
-  return nsnull;
+  aContinuingFrame = nsnull;
+  return NS_OK;
 }
 
-nsIFrame* nsFrame::GetPrevInFlow() const
+NS_METHOD nsFrame::GetPrevInFlow(nsIFrame*& aPrevInFlow) const
 {
-  return nsnull;
+  aPrevInFlow = nsnull;
+  return NS_OK;
 }
 
-void nsFrame::SetPrevInFlow(nsIFrame*)
+NS_METHOD nsFrame::SetPrevInFlow(nsIFrame*)
 {
   NS_ERROR("not splittable");
+  return NS_OK;
 }
 
-nsIFrame* nsFrame::GetNextInFlow() const
+NS_METHOD nsFrame::GetNextInFlow(nsIFrame*& aNextInFlow) const
 {
-  return nsnull;
+  aNextInFlow = nsnull;
+  return NS_OK;
 }
 
-void nsFrame::SetNextInFlow(nsIFrame*)
+NS_METHOD nsFrame::SetNextInFlow(nsIFrame*)
 {
   NS_ERROR("not splittable");
+  return NS_OK;
 }
 
-void nsFrame::AppendToFlow(nsIFrame* aAfterFrame)
+NS_METHOD nsFrame::AppendToFlow(nsIFrame* aAfterFrame)
 {
   NS_ERROR("not splittable");
+  return NS_OK;
 }
 
-void nsFrame::PrependToFlow(nsIFrame* aBeforeFrame)
+NS_METHOD nsFrame::PrependToFlow(nsIFrame* aBeforeFrame)
 {
   NS_ERROR("not splittable");
+  return NS_OK;
 }
 
-void nsFrame::RemoveFromFlow()
+NS_METHOD nsFrame::RemoveFromFlow()
 {
   NS_ERROR("not splittable");
+  return NS_OK;
 }
 
-void nsFrame::BreakFromPrevFlow()
+NS_METHOD nsFrame::BreakFromPrevFlow()
 {
   NS_ERROR("not splittable");
+  return NS_OK;
 }
 
-void nsFrame::BreakFromNextFlow()
+NS_METHOD nsFrame::BreakFromNextFlow()
 {
   NS_ERROR("not splittable");
+  return NS_OK;
 }
 
 // Associated view object
-nsIView* nsFrame::GetView() const
+NS_METHOD nsFrame::GetView(nsIView*& aView) const
 {
-  NS_IF_ADDREF(mView);
-  return mView;
+  aView = mView;
+  NS_IF_ADDREF(aView);
+  return NS_OK;
 }
 
-void nsFrame::SetView(nsIView* aView)
+NS_METHOD nsFrame::SetView(nsIView* aView)
 {
   NS_IF_RELEASE(mView);
   if (nsnull != aView) {
@@ -476,78 +531,88 @@ void nsFrame::SetView(nsIView* aView)
     aView->SetFrame(this);
     NS_ADDREF(aView);
   }
+  return NS_OK;
 }
 
 // Find the first geometric parent that has a view
-nsIFrame* nsFrame::GetParentWithView() const
+NS_METHOD nsFrame::GetParentWithView(nsIFrame*& aParent) const
 {
-  nsIFrame* parent = mGeometricParent;
+  aParent = mGeometricParent;
 
-  while (nsnull != parent) {
-    nsIView* parView = parent->GetView();
+  while (nsnull != aParent) {
+    nsIView* parView;
+     
+    aParent->GetView(parView);
     if (nsnull != parView) {
       NS_RELEASE(parView);
       break;
     }
-    parent = parent->GetGeometricParent();
+    aParent->GetGeometricParent(aParent);
   }
 
-  return parent;
+  return NS_OK;
 }
 
 // Returns the offset from this frame to the closest geometric parent that
 // has a view. Also returns the containing view or null in case of error
-nsIView* nsFrame::GetOffsetFromView(nsPoint& aOffset) const
+NS_METHOD nsFrame::GetOffsetFromView(nsPoint& aOffset, nsIView*& aView) const
 {
-  const nsIFrame* frame = this;
-  nsIView*  result = nsnull;
-  nsPoint   origin;
+  nsIFrame* frame = (nsIFrame*)this;
 
+  aView = nsnull;
   aOffset.MoveTo(0, 0);
-  nsIView* view = nsnull;
   do {
+    nsPoint origin;
+
     frame->GetOrigin(origin);
     aOffset += origin;
-    frame = frame->GetGeometricParent();
-    view = (frame == nsnull) ? nsnull : frame->GetView();
-  } while ((nsnull != frame) && (nsnull == view));
+    frame->GetGeometricParent(frame);
+    if (nsnull != frame) {
+      frame->GetView(aView);
+    }
+  } while ((nsnull != frame) && (nsnull == aView));
 
-  return view;
+  return NS_OK;
 }
 
-nsIWidget* nsFrame::GetWindow() const
+NS_METHOD nsFrame::GetWindow(nsIWidget*& aWindow) const
 {
-  nsIWidget* window = nsnull;
-  const nsIFrame* frame = this;
+  nsIFrame* frame = (nsIFrame*)this;
+
+  aWindow = nsnull;
   while (nsnull != frame) {
-    nsIView* view = frame->GetView();
+    nsIView* view;
+     
+    frame->GetView(view);
     if (nsnull != view) {
-      window = view->GetWidget();
+      aWindow = view->GetWidget();
       NS_RELEASE(view);
-      if (nsnull != window) {
-        return window;
+      if (nsnull != aWindow) {
+        break;
       }
     }
-    frame = frame->GetParentWithView();
+    frame->GetParentWithView(frame);
   }
-  NS_POSTCONDITION(nsnull != window, "no window in frame tree");
-  return nsnull;
+  NS_POSTCONDITION(nsnull != aWindow, "no window in frame tree");
+  return NS_OK;
 }
 
 // Sibling pointer used to link together frames
 
-nsIFrame* nsFrame::GetNextSibling() const
+NS_METHOD nsFrame::GetNextSibling(nsIFrame*& aNextSibling) const
 {
-  return mNextSibling;
+  aNextSibling = mNextSibling;
+  return NS_OK;
 }
 
-void nsFrame::SetNextSibling(nsIFrame* aNextSibling)
+NS_METHOD nsFrame::SetNextSibling(nsIFrame* aNextSibling)
 {
   mNextSibling = aNextSibling;
+  return NS_OK;
 }
 
 // Debugging
-void nsFrame::List(FILE* out, PRInt32 aIndent) const
+NS_METHOD nsFrame::List(FILE* out, PRInt32 aIndent) const
 {
   // Indent
   for (PRInt32 i = aIndent; --i >= 0; ) fputs("  ", out);
@@ -557,10 +622,11 @@ void nsFrame::List(FILE* out, PRInt32 aIndent) const
   fputs(" ", out);
   out << mRect;
   fputs("<>\n", out);
+  return NS_OK;
 }
 
 // Output the frame's tag
-void nsFrame::ListTag(FILE* out) const
+NS_METHOD nsFrame::ListTag(FILE* out) const
 {
   nsIAtom* tag = mContent->GetTag();
   if (tag != nsnull) {
@@ -570,16 +636,10 @@ void nsFrame::ListTag(FILE* out) const
     NS_RELEASE(tag);
   }
   fprintf(out, "(%d)@%p", mIndexInParent, this);
+  return NS_OK;
 }
 
-void nsFrame::VerifyTree() const
+NS_METHOD nsFrame::VerifyTree() const
 {
-}
-
-nsStyleStruct* nsFrame::GetStyleData(const nsIID& aSID)
-{
-  NS_ASSERTION(mStyleContext!=nsnull,"null style context");
-  if (mStyleContext)
-    return mStyleContext->GetData(aSID);
-  return nsnull;
+  return NS_OK;
 }
diff --git a/mozilla/layout/base/src/nsFrame.h b/mozilla/layout/base/src/nsFrame.h
index f64dfafcb99..2b26ee7c2e8 100644
--- a/mozilla/layout/base/src/nsFrame.h
+++ b/mozilla/layout/base/src/nsFrame.h
@@ -35,133 +35,139 @@ public:
                            PRInt32     aIndexInParent,
                            nsIFrame*   aParent);
 
-  NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
+  NS_IMETHOD  QueryInterface(const nsIID& aIID, void** aInstancePtr);
 
   // Overloaded new operator. Initializes the memory to 0
   void* operator new(size_t size);
 
-  virtual void DeleteFrame();
+  NS_IMETHOD  DeleteFrame();
 
-  virtual nsIContent*   GetContent() const;
-  virtual PRInt32       GetIndexInParent() const;
-  virtual void          SetIndexInParent(PRInt32 aIndexInParent);
+  NS_IMETHOD  GetContent(nsIContent*& aContent) const;
+  NS_IMETHOD  GetIndexInParent(PRInt32& aIndexInParent) const;
+  NS_IMETHOD  SetIndexInParent(PRInt32 aIndexInParent);
+
+  NS_IMETHOD  GetStyleContext(nsIPresContext* aContext, nsIStyleContext*& aStyleContext);
+  NS_IMETHOD  SetStyleContext(nsIStyleContext* aContext);
+
+  // Get the style struct associated with this frame
+  NS_IMETHOD  GetStyleData(const nsIID& aSID, nsStyleStruct*& aStyleStruct);
 
-  virtual nsIStyleContext* GetStyleContext(nsIPresContext* aContext);
-  virtual void             SetStyleContext(nsIStyleContext* aContext);
 
   // Geometric and content parent
-  virtual nsIFrame*     GetContentParent() const;
-  virtual void          SetContentParent(const nsIFrame* aParent);
-  virtual nsIFrame*     GetGeometricParent() const;
-  virtual void          SetGeometricParent(const nsIFrame* aParent);
+  NS_IMETHOD  GetContentParent(nsIFrame*& aParent) const;
+  NS_IMETHOD  SetContentParent(const nsIFrame* aParent);
+  NS_IMETHOD  GetGeometricParent(nsIFrame*& aParent) const;
+  NS_IMETHOD  SetGeometricParent(const nsIFrame* aParent);
 
   // Bounding rect
-  virtual nsRect        GetRect() const;
-  virtual void          GetRect(nsRect& aRect) const;
-  virtual void          GetOrigin(nsPoint& aPoint) const;
-  virtual nscoord       GetWidth() const;
-  virtual nscoord       GetHeight() const;
-  virtual void          SetRect(const nsRect& aRect);
-  virtual void          MoveTo(nscoord aX, nscoord aY);
-  virtual void          SizeTo(nscoord aWidth, nscoord aHeight);
+  NS_IMETHOD  GetRect(nsRect& aRect) const;
+  NS_IMETHOD  GetOrigin(nsPoint& aPoint) const;
+  NS_IMETHOD  GetSize(nsSize& aSize) const;
+  NS_IMETHOD  SetRect(const nsRect& aRect);
+  NS_IMETHOD  MoveTo(nscoord aX, nscoord aY);
+  NS_IMETHOD  SizeTo(nscoord aWidth, nscoord aHeight);
 
   // Child frame enumeration
-  virtual PRInt32       ChildCount() const;
-  virtual nsIFrame*     ChildAt(PRInt32 aIndex) const;
-  virtual PRInt32       IndexOf(const nsIFrame* aChild) const;
-  virtual nsIFrame*     FirstChild() const;
-  virtual nsIFrame*     NextChild(const nsIFrame* aChild) const;
-  virtual nsIFrame*     PrevChild(const nsIFrame* aChild) const;
-  virtual nsIFrame*     LastChild() const;
+  NS_IMETHOD  ChildCount(PRInt32& aChildCount) const;
+  NS_IMETHOD  ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const;
+  NS_IMETHOD  IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const;
+  NS_IMETHOD  FirstChild(nsIFrame*& aFirstChild) const;
+  NS_IMETHOD  NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const;
+  NS_IMETHOD  PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const;
+  NS_IMETHOD  LastChild(nsIFrame*& aLastChild) const;
 
-  virtual void          Paint(nsIPresContext&      aPresContext,
-                              nsIRenderingContext& aRenderingContext,
-                              const nsRect&        aDirtyRect);
+  NS_IMETHOD  Paint(nsIPresContext&      aPresContext,
+                    nsIRenderingContext& aRenderingContext,
+                    const nsRect&        aDirtyRect);
 
-  virtual nsEventStatus        HandleEvent(nsIPresContext& aPresContext, 
-                                    nsGUIEvent*     aEvent);
+  NS_IMETHOD  HandleEvent(nsIPresContext& aPresContext, 
+                          nsGUIEvent*     aEvent,
+                          nsEventStatus&  aEventStatus);
 
-  virtual PRInt32       GetCursorAt(nsIPresContext& aPresContext,
-                                    const nsPoint& aPoint,
-                                    nsIFrame** aFrame);
+  NS_IMETHOD  GetCursorAt(nsIPresContext& aPresContext,
+                          const nsPoint&  aPoint,
+                          nsIFrame**      aFrame,
+                          PRInt32&        aCursor);
 
   // Resize reflow methods
-  virtual ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                                     nsReflowMetrics& aDesiredSize,
-                                     const nsSize&    aMaxSize,
-                                     nsSize*          aMaxElementSize);
-  virtual void          JustifyReflow(nsIPresContext* aCX,
-                                      nscoord         aAvailableSpace);
+  NS_IMETHOD  ResizeReflow(nsIPresContext*  aPresContext,
+                           nsReflowMetrics& aDesiredSize,
+                           const nsSize&    aMaxSize,
+                           nsSize*          aMaxElementSize,
+                           ReflowStatus&    aStatus);
+
+  NS_IMETHOD  JustifyReflow(nsIPresContext* aPresContext,
+                            nscoord         aAvailableSpace);
 
   // Incremental reflow methods
-  virtual ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                          nsReflowMetrics& aDesiredSize,
-                                          const nsSize&    aMaxSize,
-                                          nsReflowCommand& aReflowCommand);
-  virtual void ContentAppended(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer);
-  virtual void ContentInserted(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer,
-                               nsIContent* aChild,
-                               PRInt32 aIndexInParent);
-  virtual void ContentReplaced(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer,
-                               nsIContent* aOldChild,
-                               nsIContent* aNewChild,
-                               PRInt32 aIndexInParent);
-  virtual void ContentDeleted(nsIPresShell* aShell,
+  NS_IMETHOD  IncrementalReflow(nsIPresContext*  aPresContext,
+                                nsReflowMetrics& aDesiredSize,
+                                const nsSize&    aMaxSize,
+                                nsReflowCommand& aReflowCommand,
+                                ReflowStatus&    aStatus);
+  NS_IMETHOD  ContentAppended(nsIPresShell*   aShell,
                               nsIPresContext* aPresContext,
-                              nsIContent* aContainer,
-                              nsIContent* aChild,
-                              PRInt32 aIndexInParent);
-  virtual void          GetReflowMetrics(nsIPresContext* aPresContext,
-                                         nsReflowMetrics& aMetrics);
+                              nsIContent*     aContainer);
+  NS_IMETHOD  ContentInserted(nsIPresShell*   aShell,
+                              nsIPresContext* aPresContext,
+                              nsIContent*     aContainer,
+                              nsIContent*     aChild,
+                              PRInt32         aIndexInParent);
+  NS_IMETHOD  ContentReplaced(nsIPresShell*   aShell,
+                              nsIPresContext* aPresContext,
+                              nsIContent*     aContainer,
+                              nsIContent*     aOldChild,
+                              nsIContent*     aNewChild,
+                              PRInt32         aIndexInParent);
+  NS_IMETHOD  ContentDeleted(nsIPresShell*   aShell,
+                             nsIPresContext* aPresContext,
+                             nsIContent*     aContainer,
+                             nsIContent*     aChild,
+                             PRInt32         aIndexInParent);
+
+  NS_IMETHOD  GetReflowMetrics(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aMetrics);
 
   // Flow member functions
-  virtual PRBool        IsSplittable() const;
-  virtual nsIFrame*     CreateContinuingFrame(nsIPresContext* aPresContext,
-                                              nsIFrame*       aParent);
-  virtual nsIFrame*     GetPrevInFlow() const;
-  virtual void          SetPrevInFlow(nsIFrame*);
-  virtual nsIFrame*     GetNextInFlow() const;
-  virtual void          SetNextInFlow(nsIFrame*);
+  NS_IMETHOD  IsSplittable(PRBool& aIsSplittable) const;
+  NS_IMETHOD  CreateContinuingFrame(nsIPresContext* aPresContext,
+                                    nsIFrame*       aParent,
+                                    nsIFrame*&      aContinuingFrame);
 
-  virtual void          AppendToFlow(nsIFrame* aAfterFrame);
-  virtual void          PrependToFlow(nsIFrame* aAfterFrame);
-  virtual void          RemoveFromFlow();
-  virtual void          BreakFromPrevFlow();
-  virtual void          BreakFromNextFlow();
+  NS_IMETHOD  GetPrevInFlow(nsIFrame*& aPrevInFlow) const;
+  NS_IMETHOD  SetPrevInFlow(nsIFrame*);
+  NS_IMETHOD  GetNextInFlow(nsIFrame*& aNextInFlow) const;
+  NS_IMETHOD  SetNextInFlow(nsIFrame*);
+
+  NS_IMETHOD  AppendToFlow(nsIFrame* aAfterFrame);
+  NS_IMETHOD  PrependToFlow(nsIFrame* aAfterFrame);
+  NS_IMETHOD  RemoveFromFlow();
+  NS_IMETHOD  BreakFromPrevFlow();
+  NS_IMETHOD  BreakFromNextFlow();
 
   // Associated view object
-  virtual nsIView*      GetView() const;
-  virtual void          SetView(nsIView* aView);
+  NS_IMETHOD  GetView(nsIView*& aView) const;
+  NS_IMETHOD  SetView(nsIView* aView);
 
   // Find the first geometric parent that has a view
-  virtual nsIFrame*     GetParentWithView() const;
+  NS_IMETHOD  GetParentWithView(nsIFrame*& aParent) const;
 
   // Returns the offset from this frame to the closest geometric parent that
   // has a view. Also returns the containing view, or null in case of error
-  virtual nsIView*      GetOffsetFromView(nsPoint& aOffset) const;
+  NS_IMETHOD  GetOffsetFromView(nsPoint& aOffset, nsIView*& aView) const;
 
   // Returns the closest geometric parent that has a view which has a
   // a window.
-  virtual nsIWidget*    GetWindow() const;
+  NS_IMETHOD  GetWindow(nsIWidget*&) const;
 
   // Sibling pointer used to link together frames
-  virtual nsIFrame*     GetNextSibling() const;
-  virtual void          SetNextSibling(nsIFrame* aNextSibling);
+  NS_IMETHOD  GetNextSibling(nsIFrame*& aNextSibling) const;
+  NS_IMETHOD  SetNextSibling(nsIFrame* aNextSibling);
 
   // Debugging
-  virtual void          List(FILE* out = stdout, PRInt32 aIndent = 0) const;
-  virtual void          ListTag(FILE* out = stdout) const;
-  virtual void          VerifyTree() const;
-
-  // Get the style struct associated with this frame
-  virtual nsStyleStruct* GetStyleData(const nsIID& aSID);
-
+  NS_IMETHOD  List(FILE* out = stdout, PRInt32 aIndent = 0) const;
+  NS_IMETHOD  ListTag(FILE* out = stdout) const;
+  NS_IMETHOD  VerifyTree() const;
 
 protected:
   // Constructor. Takes as arguments the content object, the index in parent,
diff --git a/mozilla/layout/base/src/nsPresContext.cpp b/mozilla/layout/base/src/nsPresContext.cpp
index 8615e15b419..ef54a55f0d0 100644
--- a/mozilla/layout/base/src/nsPresContext.cpp
+++ b/mozilla/layout/base/src/nsPresContext.cpp
@@ -190,7 +190,9 @@ void ImageLoader::UpdateFrames()
     nsIFrame* frame = (nsIFrame*) mFrames.ElementAt(i);
 
     // XXX installed colormap should be presentation-context/window state
-    nsIWidget* window = frame->GetWindow();
+    nsIWidget* window;
+     
+    frame->GetWindow(window);
     if (!gXXXInstalledColorMap && mImage) {
       nsColorMap* cmap = mImage->GetColorMap();
       if ((nsnull != cmap) && (cmap->NumColors > 0)) {
@@ -203,7 +205,9 @@ void ImageLoader::UpdateFrames()
     nsPoint offset;
     nsRect bounds;
     frame->GetRect(bounds);
-    nsIView* view = frame->GetOffsetFromView(offset);
+    nsIView* view;
+     
+    frame->GetOffsetFromView(offset, view);
     nsIViewManager* vm = view->GetViewManager();
     bounds.x = offset.x;
     bounds.y = offset.y;
@@ -360,7 +364,9 @@ nsIImage* nsPresContext::LoadImage(const nsString& aURL, nsIFrame* aForFrame)
   if (nsnull == mImageGroup) {
     // XXX this is bad; if we allow for subwindows that have different
     // rendering context's this won't work
-    nsIWidget* window = aForFrame->GetWindow();
+    nsIWidget* window;
+     
+    aForFrame->GetWindow(window);
     nsIRenderingContext* drawCtx = window->GetRenderingContext();
     drawCtx->Scale(mDeviceContext->GetAppUnitsToDevUnits(),
                    mDeviceContext->GetAppUnitsToDevUnits());
diff --git a/mozilla/layout/base/src/nsPresShell.cpp b/mozilla/layout/base/src/nsPresShell.cpp
index 947d4d0a0a5..d9acac6b4d0 100644
--- a/mozilla/layout/base/src/nsPresShell.cpp
+++ b/mozilla/layout/base/src/nsPresShell.cpp
@@ -368,7 +368,9 @@ void PresShell::ResizeReflow(nscoord aWidth, nscoord aHeight)
 #ifdef NS_DEBUG
     mRootFrame->VerifyTree();
 #endif
-    mRootFrame->ResizeReflow(mPresContext, desiredSize, maxSize, nsnull);
+    nsIFrame::ReflowStatus  status;
+
+    mRootFrame->ResizeReflow(mPresContext, desiredSize, maxSize, nsnull, status);
     mRootFrame->SizeTo(desiredSize.width, desiredSize.height);
 #ifdef NS_DEBUG
     mRootFrame->VerifyTree();
@@ -450,7 +452,9 @@ void PresShell::ProcessReflowCommands()
       mReflowCommands.RemoveElementAt(0);
 
       // Dispatch the reflow command
-      nsSize          maxSize(mRootFrame->GetWidth(), mRootFrame->GetHeight());
+      nsSize          maxSize;
+      
+      mRootFrame->GetSize(maxSize);
       rc->Dispatch(desiredSize, maxSize);
       delete rc;
     }
@@ -536,14 +540,16 @@ void PresShell::StyleSheetAdded(nsIStyleSheet* aStyleSheet)
 
 static nsIFrame* FindFrameWithContent(nsIFrame* aFrame, nsIContent* aContent)
 {
-  nsIContent* frameContent = aFrame->GetContent();
+  nsIContent* frameContent;
+   
+  aFrame->GetContent(frameContent);
   if (frameContent == aContent) {
     NS_RELEASE(frameContent);
     return aFrame;
   }
   NS_RELEASE(frameContent);
 
-  aFrame = aFrame->FirstChild();
+  aFrame->FirstChild(aFrame);
   while (aFrame) {
     nsIFrame* result = FindFrameWithContent(aFrame, aContent);
 
@@ -551,7 +557,7 @@ static nsIFrame* FindFrameWithContent(nsIFrame* aFrame, nsIContent* aContent)
       return result;
     }
 
-    aFrame = aFrame->GetNextSibling();
+    aFrame->GetNextSibling(aFrame);
   }
 
   return nsnull;
diff --git a/mozilla/layout/base/src/nsReflowCommand.cpp b/mozilla/layout/base/src/nsReflowCommand.cpp
index e27420e6bb8..4e04fcfc0c9 100644
--- a/mozilla/layout/base/src/nsReflowCommand.cpp
+++ b/mozilla/layout/base/src/nsReflowCommand.cpp
@@ -143,7 +143,7 @@ void nsReflowCommand::Dispatch(nsReflowMetrics& aDesiredSize,
   // Build the path from the target frame (index 0) to the root frame
   mPath.Clear();
   for (nsIFrame* f = (nsIFrame*)mTargetFrame; nsnull != f;
-       f = f->GetGeometricParent()) {
+       f->GetGeometricParent(f)) {
     mPath.AppendElement((void*)f);
   }
 
@@ -160,7 +160,10 @@ void nsReflowCommand::Dispatch(nsReflowMetrics& aDesiredSize,
 
   if (nsnull != root) {
     mPath.RemoveElementAt(mPath.Count() - 1);
-    root->IncrementalReflow(mPresContext, aDesiredSize, aMaxSize, *this);
+
+    nsIFrame::ReflowStatus  status;
+
+    root->IncrementalReflow(mPresContext, aDesiredSize, aMaxSize, *this, status);
   }
 }
 
@@ -178,8 +181,8 @@ nsIFrame::ReflowStatus nsReflowCommand::Next(nsReflowMetrics& aDesiredSize,
 
     NS_ASSERTION(nsnull != aNextFrame, "null frame");
     mPath.RemoveElementAt(count - 1);
-    result = aNextFrame->IncrementalReflow(mPresContext, aDesiredSize, aMaxSize,
-                                           *this);
+    aNextFrame->IncrementalReflow(mPresContext, aDesiredSize, aMaxSize,
+                                  *this, result);
   } else {
     aNextFrame = nsnull;
   }
@@ -209,12 +212,12 @@ nsIFrame::ReflowStatus nsReflowCommand::Next(nsISpaceManager* aSpaceManager,
 
     if (NS_OK == aNextFrame->QueryInterface(kIRunaroundIID, (void**)&reflowRunaround)) {
       reflowRunaround->IncrementalReflow(mPresContext, aSpaceManager, aMaxSize,
-                                         aDesiredRect, *this);
+                                         aDesiredRect, *this, result);
     } else {
       nsReflowMetrics desiredSize;
 
-      result = aNextFrame->IncrementalReflow(mPresContext, desiredSize, aMaxSize,
-                                             *this);
+      aNextFrame->IncrementalReflow(mPresContext, desiredSize, aMaxSize,
+                                    *this, result);
       aDesiredRect.x = 0;
       aDesiredRect.y = 0;
       aDesiredRect.width = desiredSize.width;
diff --git a/mozilla/layout/base/src/nsSplittableFrame.cpp b/mozilla/layout/base/src/nsSplittableFrame.cpp
index 15fcce06650..982e52ad323 100644
--- a/mozilla/layout/base/src/nsSplittableFrame.cpp
+++ b/mozilla/layout/base/src/nsSplittableFrame.cpp
@@ -35,9 +35,10 @@ nsSplittableFrame::~nsSplittableFrame()
 
 // Flow member functions
 
-PRBool nsSplittableFrame::IsSplittable() const
+NS_METHOD nsSplittableFrame::IsSplittable(PRBool& aIsSplittable) const
 {
-  return PR_TRUE;
+  aIsSplittable = PR_TRUE;
+  return NS_OK;
 }
 
 /**
@@ -48,44 +49,50 @@ PRBool nsSplittableFrame::IsSplittable() const
  *            the receiver's geometric parent
  * @return  the continuing frame or null if unsuccessful
  */
-nsIFrame* nsSplittableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                   nsIFrame*       aParent)
+NS_METHOD nsSplittableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                   nsIFrame*       aParent,
+                                                   nsIFrame*&      aContinuingFrame)
 {
   nsIContentDelegate* contentDelegate = mContent->GetDelegate(aPresContext);
-  nsIFrame*           continuingFrame =
-    contentDelegate->CreateFrame(aPresContext, mContent, mIndexInParent, aParent);
+
+  aContinuingFrame = contentDelegate->CreateFrame(aPresContext, mContent,
+                                                  mIndexInParent, aParent);
   NS_RELEASE(contentDelegate);
 
   // Append the continuing frame to the flow
-  continuingFrame->AppendToFlow(this);
+  aContinuingFrame->AppendToFlow(this);
 
   // Resolve style for the continuing frame and set its style context.
   nsIStyleContext* styleContext =
     aPresContext->ResolveStyleContextFor(mContent, aParent);
-  continuingFrame->SetStyleContext(styleContext);
+  aContinuingFrame->SetStyleContext(styleContext);
   NS_RELEASE(styleContext);
 
-  return continuingFrame;
+  return NS_OK;
 }
 
-nsIFrame* nsSplittableFrame::GetPrevInFlow() const
+NS_METHOD nsSplittableFrame::GetPrevInFlow(nsIFrame*& aPrevInFlow) const
 {
-  return mPrevInFlow;
+  aPrevInFlow = mPrevInFlow;
+  return NS_OK;
 }
 
-void nsSplittableFrame::SetPrevInFlow(nsIFrame* aFrame)
+NS_METHOD nsSplittableFrame::SetPrevInFlow(nsIFrame* aFrame)
 {
   mPrevInFlow = aFrame;
+  return NS_OK;
 }
 
-nsIFrame* nsSplittableFrame::GetNextInFlow() const
+NS_METHOD nsSplittableFrame::GetNextInFlow(nsIFrame*& aNextInFlow) const
 {
-  return mNextInFlow;
+  aNextInFlow = mNextInFlow;
+  return NS_OK;
 }
 
-void nsSplittableFrame::SetNextInFlow(nsIFrame* aFrame)
+NS_METHOD nsSplittableFrame::SetNextInFlow(nsIFrame* aFrame)
 {
   mNextInFlow = aFrame;
+  return NS_OK;
 }
 
 nsIFrame* nsSplittableFrame::GetFirstInFlow() const
@@ -113,33 +120,35 @@ nsIFrame* nsSplittableFrame::GetLastInFlow() const
 }
 
 // Append this frame to flow after aAfterFrame
-void nsSplittableFrame::AppendToFlow(nsIFrame* aAfterFrame)
+NS_METHOD nsSplittableFrame::AppendToFlow(nsIFrame* aAfterFrame)
 {
   NS_PRECONDITION(aAfterFrame != nsnull, "null pointer");
 
   mPrevInFlow = aAfterFrame;
-  mNextInFlow = aAfterFrame->GetNextInFlow();
+  aAfterFrame->GetNextInFlow(mNextInFlow);
   mPrevInFlow->SetNextInFlow(this);
   if (mNextInFlow) {
     mNextInFlow->SetPrevInFlow(this);
   }
+  return NS_OK;
 }
 
 // Prepend this frame to flow before aBeforeFrame
-void nsSplittableFrame::PrependToFlow(nsIFrame* aBeforeFrame)
+NS_METHOD nsSplittableFrame::PrependToFlow(nsIFrame* aBeforeFrame)
 {
   NS_PRECONDITION(aBeforeFrame != nsnull, "null pointer");
 
-  mPrevInFlow = aBeforeFrame->GetPrevInFlow();
+  aBeforeFrame->GetPrevInFlow(mPrevInFlow);
   mNextInFlow = aBeforeFrame;
   mNextInFlow->SetPrevInFlow(this);
   if (mPrevInFlow) {
     mPrevInFlow->SetNextInFlow(this);
   }
+  return NS_OK;
 }
 
 // Remove this frame from the flow. Connects prev in flow and next in flow
-void nsSplittableFrame::RemoveFromFlow()
+NS_METHOD nsSplittableFrame::RemoveFromFlow()
 {
   if (mPrevInFlow) {
     mPrevInFlow->SetNextInFlow(mNextInFlow);
@@ -150,23 +159,26 @@ void nsSplittableFrame::RemoveFromFlow()
   }
 
   mPrevInFlow = mNextInFlow = nsnull;
+  return NS_OK;
 }
 
 // Detach from previous frame in flow
-void nsSplittableFrame::BreakFromPrevFlow()
+NS_METHOD nsSplittableFrame::BreakFromPrevFlow()
 {
   if (mPrevInFlow) {
     mPrevInFlow->SetNextInFlow(nsnull);
     mPrevInFlow = nsnull;
   }
+  return NS_OK;
 }
 
 // Detach from next frame in flow
-void nsSplittableFrame::BreakFromNextFlow()
+NS_METHOD nsSplittableFrame::BreakFromNextFlow()
 {
   if (mNextInFlow) {
     mNextInFlow->SetPrevInFlow(nsnull);
     mNextInFlow = nsnull;
   }
+  return NS_OK;
 }
 
diff --git a/mozilla/layout/base/src/nsSplittableFrame.h b/mozilla/layout/base/src/nsSplittableFrame.h
index 221d054f3ad..479dd7bcd6a 100644
--- a/mozilla/layout/base/src/nsSplittableFrame.h
+++ b/mozilla/layout/base/src/nsSplittableFrame.h
@@ -28,13 +28,15 @@ public:
 
   // CreateContinuingFrame() does the default behavior of using the
   // content delegate to create a new frame
-  virtual PRBool      IsSplittable() const;
-  virtual nsIFrame*   CreateContinuingFrame(nsIPresContext* aPresContext,
-                                            nsIFrame*       aParent);
-  virtual nsIFrame*   GetPrevInFlow() const;
-  virtual void        SetPrevInFlow(nsIFrame*);
-  virtual nsIFrame*   GetNextInFlow() const;
-  virtual void        SetNextInFlow(nsIFrame*);
+  NS_IMETHOD  IsSplittable(PRBool& aIsSplittable) const;
+  NS_IMETHOD  CreateContinuingFrame(nsIPresContext* aPresContext,
+                                    nsIFrame*       aParent,
+                                    nsIFrame*&      aContinuingFrame);
+
+  NS_IMETHOD  GetPrevInFlow(nsIFrame*& aPrevInFlow) const;
+  NS_IMETHOD  SetPrevInFlow(nsIFrame*);
+  NS_IMETHOD  GetNextInFlow(nsIFrame*& aNextInFlow) const;
+  NS_IMETHOD  SetNextInFlow(nsIFrame*);
 
   /**
    * Return the first frame in our current flow. 
@@ -46,11 +48,11 @@ public:
    */
   nsIFrame* GetLastInFlow() const;
 
-  virtual void        AppendToFlow(nsIFrame* aAfterFrame);
-  virtual void        PrependToFlow(nsIFrame* aBeforeFrame);
-  virtual void        RemoveFromFlow();
-  virtual void        BreakFromPrevFlow();
-  virtual void        BreakFromNextFlow();
+  NS_IMETHOD  AppendToFlow(nsIFrame* aAfterFrame);
+  NS_IMETHOD  PrependToFlow(nsIFrame* aAfterFrame);
+  NS_IMETHOD  RemoveFromFlow();
+  NS_IMETHOD  BreakFromPrevFlow();
+  NS_IMETHOD  BreakFromNextFlow();
 
 protected:
   // Constructor. Takes as arguments the content object, the index in parent,
diff --git a/mozilla/layout/base/src/nsStyleContext.cpp b/mozilla/layout/base/src/nsStyleContext.cpp
index eb03ec0ccb8..1cd8ee15641 100644
--- a/mozilla/layout/base/src/nsStyleContext.cpp
+++ b/mozilla/layout/base/src/nsStyleContext.cpp
@@ -526,7 +526,9 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
     // It's text (!)
     mMolecule.display = NS_STYLE_DISPLAY_INLINE;
     mMolecule.cursor = NS_STYLE_CURSOR_IBEAM;
-    nsIContent* content = aParentFrame->GetContent();
+    nsIContent* content;
+     
+    aParentFrame->GetContent(content);
     nsIAtom* parentTag = content->GetTag();
     parentTag->ToString(buf);
     NS_RELEASE(content);
@@ -539,9 +541,13 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
 //      mFont.mFont.decorations = NS_FONT_DECORATION_UNDERLINE;
       // This simulates a <PRE><A>text inheritance rule
       // Check the parent of the A
-      nsIFrame* parentParentFrame = aParentFrame->GetGeometricParent();
+      nsIFrame* parentParentFrame;
+       
+      aParentFrame->GetGeometricParent(parentParentFrame);
       if (nsnull != parentParentFrame) {
-        nsIContent* parentParentContent = parentParentFrame->GetContent();
+        nsIContent* parentParentContent;
+         
+        parentParentFrame->GetContent(parentParentContent);
         nsIAtom* parentParentTag = parentParentContent->GetTag();
         parentParentTag->ToString(buf);
         NS_RELEASE(parentParentTag);
@@ -607,7 +613,7 @@ NS_NewStyleContext(nsIStyleContext** aInstancePtrResult,
 
   nsIStyleContext* parent = nsnull;
   if (nsnull != aParentFrame) {
-    parent = aParentFrame->GetStyleContext(aPresContext);
+    aParentFrame->GetStyleContext(aPresContext, parent);
     NS_ASSERTION(nsnull != parent, "parent frame must have style context");
   }
 
diff --git a/mozilla/layout/base/src/nsStyleSet.cpp b/mozilla/layout/base/src/nsStyleSet.cpp
index 31eb9f37ced..94ea2a5c0e7 100644
--- a/mozilla/layout/base/src/nsStyleSet.cpp
+++ b/mozilla/layout/base/src/nsStyleSet.cpp
@@ -454,7 +454,7 @@ nsIStyleContext* StyleSetImpl::ResolveStyleFor(nsIPresContext* aPresContext,
   nsIStyleContext* parentContext = nsnull;
   
   if (nsnull != aParentFrame) {
-    parentContext = aParentFrame->GetStyleContext(aPresContext);
+    aParentFrame->GetStyleContext(aPresContext, parentContext);
     NS_ASSERTION(nsnull != parentContext, "parent must have style context");
   }
 
diff --git a/mozilla/layout/base/tests/TestContainerFrame.cpp b/mozilla/layout/base/tests/TestContainerFrame.cpp
index de6a9b11616..db9e991fff8 100644
--- a/mozilla/layout/base/tests/TestContainerFrame.cpp
+++ b/mozilla/layout/base/tests/TestContainerFrame.cpp
@@ -34,7 +34,7 @@ LengthOf(nsIFrame* aChildList)
   PRInt32 result = 0;
 
   while (nsnull != aChildList) {
-    aChildList = aChildList->GetNextSibling();
+    aChildList->GetNextSibling(aChildList);
     result++;
   }
 
@@ -104,6 +104,8 @@ public:
   // Allow public access to protected member functions
   void PushChildren(nsIFrame* aFromChild, nsIFrame* aPrevSibling, PRBool aLastIsComplete);
   PRBool DeleteChildsNextInFlow(nsIFrame* aChild);
+
+  PRInt32 ChildCount() {return mChildCount;}
 };
 
 SimpleContainer::SimpleContainer(nsIContent* aContent, PRInt32 aIndexInParent)
@@ -190,42 +192,52 @@ TestChildEnumeration()
 
   // Test indexing of child frames. nsnull should be returned for index
   // values that are out of range
-  if (nsnull != f->ChildAt(-1)) {
+  nsIFrame* child;
+  f->ChildAt(-1, child);
+  if (nsnull != child) {
     printf("ChildEnumeration: child index failed for index < 0\n");
     return PR_FALSE;
   }
-  if (c1 != f->ChildAt(0)) {
+  f->ChildAt(0, child);
+  if (c1 != child) {
     printf("ChildEnumeration: wrong child at index: %d\n", 0);
     return PR_FALSE;
   }
-  if (c2 != f->ChildAt(1)) {
+  f->ChildAt(1, child);
+  if (c2 != child) {
     printf("ChildEnumeration: wrong child at index: %d\n", 1);
     return PR_FALSE;
   }
-  if (c3 != f->ChildAt(2)) {
+  f->ChildAt(2, child);
+  if (c3 != child) {
     printf("ChildEnumeration: wrong child at index: %d\n", 2);
     return PR_FALSE;
   }
-  if (nsnull != f->ChildAt(3)) {
+  f->ChildAt(3, child);
+  if (nsnull != child) {
     printf("ChildEnumeration: child index failed for index >= child countn");
     return PR_FALSE;
   }
 
   // Test first and last child member functions
-  if (f->FirstChild() != c1) {
+  f->FirstChild(child);
+  if (child != c1) {
     printf("ChildEnumeration: wrong first child\n");
     return PR_FALSE;
   }
-  if (f->LastChild() != c3) {
+  f->LastChild(child);
+  if (child != c3) {
     printf("ChildEnumeration: wrong last child\n");
     return PR_FALSE;
   }
 
+#if 0
   // Test IndexOf()
   if ((f->IndexOf(c1) != 0) || (f->IndexOf(c2) != 1) || (f->IndexOf(c3) != 2)) {
     printf("ChildEnumeration: index of failed\n");
     return PR_FALSE;
   }
+#endif
 
   return PR_TRUE;
 }
@@ -233,6 +245,7 @@ TestChildEnumeration()
 ///////////////////////////////////////////////////////////////////////////////
 //
 
+#if 0
 // Test the push children method
 //
 // This tests the following:
@@ -625,6 +638,7 @@ TestDeleteChildsNext()
 
   return PR_TRUE;
 }
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -646,6 +660,7 @@ int main(int argc, char** argv)
     return -1;
   }
 
+#if 0
   // Test the push children method
   if (!TestPushChildren()) {
     return -1;
@@ -655,6 +670,7 @@ int main(int argc, char** argv)
   if (!TestDeleteChildsNext()) {
     return -1;
   }
+#endif
 
   // Test being used as a pseudo frame
   if (!TestAsPseudo()) {
diff --git a/mozilla/layout/generic/nsBlockFrame.cpp b/mozilla/layout/generic/nsBlockFrame.cpp
index de26654f45d..1aad2a2a540 100644
--- a/mozilla/layout/generic/nsBlockFrame.cpp
+++ b/mozilla/layout/generic/nsBlockFrame.cpp
@@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 
@@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 #endif
@@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
     GetAvailableSpaceBand(aState, aY);
 
     // Get the type of floater
-    nsIStyleContext*  styleContext = floater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+     
+    floater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
   
@@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
       // both the line and the floaters are pushed to the next-in-flow...
     }
   } else {
-    lineHeight = aState.lineStart->GetHeight();
+    nsSize  size;
+
+    aState.lineStart->GetSize(size);
+    lineHeight = size.height;
   }
 
   // The first line always fits
@@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
   nsIFrame* lastFrame = aState.lineStart;
   PRInt32 lineLen = aState.lineLength - 1;
   while (--lineLen >= 0) {
-    lastFrame = lastFrame->GetNextSibling();
+    lastFrame->GetNextSibling(lastFrame);
   }
 
   // Update maxElementSize
@@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
 {
   nsIFrame* prevFrame = aState.prevLineLastFrame;
   NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
-  NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
-                  "bad prev line");
+#ifdef NS_DEBUG
+  nsIFrame* nextSibling;
+
+  prevFrame->GetNextSibling(nextSibling);
+  NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
+#endif
 
 #ifdef NS_DEBUG
   PRInt32 numKids = LengthOf(mFirstChild);
@@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
   PRInt32 kids = 0;
   while (nsnull != kid) {
     kids++;
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
   mChildCount = kids;
 
@@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // Get kid and its style
   // XXX How is this any different than what was passed in to us as aKidMol?
-  nsIContent* kid = kidFrame->GetContent();
-  nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
+  nsIContent* kid;
+  nsIStyleContext* kidSC;
+   
+  kidFrame->GetContent(kid);
+  kidFrame->GetStyleContext(aCX, kidSC);
   nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
   NS_RELEASE(kid);
 
@@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     nsIFrame* lastFrame = aState.lineStart;
     PRInt32   lineLen = aState.lineLength - 1;
     while (--lineLen >= 0) {
-      lastFrame = lastFrame->GetNextSibling();
+      lastFrame->GetNextSibling(lastFrame);
     }
 
     if (!AdvanceToNextLine(aCX, aState)) {
@@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     // Get the style for the last child, and see if it wanted to clear floaters.
     // This handles the BR tag, which is the only inline element for which clear
     // applies
-    nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
+    nsIStyleContext* lastChildSC;
+     
+    lastFrame->GetStyleContext(aCX, lastChildSC);
     nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID); 
     if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
       ClearFloaters(aState, lastChildMol->clear);
@@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
           GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
 
           // Reflow splittable children
-          if (kidFrame->IsSplittable()) {
+          PRBool  isSplittable;
+
+          kidFrame->IsSplittable(isSplittable);
+          if (isSplittable) {
             // Update size info now that we are on the next line. Then
             // reflow the child into the new available space.
             GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
             // If we just reflowed our last child then update the
             // mLastContentIsComplete state.
-            if (nsnull == kidFrame->GetNextSibling()) {
+            nsIFrame* nextSibling;
+
+            kidFrame->GetNextSibling(nextSibling);
+            if (nsnull == nextSibling) {
               // Use state from the reflow we just did
               mLastContentIsComplete = PRBool(status == frComplete);
             }
@@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // If we just reflowed our last child then update the
   // mLastContentIsComplete state.
-  if (nsnull == kidFrame->GetNextSibling()) {
+  nsIFrame* nextSibling;
+
+  kidFrame->GetNextSibling(nextSibling);
+  if (nsnull == nextSibling) {
     // Use state from the reflow we just did
     mLastContentIsComplete = PRBool(status == frComplete);
   }
@@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
   nsIFrame* prevKidFrame = nsnull;
 
   for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     NS_RELEASE(kid);
@@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
     }
 
     // Is the child complete?
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
     if (frComplete == status) {
       // Yes, the child is complete
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+      NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
     } else {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         mChildCount++;
@@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
 
     // Get the next child frame
     prevKidFrame = kidFrame;
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
   }
 
- push_done:;
-  // Update the child count member data
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
-
+ push_done:
 #ifdef NS_DEBUG
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+
   PRInt32 len = LengthOf(mFirstChild);
   NS_POSTCONDITION(len == mChildCount, "bad child count");
   VerifyLastIsComplete();
@@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     mFirstContentOffset = prev->NextChildOffset();
     if (PR_FALSE == prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
 
   // Place our children, one at a time until we are out of children
   PRInt32 kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     } else {
       // Since kid has a prev-in-flow, use that to create the next
       // frame.
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
+      kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
     }
 
     // Link child frame into the list of children. If the frame ends
     // up not fitting and getting pushed, the PushKids code will fixup
     // the child count for us.
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // We ran out of room.
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         NS_RELEASE(kid);
@@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       if (frNotComplete == status) {
         // Child didn't complete so create a continuing frame
         kidPrevInFlow = kidFrame;
-        nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
         // Add the continuing frame to the sibling list
-        continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+        nsIFrame* kidNextSibling;
+
+        kidFrame->GetNextSibling(kidNextSibling);
+        continuingFrame->SetNextSibling(kidNextSibling);
         kidFrame->SetNextSibling(continuingFrame);
         kidFrame = continuingFrame;
         mChildCount++;
 
         // Switch to new kid style
         NS_RELEASE(kidSC);
-        kidSC = kidFrame->GetStyleContext(aCX);
+        kidFrame->GetStyleContext(aCX, kidSC);
         kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       }
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
+#ifdef NS_DEBUG
+      nsIFrame* kidNextInFlow;
+
+      kidFrame->GetNextInFlow(kidNextInFlow);
+      NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
+#endif
     } while (frNotComplete == status);
     NS_RELEASE(kid);
     NS_RELEASE(kidSC);
 
     // The child that we just reflowed is complete
-    NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+#ifdef NS_DEBUG
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
+    NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
+#endif
     kidIndex++;
     kidPrevInFlow = nsnull;
   }
@@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
   // children OR we are a pseudo-frame and we ran into a block
   // element. In either case our last content MUST be complete.
   NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 
  push_done:
@@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
   PRBool result = PR_TRUE;
   nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   while (nsnull != nextInFlow) {
     // Get first available frame from the next-in-flow
     nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     }
 
     // Get style information for the pulled up kid
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
 
@@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // Push the kids that didn't fit back down to the next-in-flow
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         result = PR_FALSE;
@@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
       if (frNotComplete == status) {
         // Child is not complete
-        nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         if (nsnull == kidNextInFlow) {
           // Create a continuing frame for the incomplete child
-          nsIFrame* continuingFrame =
-            kidFrame->CreateContinuingFrame(aCX, this);
+          nsIFrame* continuingFrame;
+           
+          kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
           // Add the continuing frame to our sibling list.
-          continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+          nsIFrame* nextSibling;
+
+          kidFrame->GetNextSibling(nextSibling);
+          continuingFrame->SetNextSibling(nextSibling);
           kidFrame->SetNextSibling(continuingFrame);
           prevKidFrame = kidFrame;
           kidFrame = continuingFrame;
@@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
           // Switch to new kid style
           NS_RELEASE(kidSC);
-          kidSC = kidFrame->GetStyleContext(aCX);
+          kidFrame->GetStyleContext(aCX, kidSC);
           kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
         } else {
           // The child has a next-in-flow, but it's not one of ours.
           // It *must* be in one of our next-in-flows. Collect it
           // then.
-          NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
-                       "busted kid next-in-flow");
+          NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
           break;
         }
       }
@@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     // in our next-in-flows (and reflowing any continunations they
     // have). Therefore we KNOW that our last child is complete.
     NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
 }
 
 #include "nsUnitConversion.h"/* XXX */
-nsIFrame::ReflowStatus
-nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
-                           nsISpaceManager* aSpaceManager,
-                           const nsSize& aMaxSize,
-                           nsRect& aDesiredRect,
-                           nsSize* aMaxElementSize)
+NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
+                                     nsISpaceManager* aSpaceManager,
+                                     const nsSize& aMaxSize,
+                                     nsRect& aDesiredRect,
+                                     nsSize* aMaxElementSize,
+                                     ReflowStatus& aStatus)
 {
   nsBlockReflowState state;
   SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
-  return DoResizeReflow(aCX, state, aDesiredRect);
+  return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
-                             nsBlockReflowState& aState,
-                             nsRect& aDesiredRect)
+nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
+                                      nsBlockReflowState& aState,
+                                      nsRect& aDesiredRect,
+                                      ReflowStatus& aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
@@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 
   // First reflow any existing frames
   PRBool reflowMappedOK = PR_TRUE;
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aCX, aState);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
       // unmapped.  We need to return the correct completion status,
       // so see if there is more to reflow.
       if (MoreToReflow(aCX)) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (MoreToReflow(aCX)) {
       // Try and pull-up some children from a next-in-flow
       if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
         // If we still have unmapped children then create some new frames
         if (MoreToReflow(aCX)) {
-          status = ReflowAppendedChildren(aCX, aState);
+          aStatus = ReflowAppendedChildren(aCX, aState);
         }
       } else {
         // We were unable to pull-up all the existing frames from the
         // next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
@@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 #endif
 
       PushKids(aState);
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there is room for it.
     nscoord margin = aState.prevMaxPosBottomMargin -
@@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   aDesiredRect.height = aState.y;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
 #ifdef NOISY
   ListTag(stdout);
@@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   DumpFlow();
 #endif
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
           kid->JustifyReflow(aCX, availableSpace);
           kid->SizeTo(r.width + availableSpace, r.height);
         }
-        kid = kid->GetNextSibling();
+        kid->GetNextSibling(kid);
       } else {
         // XXX Get justification of multiple elements working
         while (--lineLength >= 0) {
-          kid = kid->GetNextSibling();
+          kid->GetNextSibling(kid);
         }
       }
     }
@@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
   }
 }
 
-nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
-                                              nsIFrame* aParent)
+NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
+                                              nsIFrame* aParent,
+                                              nsIFrame*& aContinuingFrame)
 {
   nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aCX, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
-                                nsISpaceManager* aSpaceManager,
-                                const nsSize& aMaxSize,
-                                nsRect& aDesiredRect,
-                                nsReflowCommand& aReflowCommand)
+NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
+                                          nsISpaceManager* aSpaceManager,
+                                          const nsSize& aMaxSize,
+                                          nsRect& aDesiredRect,
+                                          nsReflowCommand& aReflowCommand,
+                                          ReflowStatus& aStatus)
 {
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
 
   if (aReflowCommand.GetTarget() == this) {
     // XXX for now, just do a complete reflow mapped (it'll kinda
@@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
     SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
     PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   } else {
     // XXX not yet implemented
@@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
   }
 
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
 {
   do {
-    nsIFrame* parent = aFrame->GetGeometricParent();
+    nsIFrame* parent;
+     
+    aFrame->GetGeometricParent(parent);
   
     // See if there are any non-zero sized child frames that precede aFrame
     // in the child list
-    nsIFrame* child = parent->FirstChild();
-  
+    nsIFrame* child;
+     
+    parent->FirstChild(child);
     while ((nsnull != child) && (aFrame != child)) {
+      nsSize  size;
+
       // Is the child zero-sized?
-      if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
+      child->GetSize(size);
+      if ((size.width > 0) || (size.height > 0)) {
         // We found a non-zero sized child frame that precedes aFrame
         return PR_FALSE;
       }
   
-      child = child->GetNextSibling();
+      child->GetNextSibling(child);
     }
   
     // aFrame is the left-most non-zero sized frame in its geometric parent.
@@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   // todo list and we'll handle it when we flush out the line
   if (IsLeftMostChild(aPlaceholder)) {
     // Get the type of floater
-    nsIStyleContext*  styleContext = aFloater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+
+    aFloater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
 
@@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   }
 }
 
-void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
-                                   nsIPresContext* aPresContext,
-                                   nsIContent* aContainer)
+NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
+                                        nsIPresContext* aPresContext,
+                                        nsIContent* aContainer)
 {
-  // Zip down to the end-of-flow
-  nsBlockFrame* flow = this;
-  for (;;) {
-    nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
-    if (nsnull == next) {
-      break;
-    }
-    flow = next;
-  }
+  // Get the last-in-flow
+  nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
 
   PRInt32 kidIndex = flow->NextChildOffset();
   PRInt32 startIndex = kidIndex;
-  nsIFrame* prevKidFrame = flow->LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  flow->LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
           NS_RELEASE(kidSC);
           NS_RELEASE(kid);
   
-          return;
+          return NS_OK;
         }
         // FALL THROUGH (and create frame)
   
@@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
 
     // Link child frame into the list of children
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
                           startIndex);
     aShell->AppendReflowCommand(rc);
   }
+  return NS_OK;
 }
 
 PRIntn nsBlockFrame::GetSkipSides() const
@@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
   return eHTMLFrame_Block;
 }
 
-void nsBlockFrame::ListTag(FILE* out) const
+NS_METHOD nsBlockFrame::ListTag(FILE* out) const
 {
   if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
     fprintf(out, "*block(%d)@%p", mIndexInParent, this);
   } else {
     nsHTMLContainerFrame::ListTag(out);
   }
+  return NS_OK;
 }
 
 #ifdef NS_DEBUG
diff --git a/mozilla/layout/generic/nsBlockFrame.h b/mozilla/layout/generic/nsBlockFrame.h
index ab55c5dbeed..1f348962776 100644
--- a/mozilla/layout/generic/nsBlockFrame.h
+++ b/mozilla/layout/generic/nsBlockFrame.h
@@ -198,24 +198,27 @@ public:
 
   NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
-                                    nsISpaceManager* aSpaceManager,
-                                    const nsSize& aMaxSize,
-                                    nsRect& aDesiredRect,
-                                    nsSize* aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsISpaceManager* aSpaceManager,
+                          const nsSize& aMaxSize,
+                          nsRect& aDesiredRect,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
-                                         nsISpaceManager* aSpaceManager,
-                                         const nsSize& aMaxSize,
-                                         nsRect& aDesiredRect,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
+                               nsISpaceManager* aSpaceManager,
+                               const nsSize& aMaxSize,
+                               nsRect& aDesiredRect,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus& aStatus);
 
-  virtual void ContentAppended(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer);
+  NS_IMETHOD ContentAppended(nsIPresShell* aShell,
+                             nsIPresContext* aPresContext,
+                             nsIContent* aContainer);
 
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame* aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame* aParent,
+                                   nsIFrame*& aContinuingFrame);
 
   virtual PRBool AddFloater(nsIPresContext* aCX,
                             nsIFrame* aFloater,
@@ -224,7 +227,7 @@ public:
                             nsIFrame* aFloater,
                             PlaceholderFrame* aPlaceholder);
 
-  virtual void ListTag(FILE* out = stdout) const;
+  NS_IMETHOD ListTag(FILE* out = stdout) const;
 
   virtual nsHTMLFrameType GetFrameType() const;
 
@@ -277,9 +280,10 @@ protected:
                   const nsSize& aMaxSize, nsSize* aMaxElementSize,
                   nsISpaceManager* aSpaceManager);
 
-  ReflowStatus DoResizeReflow(nsIPresContext* aPresContext,
-                              nsBlockReflowState& aState,
-                              nsRect& aDesiredRect);
+  nsresult DoResizeReflow(nsIPresContext* aPresContext,
+                          nsBlockReflowState& aState,
+                          nsRect& aDesiredRect,
+                          ReflowStatus& aStatus);
 
   PRBool ReflowMappedChildren(nsIPresContext* aPresContext,
                               nsBlockReflowState& aState);
diff --git a/mozilla/layout/generic/nsBlockReflowState.cpp b/mozilla/layout/generic/nsBlockReflowState.cpp
index de26654f45d..1aad2a2a540 100644
--- a/mozilla/layout/generic/nsBlockReflowState.cpp
+++ b/mozilla/layout/generic/nsBlockReflowState.cpp
@@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 
@@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 #endif
@@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
     GetAvailableSpaceBand(aState, aY);
 
     // Get the type of floater
-    nsIStyleContext*  styleContext = floater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+     
+    floater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
   
@@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
       // both the line and the floaters are pushed to the next-in-flow...
     }
   } else {
-    lineHeight = aState.lineStart->GetHeight();
+    nsSize  size;
+
+    aState.lineStart->GetSize(size);
+    lineHeight = size.height;
   }
 
   // The first line always fits
@@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
   nsIFrame* lastFrame = aState.lineStart;
   PRInt32 lineLen = aState.lineLength - 1;
   while (--lineLen >= 0) {
-    lastFrame = lastFrame->GetNextSibling();
+    lastFrame->GetNextSibling(lastFrame);
   }
 
   // Update maxElementSize
@@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
 {
   nsIFrame* prevFrame = aState.prevLineLastFrame;
   NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
-  NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
-                  "bad prev line");
+#ifdef NS_DEBUG
+  nsIFrame* nextSibling;
+
+  prevFrame->GetNextSibling(nextSibling);
+  NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
+#endif
 
 #ifdef NS_DEBUG
   PRInt32 numKids = LengthOf(mFirstChild);
@@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
   PRInt32 kids = 0;
   while (nsnull != kid) {
     kids++;
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
   mChildCount = kids;
 
@@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // Get kid and its style
   // XXX How is this any different than what was passed in to us as aKidMol?
-  nsIContent* kid = kidFrame->GetContent();
-  nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
+  nsIContent* kid;
+  nsIStyleContext* kidSC;
+   
+  kidFrame->GetContent(kid);
+  kidFrame->GetStyleContext(aCX, kidSC);
   nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
   NS_RELEASE(kid);
 
@@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     nsIFrame* lastFrame = aState.lineStart;
     PRInt32   lineLen = aState.lineLength - 1;
     while (--lineLen >= 0) {
-      lastFrame = lastFrame->GetNextSibling();
+      lastFrame->GetNextSibling(lastFrame);
     }
 
     if (!AdvanceToNextLine(aCX, aState)) {
@@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     // Get the style for the last child, and see if it wanted to clear floaters.
     // This handles the BR tag, which is the only inline element for which clear
     // applies
-    nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
+    nsIStyleContext* lastChildSC;
+     
+    lastFrame->GetStyleContext(aCX, lastChildSC);
     nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID); 
     if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
       ClearFloaters(aState, lastChildMol->clear);
@@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
           GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
 
           // Reflow splittable children
-          if (kidFrame->IsSplittable()) {
+          PRBool  isSplittable;
+
+          kidFrame->IsSplittable(isSplittable);
+          if (isSplittable) {
             // Update size info now that we are on the next line. Then
             // reflow the child into the new available space.
             GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
             // If we just reflowed our last child then update the
             // mLastContentIsComplete state.
-            if (nsnull == kidFrame->GetNextSibling()) {
+            nsIFrame* nextSibling;
+
+            kidFrame->GetNextSibling(nextSibling);
+            if (nsnull == nextSibling) {
               // Use state from the reflow we just did
               mLastContentIsComplete = PRBool(status == frComplete);
             }
@@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // If we just reflowed our last child then update the
   // mLastContentIsComplete state.
-  if (nsnull == kidFrame->GetNextSibling()) {
+  nsIFrame* nextSibling;
+
+  kidFrame->GetNextSibling(nextSibling);
+  if (nsnull == nextSibling) {
     // Use state from the reflow we just did
     mLastContentIsComplete = PRBool(status == frComplete);
   }
@@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
   nsIFrame* prevKidFrame = nsnull;
 
   for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     NS_RELEASE(kid);
@@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
     }
 
     // Is the child complete?
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
     if (frComplete == status) {
       // Yes, the child is complete
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+      NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
     } else {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         mChildCount++;
@@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
 
     // Get the next child frame
     prevKidFrame = kidFrame;
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
   }
 
- push_done:;
-  // Update the child count member data
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
-
+ push_done:
 #ifdef NS_DEBUG
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+
   PRInt32 len = LengthOf(mFirstChild);
   NS_POSTCONDITION(len == mChildCount, "bad child count");
   VerifyLastIsComplete();
@@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     mFirstContentOffset = prev->NextChildOffset();
     if (PR_FALSE == prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
 
   // Place our children, one at a time until we are out of children
   PRInt32 kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     } else {
       // Since kid has a prev-in-flow, use that to create the next
       // frame.
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
+      kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
     }
 
     // Link child frame into the list of children. If the frame ends
     // up not fitting and getting pushed, the PushKids code will fixup
     // the child count for us.
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // We ran out of room.
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         NS_RELEASE(kid);
@@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       if (frNotComplete == status) {
         // Child didn't complete so create a continuing frame
         kidPrevInFlow = kidFrame;
-        nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
         // Add the continuing frame to the sibling list
-        continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+        nsIFrame* kidNextSibling;
+
+        kidFrame->GetNextSibling(kidNextSibling);
+        continuingFrame->SetNextSibling(kidNextSibling);
         kidFrame->SetNextSibling(continuingFrame);
         kidFrame = continuingFrame;
         mChildCount++;
 
         // Switch to new kid style
         NS_RELEASE(kidSC);
-        kidSC = kidFrame->GetStyleContext(aCX);
+        kidFrame->GetStyleContext(aCX, kidSC);
         kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       }
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
+#ifdef NS_DEBUG
+      nsIFrame* kidNextInFlow;
+
+      kidFrame->GetNextInFlow(kidNextInFlow);
+      NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
+#endif
     } while (frNotComplete == status);
     NS_RELEASE(kid);
     NS_RELEASE(kidSC);
 
     // The child that we just reflowed is complete
-    NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+#ifdef NS_DEBUG
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
+    NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
+#endif
     kidIndex++;
     kidPrevInFlow = nsnull;
   }
@@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
   // children OR we are a pseudo-frame and we ran into a block
   // element. In either case our last content MUST be complete.
   NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 
  push_done:
@@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
   PRBool result = PR_TRUE;
   nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   while (nsnull != nextInFlow) {
     // Get first available frame from the next-in-flow
     nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     }
 
     // Get style information for the pulled up kid
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
 
@@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // Push the kids that didn't fit back down to the next-in-flow
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         result = PR_FALSE;
@@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
       if (frNotComplete == status) {
         // Child is not complete
-        nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         if (nsnull == kidNextInFlow) {
           // Create a continuing frame for the incomplete child
-          nsIFrame* continuingFrame =
-            kidFrame->CreateContinuingFrame(aCX, this);
+          nsIFrame* continuingFrame;
+           
+          kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
           // Add the continuing frame to our sibling list.
-          continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+          nsIFrame* nextSibling;
+
+          kidFrame->GetNextSibling(nextSibling);
+          continuingFrame->SetNextSibling(nextSibling);
           kidFrame->SetNextSibling(continuingFrame);
           prevKidFrame = kidFrame;
           kidFrame = continuingFrame;
@@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
           // Switch to new kid style
           NS_RELEASE(kidSC);
-          kidSC = kidFrame->GetStyleContext(aCX);
+          kidFrame->GetStyleContext(aCX, kidSC);
           kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
         } else {
           // The child has a next-in-flow, but it's not one of ours.
           // It *must* be in one of our next-in-flows. Collect it
           // then.
-          NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
-                       "busted kid next-in-flow");
+          NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
           break;
         }
       }
@@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     // in our next-in-flows (and reflowing any continunations they
     // have). Therefore we KNOW that our last child is complete.
     NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
 }
 
 #include "nsUnitConversion.h"/* XXX */
-nsIFrame::ReflowStatus
-nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
-                           nsISpaceManager* aSpaceManager,
-                           const nsSize& aMaxSize,
-                           nsRect& aDesiredRect,
-                           nsSize* aMaxElementSize)
+NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
+                                     nsISpaceManager* aSpaceManager,
+                                     const nsSize& aMaxSize,
+                                     nsRect& aDesiredRect,
+                                     nsSize* aMaxElementSize,
+                                     ReflowStatus& aStatus)
 {
   nsBlockReflowState state;
   SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
-  return DoResizeReflow(aCX, state, aDesiredRect);
+  return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
-                             nsBlockReflowState& aState,
-                             nsRect& aDesiredRect)
+nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
+                                      nsBlockReflowState& aState,
+                                      nsRect& aDesiredRect,
+                                      ReflowStatus& aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
@@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 
   // First reflow any existing frames
   PRBool reflowMappedOK = PR_TRUE;
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aCX, aState);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
       // unmapped.  We need to return the correct completion status,
       // so see if there is more to reflow.
       if (MoreToReflow(aCX)) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (MoreToReflow(aCX)) {
       // Try and pull-up some children from a next-in-flow
       if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
         // If we still have unmapped children then create some new frames
         if (MoreToReflow(aCX)) {
-          status = ReflowAppendedChildren(aCX, aState);
+          aStatus = ReflowAppendedChildren(aCX, aState);
         }
       } else {
         // We were unable to pull-up all the existing frames from the
         // next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
@@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 #endif
 
       PushKids(aState);
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there is room for it.
     nscoord margin = aState.prevMaxPosBottomMargin -
@@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   aDesiredRect.height = aState.y;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
 #ifdef NOISY
   ListTag(stdout);
@@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   DumpFlow();
 #endif
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
           kid->JustifyReflow(aCX, availableSpace);
           kid->SizeTo(r.width + availableSpace, r.height);
         }
-        kid = kid->GetNextSibling();
+        kid->GetNextSibling(kid);
       } else {
         // XXX Get justification of multiple elements working
         while (--lineLength >= 0) {
-          kid = kid->GetNextSibling();
+          kid->GetNextSibling(kid);
         }
       }
     }
@@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
   }
 }
 
-nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
-                                              nsIFrame* aParent)
+NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
+                                              nsIFrame* aParent,
+                                              nsIFrame*& aContinuingFrame)
 {
   nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aCX, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
-                                nsISpaceManager* aSpaceManager,
-                                const nsSize& aMaxSize,
-                                nsRect& aDesiredRect,
-                                nsReflowCommand& aReflowCommand)
+NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
+                                          nsISpaceManager* aSpaceManager,
+                                          const nsSize& aMaxSize,
+                                          nsRect& aDesiredRect,
+                                          nsReflowCommand& aReflowCommand,
+                                          ReflowStatus& aStatus)
 {
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
 
   if (aReflowCommand.GetTarget() == this) {
     // XXX for now, just do a complete reflow mapped (it'll kinda
@@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
     SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
     PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   } else {
     // XXX not yet implemented
@@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
   }
 
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
 {
   do {
-    nsIFrame* parent = aFrame->GetGeometricParent();
+    nsIFrame* parent;
+     
+    aFrame->GetGeometricParent(parent);
   
     // See if there are any non-zero sized child frames that precede aFrame
     // in the child list
-    nsIFrame* child = parent->FirstChild();
-  
+    nsIFrame* child;
+     
+    parent->FirstChild(child);
     while ((nsnull != child) && (aFrame != child)) {
+      nsSize  size;
+
       // Is the child zero-sized?
-      if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
+      child->GetSize(size);
+      if ((size.width > 0) || (size.height > 0)) {
         // We found a non-zero sized child frame that precedes aFrame
         return PR_FALSE;
       }
   
-      child = child->GetNextSibling();
+      child->GetNextSibling(child);
     }
   
     // aFrame is the left-most non-zero sized frame in its geometric parent.
@@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   // todo list and we'll handle it when we flush out the line
   if (IsLeftMostChild(aPlaceholder)) {
     // Get the type of floater
-    nsIStyleContext*  styleContext = aFloater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+
+    aFloater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
 
@@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   }
 }
 
-void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
-                                   nsIPresContext* aPresContext,
-                                   nsIContent* aContainer)
+NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
+                                        nsIPresContext* aPresContext,
+                                        nsIContent* aContainer)
 {
-  // Zip down to the end-of-flow
-  nsBlockFrame* flow = this;
-  for (;;) {
-    nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
-    if (nsnull == next) {
-      break;
-    }
-    flow = next;
-  }
+  // Get the last-in-flow
+  nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
 
   PRInt32 kidIndex = flow->NextChildOffset();
   PRInt32 startIndex = kidIndex;
-  nsIFrame* prevKidFrame = flow->LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  flow->LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
           NS_RELEASE(kidSC);
           NS_RELEASE(kid);
   
-          return;
+          return NS_OK;
         }
         // FALL THROUGH (and create frame)
   
@@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
 
     // Link child frame into the list of children
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
                           startIndex);
     aShell->AppendReflowCommand(rc);
   }
+  return NS_OK;
 }
 
 PRIntn nsBlockFrame::GetSkipSides() const
@@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
   return eHTMLFrame_Block;
 }
 
-void nsBlockFrame::ListTag(FILE* out) const
+NS_METHOD nsBlockFrame::ListTag(FILE* out) const
 {
   if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
     fprintf(out, "*block(%d)@%p", mIndexInParent, this);
   } else {
     nsHTMLContainerFrame::ListTag(out);
   }
+  return NS_OK;
 }
 
 #ifdef NS_DEBUG
diff --git a/mozilla/layout/generic/nsBlockReflowState.h b/mozilla/layout/generic/nsBlockReflowState.h
index de26654f45d..1aad2a2a540 100644
--- a/mozilla/layout/generic/nsBlockReflowState.h
+++ b/mozilla/layout/generic/nsBlockReflowState.h
@@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 
@@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 #endif
@@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
     GetAvailableSpaceBand(aState, aY);
 
     // Get the type of floater
-    nsIStyleContext*  styleContext = floater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+     
+    floater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
   
@@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
       // both the line and the floaters are pushed to the next-in-flow...
     }
   } else {
-    lineHeight = aState.lineStart->GetHeight();
+    nsSize  size;
+
+    aState.lineStart->GetSize(size);
+    lineHeight = size.height;
   }
 
   // The first line always fits
@@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
   nsIFrame* lastFrame = aState.lineStart;
   PRInt32 lineLen = aState.lineLength - 1;
   while (--lineLen >= 0) {
-    lastFrame = lastFrame->GetNextSibling();
+    lastFrame->GetNextSibling(lastFrame);
   }
 
   // Update maxElementSize
@@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
 {
   nsIFrame* prevFrame = aState.prevLineLastFrame;
   NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
-  NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
-                  "bad prev line");
+#ifdef NS_DEBUG
+  nsIFrame* nextSibling;
+
+  prevFrame->GetNextSibling(nextSibling);
+  NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
+#endif
 
 #ifdef NS_DEBUG
   PRInt32 numKids = LengthOf(mFirstChild);
@@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
   PRInt32 kids = 0;
   while (nsnull != kid) {
     kids++;
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
   mChildCount = kids;
 
@@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // Get kid and its style
   // XXX How is this any different than what was passed in to us as aKidMol?
-  nsIContent* kid = kidFrame->GetContent();
-  nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
+  nsIContent* kid;
+  nsIStyleContext* kidSC;
+   
+  kidFrame->GetContent(kid);
+  kidFrame->GetStyleContext(aCX, kidSC);
   nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
   NS_RELEASE(kid);
 
@@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     nsIFrame* lastFrame = aState.lineStart;
     PRInt32   lineLen = aState.lineLength - 1;
     while (--lineLen >= 0) {
-      lastFrame = lastFrame->GetNextSibling();
+      lastFrame->GetNextSibling(lastFrame);
     }
 
     if (!AdvanceToNextLine(aCX, aState)) {
@@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     // Get the style for the last child, and see if it wanted to clear floaters.
     // This handles the BR tag, which is the only inline element for which clear
     // applies
-    nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
+    nsIStyleContext* lastChildSC;
+     
+    lastFrame->GetStyleContext(aCX, lastChildSC);
     nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID); 
     if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
       ClearFloaters(aState, lastChildMol->clear);
@@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
           GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
 
           // Reflow splittable children
-          if (kidFrame->IsSplittable()) {
+          PRBool  isSplittable;
+
+          kidFrame->IsSplittable(isSplittable);
+          if (isSplittable) {
             // Update size info now that we are on the next line. Then
             // reflow the child into the new available space.
             GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
             // If we just reflowed our last child then update the
             // mLastContentIsComplete state.
-            if (nsnull == kidFrame->GetNextSibling()) {
+            nsIFrame* nextSibling;
+
+            kidFrame->GetNextSibling(nextSibling);
+            if (nsnull == nextSibling) {
               // Use state from the reflow we just did
               mLastContentIsComplete = PRBool(status == frComplete);
             }
@@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // If we just reflowed our last child then update the
   // mLastContentIsComplete state.
-  if (nsnull == kidFrame->GetNextSibling()) {
+  nsIFrame* nextSibling;
+
+  kidFrame->GetNextSibling(nextSibling);
+  if (nsnull == nextSibling) {
     // Use state from the reflow we just did
     mLastContentIsComplete = PRBool(status == frComplete);
   }
@@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
   nsIFrame* prevKidFrame = nsnull;
 
   for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     NS_RELEASE(kid);
@@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
     }
 
     // Is the child complete?
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
     if (frComplete == status) {
       // Yes, the child is complete
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+      NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
     } else {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         mChildCount++;
@@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
 
     // Get the next child frame
     prevKidFrame = kidFrame;
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
   }
 
- push_done:;
-  // Update the child count member data
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
-
+ push_done:
 #ifdef NS_DEBUG
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+
   PRInt32 len = LengthOf(mFirstChild);
   NS_POSTCONDITION(len == mChildCount, "bad child count");
   VerifyLastIsComplete();
@@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     mFirstContentOffset = prev->NextChildOffset();
     if (PR_FALSE == prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
 
   // Place our children, one at a time until we are out of children
   PRInt32 kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     } else {
       // Since kid has a prev-in-flow, use that to create the next
       // frame.
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
+      kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
     }
 
     // Link child frame into the list of children. If the frame ends
     // up not fitting and getting pushed, the PushKids code will fixup
     // the child count for us.
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // We ran out of room.
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         NS_RELEASE(kid);
@@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       if (frNotComplete == status) {
         // Child didn't complete so create a continuing frame
         kidPrevInFlow = kidFrame;
-        nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
         // Add the continuing frame to the sibling list
-        continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+        nsIFrame* kidNextSibling;
+
+        kidFrame->GetNextSibling(kidNextSibling);
+        continuingFrame->SetNextSibling(kidNextSibling);
         kidFrame->SetNextSibling(continuingFrame);
         kidFrame = continuingFrame;
         mChildCount++;
 
         // Switch to new kid style
         NS_RELEASE(kidSC);
-        kidSC = kidFrame->GetStyleContext(aCX);
+        kidFrame->GetStyleContext(aCX, kidSC);
         kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       }
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
+#ifdef NS_DEBUG
+      nsIFrame* kidNextInFlow;
+
+      kidFrame->GetNextInFlow(kidNextInFlow);
+      NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
+#endif
     } while (frNotComplete == status);
     NS_RELEASE(kid);
     NS_RELEASE(kidSC);
 
     // The child that we just reflowed is complete
-    NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+#ifdef NS_DEBUG
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
+    NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
+#endif
     kidIndex++;
     kidPrevInFlow = nsnull;
   }
@@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
   // children OR we are a pseudo-frame and we ran into a block
   // element. In either case our last content MUST be complete.
   NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 
  push_done:
@@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
   PRBool result = PR_TRUE;
   nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   while (nsnull != nextInFlow) {
     // Get first available frame from the next-in-flow
     nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     }
 
     // Get style information for the pulled up kid
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
 
@@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // Push the kids that didn't fit back down to the next-in-flow
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         result = PR_FALSE;
@@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
       if (frNotComplete == status) {
         // Child is not complete
-        nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         if (nsnull == kidNextInFlow) {
           // Create a continuing frame for the incomplete child
-          nsIFrame* continuingFrame =
-            kidFrame->CreateContinuingFrame(aCX, this);
+          nsIFrame* continuingFrame;
+           
+          kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
           // Add the continuing frame to our sibling list.
-          continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+          nsIFrame* nextSibling;
+
+          kidFrame->GetNextSibling(nextSibling);
+          continuingFrame->SetNextSibling(nextSibling);
           kidFrame->SetNextSibling(continuingFrame);
           prevKidFrame = kidFrame;
           kidFrame = continuingFrame;
@@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
           // Switch to new kid style
           NS_RELEASE(kidSC);
-          kidSC = kidFrame->GetStyleContext(aCX);
+          kidFrame->GetStyleContext(aCX, kidSC);
           kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
         } else {
           // The child has a next-in-flow, but it's not one of ours.
           // It *must* be in one of our next-in-flows. Collect it
           // then.
-          NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
-                       "busted kid next-in-flow");
+          NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
           break;
         }
       }
@@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     // in our next-in-flows (and reflowing any continunations they
     // have). Therefore we KNOW that our last child is complete.
     NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
 }
 
 #include "nsUnitConversion.h"/* XXX */
-nsIFrame::ReflowStatus
-nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
-                           nsISpaceManager* aSpaceManager,
-                           const nsSize& aMaxSize,
-                           nsRect& aDesiredRect,
-                           nsSize* aMaxElementSize)
+NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
+                                     nsISpaceManager* aSpaceManager,
+                                     const nsSize& aMaxSize,
+                                     nsRect& aDesiredRect,
+                                     nsSize* aMaxElementSize,
+                                     ReflowStatus& aStatus)
 {
   nsBlockReflowState state;
   SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
-  return DoResizeReflow(aCX, state, aDesiredRect);
+  return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
-                             nsBlockReflowState& aState,
-                             nsRect& aDesiredRect)
+nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
+                                      nsBlockReflowState& aState,
+                                      nsRect& aDesiredRect,
+                                      ReflowStatus& aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
@@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 
   // First reflow any existing frames
   PRBool reflowMappedOK = PR_TRUE;
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aCX, aState);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
       // unmapped.  We need to return the correct completion status,
       // so see if there is more to reflow.
       if (MoreToReflow(aCX)) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (MoreToReflow(aCX)) {
       // Try and pull-up some children from a next-in-flow
       if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
         // If we still have unmapped children then create some new frames
         if (MoreToReflow(aCX)) {
-          status = ReflowAppendedChildren(aCX, aState);
+          aStatus = ReflowAppendedChildren(aCX, aState);
         }
       } else {
         // We were unable to pull-up all the existing frames from the
         // next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
@@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 #endif
 
       PushKids(aState);
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there is room for it.
     nscoord margin = aState.prevMaxPosBottomMargin -
@@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   aDesiredRect.height = aState.y;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
 #ifdef NOISY
   ListTag(stdout);
@@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   DumpFlow();
 #endif
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
           kid->JustifyReflow(aCX, availableSpace);
           kid->SizeTo(r.width + availableSpace, r.height);
         }
-        kid = kid->GetNextSibling();
+        kid->GetNextSibling(kid);
       } else {
         // XXX Get justification of multiple elements working
         while (--lineLength >= 0) {
-          kid = kid->GetNextSibling();
+          kid->GetNextSibling(kid);
         }
       }
     }
@@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
   }
 }
 
-nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
-                                              nsIFrame* aParent)
+NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
+                                              nsIFrame* aParent,
+                                              nsIFrame*& aContinuingFrame)
 {
   nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aCX, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
-                                nsISpaceManager* aSpaceManager,
-                                const nsSize& aMaxSize,
-                                nsRect& aDesiredRect,
-                                nsReflowCommand& aReflowCommand)
+NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
+                                          nsISpaceManager* aSpaceManager,
+                                          const nsSize& aMaxSize,
+                                          nsRect& aDesiredRect,
+                                          nsReflowCommand& aReflowCommand,
+                                          ReflowStatus& aStatus)
 {
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
 
   if (aReflowCommand.GetTarget() == this) {
     // XXX for now, just do a complete reflow mapped (it'll kinda
@@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
     SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
     PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   } else {
     // XXX not yet implemented
@@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
   }
 
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
 {
   do {
-    nsIFrame* parent = aFrame->GetGeometricParent();
+    nsIFrame* parent;
+     
+    aFrame->GetGeometricParent(parent);
   
     // See if there are any non-zero sized child frames that precede aFrame
     // in the child list
-    nsIFrame* child = parent->FirstChild();
-  
+    nsIFrame* child;
+     
+    parent->FirstChild(child);
     while ((nsnull != child) && (aFrame != child)) {
+      nsSize  size;
+
       // Is the child zero-sized?
-      if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
+      child->GetSize(size);
+      if ((size.width > 0) || (size.height > 0)) {
         // We found a non-zero sized child frame that precedes aFrame
         return PR_FALSE;
       }
   
-      child = child->GetNextSibling();
+      child->GetNextSibling(child);
     }
   
     // aFrame is the left-most non-zero sized frame in its geometric parent.
@@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   // todo list and we'll handle it when we flush out the line
   if (IsLeftMostChild(aPlaceholder)) {
     // Get the type of floater
-    nsIStyleContext*  styleContext = aFloater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+
+    aFloater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
 
@@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   }
 }
 
-void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
-                                   nsIPresContext* aPresContext,
-                                   nsIContent* aContainer)
+NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
+                                        nsIPresContext* aPresContext,
+                                        nsIContent* aContainer)
 {
-  // Zip down to the end-of-flow
-  nsBlockFrame* flow = this;
-  for (;;) {
-    nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
-    if (nsnull == next) {
-      break;
-    }
-    flow = next;
-  }
+  // Get the last-in-flow
+  nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
 
   PRInt32 kidIndex = flow->NextChildOffset();
   PRInt32 startIndex = kidIndex;
-  nsIFrame* prevKidFrame = flow->LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  flow->LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
           NS_RELEASE(kidSC);
           NS_RELEASE(kid);
   
-          return;
+          return NS_OK;
         }
         // FALL THROUGH (and create frame)
   
@@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
 
     // Link child frame into the list of children
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
                           startIndex);
     aShell->AppendReflowCommand(rc);
   }
+  return NS_OK;
 }
 
 PRIntn nsBlockFrame::GetSkipSides() const
@@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
   return eHTMLFrame_Block;
 }
 
-void nsBlockFrame::ListTag(FILE* out) const
+NS_METHOD nsBlockFrame::ListTag(FILE* out) const
 {
   if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
     fprintf(out, "*block(%d)@%p", mIndexInParent, this);
   } else {
     nsHTMLContainerFrame::ListTag(out);
   }
+  return NS_OK;
 }
 
 #ifdef NS_DEBUG
diff --git a/mozilla/layout/generic/nsHTMLContainerFrame.cpp b/mozilla/layout/generic/nsHTMLContainerFrame.cpp
index 960b6c0396d..c5026c6058a 100644
--- a/mozilla/layout/generic/nsHTMLContainerFrame.cpp
+++ b/mozilla/layout/generic/nsHTMLContainerFrame.cpp
@@ -44,10 +44,9 @@ nsHTMLContainerFrame::~nsHTMLContainerFrame()
 {
 }
 
-void
-nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
-                            nsIRenderingContext& aRenderingContext,
-                            const nsRect& aDirtyRect)
+NS_METHOD nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
+                                      nsIRenderingContext& aRenderingContext,
+                                      const nsRect& aDirtyRect)
 {
   // Do not paint ourselves if we are a pseudo-frame
   if (PR_FALSE == IsPseudoFrame()) {
@@ -68,6 +67,7 @@ nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
     aRenderingContext.SetColor(NS_RGB(255,0,0));
     aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
   }
+  return NS_OK;
 }
 
 void nsHTMLContainerFrame::TriggerLink(nsIPresContext& aPresContext,
@@ -96,14 +96,15 @@ void nsHTMLContainerFrame::TriggerLink(nsIPresContext& aPresContext,
   }
 }
 
-nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
-                                                nsGUIEvent* aEvent)
+NS_METHOD nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
+                                            nsGUIEvent* aEvent,
+                                            nsEventStatus& aEventStatus)
 {
-  nsEventStatus rv = nsEventStatus_eIgnore; 
+  aEventStatus = nsEventStatus_eIgnore; 
   switch (aEvent->message) {
   case NS_MOUSE_LEFT_BUTTON_UP:
     if (nsEventStatus_eIgnore ==
-        nsContainerFrame::HandleEvent(aPresContext, aEvent)) { 
+        nsContainerFrame::HandleEvent(aPresContext, aEvent, aEventStatus)) { 
       // If our child didn't take the click then since we are an
       // anchor, we take the click.
       nsIAtom* tag = mContent->GetTag();
@@ -112,7 +113,7 @@ nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
         mContent->GetAttribute("href", href);
         mContent->GetAttribute("target", target);
         TriggerLink(aPresContext, base, href, target);
-        rv = nsEventStatus_eConsumeNoDefault; 
+        aEventStatus = nsEventStatus_eConsumeNoDefault; 
       }
       NS_IF_RELEASE(tag);
     }
@@ -123,15 +124,16 @@ nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
     break;
 
   default:
-    rv = nsContainerFrame::HandleEvent(aPresContext, aEvent);
+    nsContainerFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
     break;
   }
-  return rv;
+  return NS_OK;
 }
 
-PRInt32 nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
-                                          const nsPoint& aPoint,
-                                          nsIFrame** aFrame)
+NS_METHOD nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
+                                            const nsPoint& aPoint,
+                                            nsIFrame** aFrame,
+                                            PRInt32& aCursor)
 {
   nsStyleMolecule* mol = (nsStyleMolecule*)
     mStyleContext->GetData(kStyleMoleculeSID);
@@ -139,9 +141,10 @@ PRInt32 nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
     // If this container has a particular cursor, use it, otherwise
     // let the child decide.
     *aFrame = this;
-    return (PRInt32) mol->cursor;
+    aCursor = (PRInt32)mol->cursor;
+    return NS_OK;
   }
-  return nsContainerFrame::GetCursorAt(aPresContext, aPoint, aFrame);
+  return nsContainerFrame::GetCursorAt(aPresContext, aPoint, aFrame, aCursor);
 }
 
 #if 0
diff --git a/mozilla/layout/generic/nsHTMLContainerFrame.h b/mozilla/layout/generic/nsHTMLContainerFrame.h
index 974db84442d..e8e6709fcdb 100644
--- a/mozilla/layout/generic/nsHTMLContainerFrame.h
+++ b/mozilla/layout/generic/nsHTMLContainerFrame.h
@@ -30,16 +30,18 @@ public:
                        PRInt32 aIndexInParent,
                        nsIFrame* aParent);
 
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD  Paint(nsIPresContext& aPresContext,
+                    nsIRenderingContext& aRenderingContext,
+                    const nsRect& aDirtyRect);
 
-  virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
-                                    nsGUIEvent* aEvent);
+  NS_IMETHOD  HandleEvent(nsIPresContext& aPresContext,
+                          nsGUIEvent* aEvent,
+                          nsEventStatus& aEventStatus);
 
-  virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
-                              const nsPoint& aPoint,
-                              nsIFrame** aFrame);
+  NS_IMETHOD  GetCursorAt(nsIPresContext& aPresContext,
+                          const nsPoint& aPoint,
+                          nsIFrame** aFrame,
+                          PRInt32& aCursor);
 
 #if 0
   virtual ReflowStatus IncrementalReflow(nsIPresContext*  aPresContext,
diff --git a/mozilla/layout/generic/nsIFrame.h b/mozilla/layout/generic/nsIFrame.h
index 25db0e7323b..a3a81a50bb5 100644
--- a/mozilla/layout/generic/nsIFrame.h
+++ b/mozilla/layout/generic/nsIFrame.h
@@ -34,12 +34,10 @@ class nsIView;
 class nsIWidget;
 class nsReflowCommand;
 
-struct nsStyleStruct;
-struct nsGUIEvent;
-
 struct nsPoint;
 struct nsRect;
 struct nsReflowMetrics;
+struct nsStyleStruct;
 
 // IID for the nsIFrame interface {12B193D0-9F70-11d1-8500-00A02468FAB6}
 #define NS_IFRAME_IID         \
@@ -81,13 +79,13 @@ public:
    * QueryInterface() defined in nsISupports. This is the only member
    * function of nsISupports that is public.
    */
-  NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
+  NS_IMETHOD  QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
 
   /**
    * Deletes this frame and each of its child frames (recursively calls
    * DeleteFrame() for each child)
    */
-  virtual void DeleteFrame() = 0;
+  NS_IMETHOD  DeleteFrame() = 0;
 
   /**
    * Get the content object associated with this frame. Adds a reference to
@@ -95,66 +93,73 @@ public:
    *
    * @see nsISupports#Release()
    */
-  virtual nsIContent*   GetContent() const = 0;
+  NS_IMETHOD  GetContent(nsIContent*& aContent) const = 0;
 
   /**
    * Get/Set the frame's index in parent.
    */
-  virtual PRInt32       GetIndexInParent() const = 0;
-  virtual void          SetIndexInParent(PRInt32 aIndexInParent) = 0;
+  NS_IMETHOD  GetIndexInParent(PRInt32& aIndexInParent) const = 0;
+  NS_IMETHOD  SetIndexInParent(PRInt32 aIndexInParent) = 0;
 
   /**
    * Get the style context associated with this frame. Note that GetStyleContext()
    * adds a reference to the style context so the caller must do a release.
    *
-   * @see #nsISupports#Release()
+   * @see nsISupports#Release()
    */
-  virtual nsIStyleContext* GetStyleContext(nsIPresContext* aContext) = 0;
-  virtual void             SetStyleContext(nsIStyleContext* aContext) = 0;
-
+  NS_IMETHOD  GetStyleContext(nsIPresContext*   aContext,
+                              nsIStyleContext*& aStyleContext) = 0;
+  NS_IMETHOD  SetStyleContext(nsIStyleContext* aContext) = 0;
 
   /**
-   *
    * Get the style data associated with this frame
-   *
-   *
    */
-  virtual nsStyleStruct* GetStyleData(const nsIID& aSID) = 0;
+  NS_IMETHOD  GetStyleData(const nsIID& aSID, nsStyleStruct*& aStyleStruct) = 0;
 
   /**
    * Accessor functions for geometric and content parent.
    */
-  virtual nsIFrame*     GetContentParent() const = 0;
-  virtual void          SetContentParent(const nsIFrame* aParent) = 0;
-  virtual nsIFrame*     GetGeometricParent() const = 0;
-  virtual void          SetGeometricParent(const nsIFrame* aParent) = 0;
+  NS_IMETHOD  GetContentParent(nsIFrame*& aParent) const = 0;
+  NS_IMETHOD  SetContentParent(const nsIFrame* aParent) = 0;
+  NS_IMETHOD  GetGeometricParent(nsIFrame*& aParent) const = 0;
+  NS_IMETHOD  SetGeometricParent(const nsIFrame* aParent) = 0;
 
   /**
    * Bounding rect of the frame. The values are in twips, and the origin is
    * relative to the upper-left of the geometric parent. The size includes the
    * content area, borders, and padding.
    */
-  virtual nsRect        GetRect() const = 0;
-  virtual void          GetRect(nsRect& aRect) const = 0;
-  virtual void          GetOrigin(nsPoint& aPoint) const = 0;
-  virtual nscoord       GetWidth() const = 0;
-  virtual nscoord       GetHeight() const = 0;
-  virtual void          SetRect(const nsRect& aRect) = 0;
-  virtual void          MoveTo(nscoord aX, nscoord aY) = 0;
-  virtual void          SizeTo(nscoord aWidth, nscoord aHeight) = 0;
+  NS_IMETHOD  GetRect(nsRect& aRect) const = 0;
+  NS_IMETHOD  GetOrigin(nsPoint& aPoint) const = 0;
+  NS_IMETHOD  GetSize(nsSize& aSize) const = 0;
+  NS_IMETHOD  SetRect(const nsRect& aRect) = 0;
+  NS_IMETHOD  MoveTo(nscoord aX, nscoord aY) = 0;
+  NS_IMETHOD  SizeTo(nscoord aWidth, nscoord aHeight) = 0;
+
+  /**
+   * Child frame enumeration
+   */
+  NS_IMETHOD  ChildCount(PRInt32& aChildCount) const = 0;
+  NS_IMETHOD  ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const = 0;
+  NS_IMETHOD  IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const = 0;
+  NS_IMETHOD  FirstChild(nsIFrame*& aFirstChild) const = 0;
+  NS_IMETHOD  NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const = 0;
+  NS_IMETHOD  PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const = 0;
+  NS_IMETHOD  LastChild(nsIFrame*& aLastChild) const = 0;
 
   /**
    * Painting
    */
-  virtual void          Paint(nsIPresContext&      aPresContext,
-                              nsIRenderingContext& aRenderingContext,
-                              const nsRect&        aDirtyRect) = 0;
+  NS_IMETHOD  Paint(nsIPresContext&      aPresContext,
+                    nsIRenderingContext& aRenderingContext,
+                    const nsRect&        aDirtyRect) = 0;
 
   /**
    * Handle an event. 
    */
-  virtual nsEventStatus   HandleEvent(nsIPresContext& aPresContext,
-                                      nsGUIEvent*     aEvent) = 0;
+  NS_IMETHOD  HandleEvent(nsIPresContext& aPresContext,
+                          nsGUIEvent*     aEvent,
+                          nsEventStatus&  aEventStatus) = 0;
 
   /**
    * Get the cursor for a given point in the frame tree. The
@@ -162,20 +167,10 @@ public:
    * no cursor is wanted). In addition, if a cursor is desired
    * then *aFrame is set to the frame that wants the cursor.
    */
-  virtual PRInt32       GetCursorAt(nsIPresContext& aPresContext,
-                                    const nsPoint& aPoint,
-                                    nsIFrame** aFrame) = 0;
-
-  /**
-   * Child frame enumeration
-   */
-  virtual PRInt32       ChildCount() const = 0;
-  virtual nsIFrame*     ChildAt(PRInt32 aIndex) const = 0;
-  virtual PRInt32       IndexOf(const nsIFrame* aChild) const = 0;
-  virtual nsIFrame*     FirstChild() const = 0;
-  virtual nsIFrame*     NextChild(const nsIFrame* aChild) const = 0;
-  virtual nsIFrame*     PrevChild(const nsIFrame* aChild) const = 0;
-  virtual nsIFrame*     LastChild() const = 0;
+  NS_IMETHOD  GetCursorAt(nsIPresContext& aPresContext,
+                          const nsPoint&  aPoint,
+                          nsIFrame**      aFrame,
+                          PRInt32&        aCursor) = 0;
 
   /**
    * Reflow status returned by the reflow methods
@@ -206,10 +201,11 @@ public:
    *          a maximum element size. The maximum element size must be less than or
    *          equal to your desired size.
    */
-  virtual ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                                     nsReflowMetrics& aDesiredSize,
-                                     const nsSize&    aMaxSize,
-                                     nsSize*          aMaxElementSize) = 0;
+  NS_IMETHOD  ResizeReflow(nsIPresContext*  aPresContext,
+                           nsReflowMetrics& aDesiredSize,
+                           const nsSize&    aMaxSize,
+                           nsSize*          aMaxElementSize,
+                           ReflowStatus&    aStatus) = 0;
 
   /**
    * Post-processing reflow method invoked when justification is enabled.
@@ -218,8 +214,8 @@ public:
    * @param aAvailableSpace The amount of available space that the frame
    *         should distribute internally.
    */
-  virtual void          JustifyReflow(nsIPresContext*  aPresContext,
-                                      nscoord          aAvailableSpace) = 0;
+  NS_IMETHOD  JustifyReflow(nsIPresContext* aPresContext,
+                            nscoord         aAvailableSpace) = 0;
 
   /**
    * Incremental reflow. The reflow command contains information about the
@@ -243,10 +239,11 @@ public:
    * @see nsReflowCommand#GetTarget()
    * @see nsReflowCommand#GetType()
    */
-  virtual ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                          nsReflowMetrics& aDesiredSize,
-                                          const nsSize&    aMaxSize,
-                                          nsReflowCommand& aReflowCommand) = 0;
+  NS_IMETHOD  IncrementalReflow(nsIPresContext*  aPresContext,
+                                nsReflowMetrics& aDesiredSize,
+                                const nsSize&    aMaxSize,
+                                nsReflowCommand& aReflowCommand,
+                                ReflowStatus&    aStatus) = 0;
 
   /**
    * This call is invoked when content is appended to the content
@@ -256,9 +253,9 @@ public:
    * the call must generate reflow commands that will incrementally
    * reflow and repair the damaged portion of the frame tree.
    */
-  virtual void ContentAppended(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer) = 0;
+  NS_IMETHOD  ContentAppended(nsIPresShell*   aShell,
+                              nsIPresContext* aPresContext,
+                              nsIContent*     aContainer) = 0;
 
   /**
    * This call is invoked when content is inserted in the content
@@ -271,11 +268,11 @@ public:
    * @param aIndexInParent the index in the content container where
    *          the new content was inserted.
    */
-  virtual void ContentInserted(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer,
-                               nsIContent* aChild,
-                               PRInt32 aIndexInParent) = 0;
+  NS_IMETHOD  ContentInserted(nsIPresShell*   aShell,
+                              nsIPresContext* aPresContext,
+                              nsIContent*     aContainer,
+                              nsIContent*     aChild,
+                              PRInt32         aIndexInParent) = 0;
 
   /**
    * This call is invoked when content is replaced in the content
@@ -288,12 +285,12 @@ public:
    *
    * @param aIndexInParent the index in the content container where
    *          the new content was inserted.  */
-  virtual void ContentReplaced(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer,
-                               nsIContent* aOldChild,
-                               nsIContent* aNewChild,
-                               PRInt32 aIndexInParent) = 0;
+  NS_IMETHOD  ContentReplaced(nsIPresShell*   aShell,
+                              nsIPresContext* aPresContext,
+                              nsIContent*     aContainer,
+                              nsIContent*     aOldChild,
+                              nsIContent*     aNewChild,
+                              PRInt32         aIndexInParent) = 0;
 
   /**
    * This call is invoked when content is deleted from the content
@@ -306,11 +303,11 @@ public:
    * @param aIndexInParent the index in the content container where
    *          the new content was deleted.
    */
-  virtual void ContentDeleted(nsIPresShell* aShell,
-                              nsIPresContext* aPresContext,
-                              nsIContent* aContainer,
-                              nsIContent* aChild,
-                              PRInt32 aIndexInParent) = 0;
+  NS_IMETHOD  ContentDeleted(nsIPresShell*   aShell,
+                             nsIPresContext* aPresContext,
+                             nsIContent*     aContainer,
+                             nsIContent*     aChild,
+                             PRInt32         aIndexInParent) = 0;
 
   /**
    * Return the reflow metrics for this frame. If the frame is a
@@ -320,43 +317,45 @@ public:
    * ascent of the line's children). Note that the metrics returned
    * apply to the frame as it exists at the time of the call.
    */
-  virtual void          GetReflowMetrics(nsIPresContext*  aPresContext,
-                                         nsReflowMetrics& aMetrics) = 0;
+  NS_IMETHOD  GetReflowMetrics(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aMetrics) = 0;
 
   /**
    * Flow member functions. CreateContinuingFrame() is responsible for appending
    * the continuing frame to the flow.
    */
-  virtual PRBool        IsSplittable() const = 0;
-  virtual nsIFrame*     CreateContinuingFrame(nsIPresContext* aPresContext,
-                                              nsIFrame*       aParent) = 0;
-  virtual nsIFrame*     GetPrevInFlow() const = 0;
-  virtual void          SetPrevInFlow(nsIFrame*) = 0;
-  virtual nsIFrame*     GetNextInFlow() const = 0;
-  virtual void          SetNextInFlow(nsIFrame*) = 0;
+  NS_IMETHOD  IsSplittable(PRBool& aIsSplittable) const = 0;
+  NS_IMETHOD  CreateContinuingFrame(nsIPresContext* aPresContext,
+                                    nsIFrame*       aParent,
+                                    nsIFrame*&      aContinuingFrame) = 0;
 
-  virtual void          AppendToFlow(nsIFrame* aAfterFrame) = 0;
-  virtual void          PrependToFlow(nsIFrame* aBeforeFrame) = 0;
-  virtual void          RemoveFromFlow() = 0;
-  virtual void          BreakFromPrevFlow() = 0;
-  virtual void          BreakFromNextFlow() = 0;
+  NS_IMETHOD  GetPrevInFlow(nsIFrame*& aPrevInFlow) const = 0;
+  NS_IMETHOD  SetPrevInFlow(nsIFrame*) = 0;
+  NS_IMETHOD  GetNextInFlow(nsIFrame*& aNextInFlow) const = 0;
+  NS_IMETHOD  SetNextInFlow(nsIFrame*) = 0;
+
+  NS_IMETHOD  AppendToFlow(nsIFrame* aAfterFrame) = 0;
+  NS_IMETHOD  PrependToFlow(nsIFrame* aBeforeFrame) = 0;
+  NS_IMETHOD  RemoveFromFlow() = 0;
+  NS_IMETHOD  BreakFromPrevFlow() = 0;
+  NS_IMETHOD  BreakFromNextFlow() = 0;
 
   /**
    * Accessor functions to get/set the associated view object
    */
-  virtual nsIView*      GetView() const = 0;  // may be null
-  virtual void          SetView(nsIView* aView) = 0;
+  NS_IMETHOD  GetView(nsIView*& aView) const = 0;  // may be null
+  NS_IMETHOD  SetView(nsIView* aView) = 0;
 
   /**
    * Find the first geometric parent that has a view
    */
-  virtual nsIFrame*     GetParentWithView() const = 0;
+  NS_IMETHOD  GetParentWithView(nsIFrame*& aParent) const = 0;
 
   /**
    * Returns the offset from this frame to the closest geometric parent that
    * has a view. Also returns the containing view or null in case of error
    */
-  virtual nsIView*      GetOffsetFromView(nsPoint& aOffset) const = 0;
+  NS_IMETHOD  GetOffsetFromView(nsPoint& aOffset, nsIView*& aView) const = 0;
 
   /**
    * Returns the window that contains this frame. If this frame has a
@@ -364,18 +363,18 @@ public:
    * returned, otherwise this frame's geometric parent is checked
    * recursively upwards.
    */
-  virtual nsIWidget*    GetWindow() const = 0;
+  NS_IMETHOD  GetWindow(nsIWidget*&) const = 0;
 
   /**
    * Sibling pointer used to link together frames
    */
-  virtual nsIFrame*     GetNextSibling() const = 0;
-  virtual void          SetNextSibling(nsIFrame* aNextSibling) = 0;
+  NS_IMETHOD  GetNextSibling(nsIFrame*& aNextSibling) const = 0;
+  NS_IMETHOD  SetNextSibling(nsIFrame* aNextSibling) = 0;
 
   // Debugging
-  virtual void          List(FILE* out = stdout, PRInt32 aIndent = 0) const= 0;
-  virtual void          ListTag(FILE* out = stdout) const = 0;
-  virtual void          VerifyTree() const = 0;
+  NS_IMETHOD  List(FILE* out = stdout, PRInt32 aIndent = 0) const= 0;
+  NS_IMETHOD  ListTag(FILE* out = stdout) const = 0;
+  NS_IMETHOD  VerifyTree() const = 0;
 
   // Show frame borders when rendering
   static NS_LAYOUT void ShowFrameBorders(PRBool aEnable);
diff --git a/mozilla/layout/generic/nsInlineFrame.cpp b/mozilla/layout/generic/nsInlineFrame.cpp
index c795cf6122e..d623ffb10d6 100644
--- a/mozilla/layout/generic/nsInlineFrame.cpp
+++ b/mozilla/layout/generic/nsInlineFrame.cpp
@@ -241,17 +241,22 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No, the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       PRBool lastContentIsComplete = mLastContentIsComplete;
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         if (nsnull == nextSib) {
@@ -264,7 +269,9 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
 
       // We've used up all of our available space so push the remaining
       // children to the next-in-flow
-      nsIFrame* nextSibling = kidFrame->GetNextSibling();
+      nsIFrame* nextSibling;
+       
+      kidFrame->GetNextSibling(nextSibling);
       if (nsnull != nextSibling) {
         PushChildren(nextSibling, kidFrame, lastContentIsComplete);
         SetLastContentOffset(prevKidFrame);
@@ -274,16 +281,22 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
     }
 
     // Get the next child frame
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
 
     // XXX talk with troy about checking for available space here
   }
 
   // Update the child count member data
   mChildCount = childCount;
-  NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
 #ifdef NS_DEBUG
+  NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
+
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
   VerifyLastIsComplete();
 #endif
   return result;
@@ -309,7 +322,9 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
 #ifdef NS_DEBUG
   PRInt32        kidIndex = NextChildOffset();
 #endif
-  nsIFrame*      prevKidFrame = LastChild();
+  nsIFrame*      prevKidFrame;
+   
+  LastChild(prevKidFrame);
 
   // This will hold the prevKidFrame's mLastContentIsComplete
   // status. If we have to push the frame that follows prevKidFrame
@@ -338,7 +353,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
         kidFrame = nextInFlow->mFirstChild;
       } else {
         // We've pulled up all the children, so move to the next-in-flow.
-        nextInFlow = (nsInlineFrame*)nextInFlow->GetNextInFlow();
+        nsIFrame* next;
+
+        nextInFlow->GetNextInFlow(next);
+        nextInFlow = (nsInlineFrame*)next;
         continue;
       }
     }
@@ -346,8 +364,12 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
     // See if the child fits in the available space. If it fits or
     // it's splittable then reflow it. The reason we can't just move
     // it is that we still need ascent/descent information
-    if ((kidFrame->GetWidth() > aState.availSize.width) &&
-        !kidFrame->IsSplittable()) {
+    nsSize  kidFrameSize;
+    PRBool  kidIsSplittable;
+
+    kidFrame->GetSize(kidFrameSize);
+    kidFrame->IsSplittable(kidIsSplittable);
+    if ((kidFrameSize.width > aState.availSize.width) && !kidIsSplittable) {
       result = PR_FALSE;
       mLastContentIsComplete = prevLastContentIsComplete;
       break;
@@ -369,7 +391,7 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
     PlaceChild(kidFrame, mChildCount, aState, kidSize, pKidMaxElementSize);
 
     // Remove the frame from its current parent
-    nextInFlow->mFirstChild = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(nextInFlow->mFirstChild);
     nextInFlow->mChildCount--;
     // Update the next-in-flows first content offset
     if (nsnull != nextInFlow->mFirstChild) {
@@ -378,7 +400,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
 
     // Link the frame into our list of children
     kidFrame->SetGeometricParent(this);
-    if (nextInFlow == kidFrame->GetContentParent()) {
+    nsIFrame* kidContentParent;
+
+    kidFrame->GetContentParent(kidContentParent);
+    if (nextInFlow == kidContentParent) {
       kidFrame->SetContentParent(this);
     }
     if (nsnull == prevKidFrame) {
@@ -398,13 +423,16 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a
         // continuing frame. The creation appends it to the flow and
         // prepares it for reflow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to our sibling list and then push
@@ -432,7 +460,7 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
 
   // Update our last content offset
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -452,7 +480,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
       // the next-in-flows must be empty. Do a sanity check
       while (nsnull != nextInFlow) {
         NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
-        nextInFlow = (nsInlineFrame*)nextInFlow->GetNextInFlow();
+        nsIFrame* next;
+
+        nextInFlow->GetNextInFlow(next);
+        nextInFlow = (nsInlineFrame*)next;
       }
 #endif
     }
@@ -492,7 +523,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
     mFirstContentOffset = prev->NextChildOffset();
     if (!prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
   mLastContentIsComplete = PR_TRUE;
@@ -501,8 +532,9 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
   nsSize    kidMaxElementSize;
   nsSize*   pKidMaxElementSize = (nsnull != aState.maxElementSize) ? &kidMaxElementSize : nsnull;
   PRInt32   kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
 
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -558,7 +590,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
       }
       kidFrame->SetStyleContext(kidStyleContext);
     } else {
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
+      kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
     }
     NS_RELEASE(kid);
     NS_RELEASE(kidStyleContext);
@@ -606,7 +638,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
 
 done:;
   // Update the content mapping
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 #ifdef NS_DEBUG
   PRInt32 len = LengthOf(mFirstChild);
@@ -618,11 +650,11 @@ done:;
   return result;
 }
 
-nsIFrame::ReflowStatus
-nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                            nsReflowMetrics& aDesiredSize,
-                            const nsSize&    aMaxSize,
-                            nsSize*          aMaxElementSize)
+NS_METHOD nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                      nsReflowMetrics& aDesiredSize,
+                                      const nsSize&    aMaxSize,
+                                      nsSize*          aMaxElementSize,
+                                      ReflowStatus&    aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
@@ -630,7 +662,8 @@ nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
 //XXX not now  NS_PRECONDITION((aMaxSize.width > 0) && (aMaxSize.height > 0), "unexpected max size");
 
   PRBool        reflowMappedOK = PR_TRUE;
-  ReflowStatus  status = frComplete;
+
+  aStatus = frComplete;  // initialize out parameter
 
   // Get the style molecule
   nsStyleFont* styleFont =
@@ -651,7 +684,7 @@ nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
     reflowMappedOK = ReflowMappedChildren(aPresContext, state);
 
     if (PR_FALSE == reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -661,18 +694,18 @@ nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
     if (state.availSize.width <= 0) {
       // No space left. Don't try to pull-up children or reflow unmapped
       if (NextChildOffset() < mContent->ChildCount()) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (NextChildOffset() < mContent->ChildCount()) {
       // Try and pull-up some children from a next-in-flow
       if (PullUpChildren(aPresContext, state)) {
         // If we still have unmapped children then create some new frames
         if (NextChildOffset() < mContent->ChildCount()) {
-          status = ReflowUnmappedChildren(aPresContext, state);
+          aStatus = ReflowUnmappedChildren(aPresContext, state);
         }
       } else {
         // We were unable to pull-up all the existing frames from the next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
@@ -694,9 +727,9 @@ nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
   aDesiredSize.height = aDesiredSize.ascent + aDesiredSize.descent;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
-  return status;
+  return NS_OK;
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -717,8 +750,8 @@ PRIntn nsInlineFrame::GetSkipSides() const
 
 // Incremental reflow support
 
-void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
-                                     nsReflowMetrics& aMetrics)
+NS_METHOD nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
+                                          nsReflowMetrics& aMetrics)
 {
   nscoord maxAscent = 0;
   nscoord maxDescent = 0;
@@ -728,7 +761,7 @@ void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
     kid->GetReflowMetrics(aPresContext, kidMetrics);
     if (kidMetrics.ascent > maxAscent) maxAscent = kidMetrics.ascent;
     if (kidMetrics.descent > maxDescent) maxDescent = kidMetrics.descent;
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 
   // XXX what about border & padding
@@ -736,6 +769,8 @@ void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
   aMetrics.height = mRect.height;
   aMetrics.ascent = maxAscent;
   aMetrics.descent = maxDescent;
+
+  return NS_OK;
 }
 
 /**
@@ -765,7 +800,7 @@ PRIntn nsInlineFrame::RecoverState(nsIPresContext* aPresContext,
     // XXX Factor in left and right margins
     x += kidMetrics.width;
 
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
     i++;
   }
   aState.maxAscent = maxAscent;
@@ -774,13 +809,13 @@ PRIntn nsInlineFrame::RecoverState(nsIPresContext* aPresContext,
   return (nsnull == aSkipChild) ? 0 : i;
 }
 
-nsIFrame::ReflowStatus
-nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                                 nsReflowMetrics& aDesiredSize,
-                                 const nsSize&    aMaxSize,
-                                 nsReflowCommand& aReflowCommand)
+NS_METHOD nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                           nsReflowMetrics& aDesiredSize,
+                                           const nsSize&    aMaxSize,
+                                           nsReflowCommand& aReflowCommand,
+                                           ReflowStatus&    aStatus)
 {
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;  // initialize out parameter
 
 #if 0
   if (aReflowCommand.GetTarget() == this) {
@@ -794,7 +829,7 @@ nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
       while (nsnull != flow->mNextInFlow) {
         flow = flow->mNextInFlow;
       }
-      status = flow->ReflowUnmappedChildren(...);
+      aStatus = flow->ReflowUnmappedChildren(...);
       break;
 
     case nsReflowCommand::rcContentInserted:
@@ -875,7 +910,7 @@ nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
 
     // Now pass reflow command down to our child to handle
     nsReflowMetrics kidMetrics;
-    status = aReflowCommand.Next(kidMetrics, aMaxSize, kid);
+    aStatus = aReflowCommand.Next(kidMetrics, aMaxSize, kid);
     // XXX what do we do when the nextInChain's completion status changes?
     // XXX if kid == LastChild() then mLastContentIsComplete needs updating
 
@@ -909,13 +944,13 @@ nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
       // Update other children that are impacted by the change in
       // nextInChain. In addition, re-apply vertical alignment and
       // relative positioning to the children on the line.
-      status = AdjustChildren(aPresContext, aDesiredSize, aState, kid,
-                              kidMetrics, status);
+      aStatus = AdjustChildren(aPresContext, aDesiredSize, aState, kid,
+                               kidMetrics, aStatus);
     }
   }
 #endif
 
-  return status;
+  return NS_OK;
 }
 
 
@@ -961,7 +996,7 @@ nsInlineFrame::AdjustChildren(nsIPresContext* aPresContext,
     }
     x += r.width;
     // XXX factor in left and right margins
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 
   // Vertically align the children
@@ -981,25 +1016,19 @@ nsInlineFrame::AdjustChildren(nsIPresContext* aPresContext,
 // My container has new content at the end of it. Create frames for
 // the appended content and then generate an incremental reflow
 // command for ourselves.
-void nsInlineFrame::ContentAppended(nsIPresShell* aShell,
-                                    nsIPresContext* aPresContext,
-                                    nsIContent* aContainer)
+NS_METHOD nsInlineFrame::ContentAppended(nsIPresShell* aShell,
+                                         nsIPresContext* aPresContext,
+                                         nsIContent* aContainer)
 {
-  // Zip down to the end-of-flow
-  nsInlineFrame* flow = this;
-  for (;;) {
-    nsInlineFrame* next = (nsInlineFrame*) flow->GetNextInFlow();
-    if (nsnull == next) {
-      break;
-    }
-    flow = next;
-  }
+  // Get the last in flow
+  nsInlineFrame* flow = (nsInlineFrame*)GetLastInFlow();
 
   // Get index of where the content has been appended
   PRInt32 kidIndex = flow->NextChildOffset();
   PRInt32 startIndex = kidIndex;
-  nsIFrame* prevKidFrame = flow->LastChild();
+  nsIFrame* prevKidFrame;
 
+  flow->LastChild(prevKidFrame);
   // Create frames for each new child
   for (;;) {
     // Get the next content object
@@ -1027,4 +1056,5 @@ void nsInlineFrame::ContentAppended(nsIPresShell* aShell,
                           startIndex);
     aShell->AppendReflowCommand(rc);
   }
+  return NS_OK;
 }
diff --git a/mozilla/layout/generic/nsLeafFrame.cpp b/mozilla/layout/generic/nsLeafFrame.cpp
index 052f6bd8ea2..da502bfbe0c 100644
--- a/mozilla/layout/generic/nsLeafFrame.cpp
+++ b/mozilla/layout/generic/nsLeafFrame.cpp
@@ -33,9 +33,9 @@ nsLeafFrame::~nsLeafFrame()
 {
 }
 
-void nsLeafFrame::Paint(nsIPresContext& aPresContext,
-                        nsIRenderingContext& aRenderingContext,
-                        const nsRect& aDirtyRect)
+NS_METHOD nsLeafFrame::Paint(nsIPresContext& aPresContext,
+                             nsIRenderingContext& aRenderingContext,
+                             const nsRect& aDirtyRect)
 {
   nsStyleColor* myColor =
     (nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
@@ -45,13 +45,14 @@ void nsLeafFrame::Paint(nsIPresContext& aPresContext,
                                   aDirtyRect, mRect, *myColor);
   nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
                               aDirtyRect, mRect, *myMol, 0);
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
-                          nsReflowMetrics& aDesiredSize,
-                          const nsSize& aMaxSize,
-                          nsSize* aMaxElementSize)
+NS_METHOD nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                    nsReflowMetrics& aDesiredSize,
+                                    const nsSize& aMaxSize,
+                                    nsSize* aMaxElementSize,
+                                    ReflowStatus& aStatus)
 {
   // XXX add in code to check for width/height being set via css
   // and if set use them instead of calling GetDesiredSize.
@@ -62,14 +63,15 @@ nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
     aMaxElementSize->width = aDesiredSize.width;
     aMaxElementSize->height = aDesiredSize.height;
   }
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize& aMaxSize,
-                               nsReflowCommand& aReflowCommand)
+NS_METHOD nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
+                                         nsReflowMetrics& aDesiredSize,
+                                         const nsSize& aMaxSize,
+                                         nsReflowCommand& aReflowCommand,
+                                         ReflowStatus& aStatus)
 {
   // XXX Unless the reflow command is a style change, we should
   // just return the current size, otherwise we should invoke
@@ -80,7 +82,8 @@ nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
   GetDesiredSize(aPresContext, aDesiredSize, aMaxSize);
   AddBordersAndPadding(aPresContext, aDesiredSize);
 
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
 // XXX how should border&padding effect baseline alignment?
@@ -109,9 +112,11 @@ void nsLeafFrame::GetInnerArea(nsIPresContext* aPresContext,
     (mol->borderPadding.top + mol->borderPadding.bottom);
 }
 
-nsIFrame* nsLeafFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                             nsIFrame*       aParent)
+NS_METHOD nsLeafFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                             nsIFrame*       aParent,
+                                             nsIFrame*&      aContinuingFrame)
 {
   NS_NOTREACHED("Attempt to split the unsplittable");
-  return nsnull;
+  aContinuingFrame = nsnull;
+  return NS_OK;
 }
diff --git a/mozilla/layout/generic/nsLeafFrame.h b/mozilla/layout/generic/nsLeafFrame.h
index 6798e154a77..e979cc2aa06 100644
--- a/mozilla/layout/generic/nsLeafFrame.h
+++ b/mozilla/layout/generic/nsLeafFrame.h
@@ -28,22 +28,25 @@
  */
 class nsLeafFrame : public nsFrame {
 public:
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize& aMaxSize,
-                                    nsSize* aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize& aMaxSize,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
-                                         nsReflowMetrics& aDesiredSize,
-                                         const nsSize& aMaxSize,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize& aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus& aStatus);
 
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
 protected:
   nsLeafFrame(nsIContent* aContent,
diff --git a/mozilla/layout/generic/nsPageFrame.cpp b/mozilla/layout/generic/nsPageFrame.cpp
index 858422d7f5c..7da6ddc801b 100644
--- a/mozilla/layout/generic/nsPageFrame.cpp
+++ b/mozilla/layout/generic/nsPageFrame.cpp
@@ -23,8 +23,8 @@
 #include "nsReflowCommand.h"
 #include "nsIRenderingContext.h"
 
-PageFrame::PageFrame(nsIContent* aContent, nsIFrame* aParent)
-  : nsContainerFrame(aContent, aParent->GetIndexInParent(), aParent)
+PageFrame::PageFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent)
+  : nsContainerFrame(aContent, aIndexInParent, aParent)
 {
 }
 
@@ -56,16 +56,16 @@ void PageFrame::CreateFirstChild(nsIPresContext* aPresContext)
   }
 }
 
-nsIFrame::ReflowStatus
-PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                        nsReflowMetrics& aDesiredSize,
-                        const nsSize&    aMaxSize,
-                        nsSize*          aMaxElementSize)
+NS_METHOD PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                  nsReflowMetrics& aDesiredSize,
+                                  const nsSize&    aMaxSize,
+                                  nsSize*          aMaxElementSize,
+                                  ReflowStatus&    aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
 #endif
-  ReflowStatus  result = frComplete;
+  aStatus = frComplete;  // initialize out parameter
 
   // Do we have any children?
   if (nsnull == mFirstChild) {
@@ -76,10 +76,11 @@ PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
       PageFrame*  prevPage = (PageFrame*)mPrevInFlow;
 
       NS_ASSERTION(!prevPage->mLastContentIsComplete, "bad continuing page");
-      nsIFrame* prevLastChild = prevPage->LastChild();
+      nsIFrame* prevLastChild;
+      prevPage->LastChild(prevLastChild);
 
       // Create a continuing child of the previous page's last child
-      mFirstChild = prevLastChild->CreateContinuingFrame(aPresContext, this);
+      prevLastChild->CreateContinuingFrame(aPresContext, this, mFirstChild);
       mChildCount = 1;
       mLastContentOffset = mFirstContentOffset;
     }
@@ -89,9 +90,9 @@ PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
   // XXX Pay attention to the page's border and padding...
   if (nsnull != mFirstChild) {
     // Get the child's desired size
-    result = ReflowChild(mFirstChild, aPresContext, aDesiredSize, aMaxSize,
-                         aMaxElementSize);
-    mLastContentIsComplete = PRBool(result == frComplete);
+    aStatus = ReflowChild(mFirstChild, aPresContext, aDesiredSize, aMaxSize,
+                          aMaxElementSize);
+    mLastContentIsComplete = PRBool(aStatus == frComplete);
 
     // Make sure the child is at least as tall as our max size (the containing window)
     if (aDesiredSize.height < aMaxSize.height) {
@@ -103,8 +104,11 @@ PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
     mFirstChild->SetRect(rect);
 
     // Is the frame complete?
-    if (frComplete == result) {
-      NS_ASSERTION(nsnull == mFirstChild->GetNextInFlow(), "bad child flow list");
+    if (frComplete == aStatus) {
+      nsIFrame* childNextInFlow;
+
+      mFirstChild->GetNextInFlow(childNextInFlow);
+      NS_ASSERTION(nsnull == childNextInFlow, "bad child flow list");
     }
   }
 
@@ -113,28 +117,27 @@ PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
   aDesiredSize.height = aMaxSize.height;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(result);
+  PostReflowCheck(aStatus);
 #endif
-  return result;
+  return NS_OK;
 }
 
 // XXX Do something sensible in page mode...
-nsIFrame::ReflowStatus
-PageFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&    aMaxSize,
-                             nsReflowCommand& aReflowCommand)
+NS_METHOD PageFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                       nsReflowMetrics& aDesiredSize,
+                                       const nsSize&    aMaxSize,
+                                       nsReflowCommand& aReflowCommand,
+                                       ReflowStatus&    aStatus)
 {
   // We don't expect the target of the reflow command to be page frame
   NS_ASSERTION(aReflowCommand.GetTarget() != this, "page frame is reflow command target");
 
   nsSize        maxSize(aMaxSize.width, NS_UNCONSTRAINEDSIZE);
-  ReflowStatus  status;
   nsIFrame*     child;
 
   // Dispatch the reflow command to our pseudo frame. Allow it to be as high
   // as it wants
-  status = aReflowCommand.Next(aDesiredSize, maxSize, child);
+  aStatus = aReflowCommand.Next(aDesiredSize, maxSize, child);
 
   // Place and size the child. Make sure the child is at least as
   // tall as our max size (the containing window)
@@ -148,20 +151,22 @@ PageFrame::IncrementalReflow(nsIPresContext*  aPresContext,
     child->SetRect(rect);
   }
 
-  return status;
+  return NS_OK;
 }
 
-nsIFrame* PageFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                           nsIFrame*       aParent)
+NS_METHOD PageFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                           nsIFrame*       aParent,
+                                           nsIFrame*&      aContinuingFrame)
 {
-  PageFrame* cf = new PageFrame(mContent, aParent);
+  PageFrame* cf = new PageFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
-void PageFrame::Paint(nsIPresContext&      aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect&        aDirtyRect)
+NS_METHOD PageFrame::Paint(nsIPresContext&      aPresContext,
+                           nsIRenderingContext& aRenderingContext,
+                           const nsRect&        aDirtyRect)
 {
   nsContainerFrame::Paint(aPresContext, aRenderingContext, aDirtyRect);
 
@@ -169,10 +174,12 @@ void PageFrame::Paint(nsIPresContext&      aPresContext,
   // where each page begins and ends
   aRenderingContext.SetColor(NS_RGB(0, 0, 0));
   aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
+  return NS_OK;
 }
 
-void PageFrame::ListTag(FILE* out) const
+NS_METHOD PageFrame::ListTag(FILE* out) const
 {
   fprintf(out, "*PAGE@%p", this);
+  return NS_OK;
 }
 
diff --git a/mozilla/layout/generic/nsPageFrame.h b/mozilla/layout/generic/nsPageFrame.h
index b3d8387c8f5..aaee82d3952 100644
--- a/mozilla/layout/generic/nsPageFrame.h
+++ b/mozilla/layout/generic/nsPageFrame.h
@@ -23,27 +23,30 @@
 // Pseudo frame created by the root content frame
 class PageFrame : public nsContainerFrame {
 public:
-  PageFrame(nsIContent* aContent, nsIFrame* aParent);
+  PageFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext*  aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize&    aMaxSize,
-                                    nsSize*          aMaxElementSize);
+  NS_IMETHOD  ResizeReflow(nsIPresContext*  aPresContext,
+                           nsReflowMetrics& aDesiredSize,
+                           const nsSize&    aMaxSize,
+                           nsSize*          aMaxElementSize,
+                           ReflowStatus&    aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext*  aPresContext,
-                                         nsReflowMetrics& aDesiredSize,
-                                         const nsSize&    aMaxSize,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD  IncrementalReflow(nsIPresContext*  aPresContext,
+                                nsReflowMetrics& aDesiredSize,
+                                const nsSize&    aMaxSize,
+                                nsReflowCommand& aReflowCommand,
+                                ReflowStatus&    aStatus);
 
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame* aParent);
+  NS_IMETHOD  CreateContinuingFrame(nsIPresContext* aPresContext,
+                                    nsIFrame*       aParent,
+                                    nsIFrame*&      aContinuingFrame);
 
-  virtual void          Paint(nsIPresContext&      aPresContext,
-                              nsIRenderingContext& aRenderingContext,
-                              const nsRect&        aDirtyRect);
+  NS_IMETHOD  Paint(nsIPresContext&      aPresContext,
+                    nsIRenderingContext& aRenderingContext,
+                    const nsRect&        aDirtyRect);
 
   // Debugging
-  virtual void  ListTag(FILE* out = stdout) const;
+  NS_IMETHOD  ListTag(FILE* out = stdout) const;
 
 protected:
   void CreateFirstChild(nsIPresContext* aPresContext);
diff --git a/mozilla/layout/generic/nsPlaceholderFrame.cpp b/mozilla/layout/generic/nsPlaceholderFrame.cpp
index 1028f477461..902c2f2603f 100644
--- a/mozilla/layout/generic/nsPlaceholderFrame.cpp
+++ b/mozilla/layout/generic/nsPlaceholderFrame.cpp
@@ -52,16 +52,16 @@ PlaceholderFrame::~PlaceholderFrame()
 {
 }
 
-nsIFrame::ReflowStatus
-PlaceholderFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize&    aMaxSize,
-                               nsSize*          aMaxElementSize)
+NS_METHOD PlaceholderFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                         nsReflowMetrics& aDesiredSize,
+                                         const nsSize&    aMaxSize,
+                                         nsSize*          aMaxElementSize,
+                                         ReflowStatus&    aStatus)
 {
   // Get the floater container in which we're inserted
   nsIFloaterContainer*  container = nsnull;
 
-  for (nsIFrame* parent = mGeometricParent; parent; parent = parent->GetGeometricParent()) {
+  for (nsIFrame* parent = mGeometricParent; parent; parent->GetGeometricParent(parent)) {
     if (NS_OK == parent->QueryInterface(kIFloaterContainerIID, (void**)&container)) {
       break;
     }
@@ -82,7 +82,7 @@ PlaceholderFrame::ResizeReflow(nsIPresContext*  aPresContext,
 
     // Resize reflow the anchored item into the available space
     // XXX Check for complete?
-    mAnchoredItem->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
+    mAnchoredItem->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
     mAnchoredItem->SizeTo(aDesiredSize.width, aDesiredSize.height);
 
     // Now notify our containing block that there's a new floater
@@ -91,11 +91,12 @@ PlaceholderFrame::ResizeReflow(nsIPresContext*  aPresContext,
     container->PlaceFloater(aPresContext, mAnchoredItem, this);
   }
 
-  return nsFrame::ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize);
+  return nsFrame::ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, aStatus);
 }
 
-void PlaceholderFrame::ListTag(FILE* out) const
+NS_METHOD PlaceholderFrame::ListTag(FILE* out) const
 {
   fputs("*placeholder", out);
   fprintf(out, "(%d)@%p", mIndexInParent, this);
+  return NS_OK;
 }
diff --git a/mozilla/layout/generic/nsPlaceholderFrame.h b/mozilla/layout/generic/nsPlaceholderFrame.h
index b3b87673539..6cae7e1c546 100644
--- a/mozilla/layout/generic/nsPlaceholderFrame.h
+++ b/mozilla/layout/generic/nsPlaceholderFrame.h
@@ -36,11 +36,12 @@ public:
   nsIFrame*   GetAnchoredItem() const {return mAnchoredItem;}
 
   // Resize reflow methods
-  virtual ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                                     nsReflowMetrics& aDesiredSize,
-                                     const nsSize&    aMaxSize,
-                                     nsSize*          aMaxElementSize);
-  virtual void          ListTag(FILE* out = stdout) const;
+  NS_IMETHOD  ResizeReflow(nsIPresContext*  aPresContext,
+                           nsReflowMetrics& aDesiredSize,
+                           const nsSize&    aMaxSize,
+                           nsSize*          aMaxElementSize,
+                           ReflowStatus&    aStatus);
+  NS_IMETHOD  ListTag(FILE* out = stdout) const;
 
 protected:
   // Constructor. Takes as arguments the content object, the index in parent,
diff --git a/mozilla/layout/html/base/src/deadnsInlineFrame.h b/mozilla/layout/html/base/src/deadnsInlineFrame.h
index 836a8f3082f..464d604e65d 100644
--- a/mozilla/layout/html/base/src/deadnsInlineFrame.h
+++ b/mozilla/layout/html/base/src/deadnsInlineFrame.h
@@ -31,22 +31,24 @@ public:
                            PRInt32     aIndexInParent,
                            nsIFrame*   aParent);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext*  aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize&    aMaxSize,
-                                    nsSize*          aMaxElementSize);
+  NS_IMETHOD  ResizeReflow(nsIPresContext*  aPresContext,
+                           nsReflowMetrics& aDesiredSize,
+                           const nsSize&    aMaxSize,
+                           nsSize*          aMaxElementSize,
+                           ReflowStatus&    aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext*  aPresContext,
-                                         nsReflowMetrics& aDesiredSize,
-                                         const nsSize&    aMaxSize,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD  IncrementalReflow(nsIPresContext*  aPresContext,
+                                nsReflowMetrics& aDesiredSize,
+                                const nsSize&    aMaxSize,
+                                nsReflowCommand& aReflowCommand,
+                                ReflowStatus&    aStatus);
 
-  virtual void ContentAppended(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer);
+  NS_IMETHOD  ContentAppended(nsIPresShell*   aShell,
+                              nsIPresContext* aPresContext,
+                              nsIContent*     aContainer);
 
-  virtual void GetReflowMetrics(nsIPresContext*  aPresContext,
-                                nsReflowMetrics& aMetrics);
+  NS_IMETHOD  GetReflowMetrics(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aMetrics);
 
 protected:
   nsInlineFrame(nsIContent* aContent,
diff --git a/mozilla/layout/html/base/src/nsBRPart.cpp b/mozilla/layout/html/base/src/nsBRPart.cpp
index 2a731bc7bf4..22791db03d6 100644
--- a/mozilla/layout/html/base/src/nsBRPart.cpp
+++ b/mozilla/layout/html/base/src/nsBRPart.cpp
@@ -37,12 +37,13 @@ public:
   BRFrame(nsIContent* aContent,
           PRInt32 aIndexInParent,
           nsIFrame* aParentFrame);
-  virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize& aMaxSize,
-                                    nsSize* aMaxElementSize);
-  virtual void GetReflowMetrics(nsIPresContext*  aPresContext,
-                                nsReflowMetrics& aMetrics);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize& aMaxSize,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
+  NS_IMETHOD GetReflowMetrics(nsIPresContext*  aPresContext,
+                              nsReflowMetrics& aMetrics);
 
 protected:
   virtual ~BRFrame();
@@ -59,7 +60,7 @@ BRFrame::~BRFrame()
 {
 }
 
-void BRFrame::GetReflowMetrics(nsIPresContext* aPresContext, nsReflowMetrics& aMetrics)
+NS_METHOD BRFrame::GetReflowMetrics(nsIPresContext* aPresContext, nsReflowMetrics& aMetrics)
 {
   // We have no width, but we're the height of the default font
   nsStyleFont* font =
@@ -70,13 +71,14 @@ void BRFrame::GetReflowMetrics(nsIPresContext* aPresContext, nsReflowMetrics& aM
   aMetrics.ascent = fm->GetMaxAscent();
   aMetrics.descent = fm->GetMaxDescent();
   NS_RELEASE(fm);
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-BRFrame::ResizeReflow(nsIPresContext* aPresContext,
-                      nsReflowMetrics& aDesiredSize,
-                      const nsSize& aMaxSize,
-                      nsSize* aMaxElementSize)
+NS_METHOD BRFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                nsReflowMetrics& aDesiredSize,
+                                const nsSize& aMaxSize,
+                                nsSize* aMaxElementSize,
+                                ReflowStatus& aStatus)
 {
   // Get cached state for containing block frame
   nsBlockReflowState* state = nsnull;
@@ -90,7 +92,7 @@ BRFrame::ResizeReflow(nsIPresContext* aPresContext,
         break;
       }
     }
-    parent = parent->GetGeometricParent();
+    parent->GetGeometricParent(parent);
   }
   if (nsnull != parent) {
     nsIPresShell* shell = aPresContext->GetShell();
@@ -103,7 +105,8 @@ BRFrame::ResizeReflow(nsIPresContext* aPresContext,
   }
 
   GetReflowMetrics(aPresContext, aDesiredSize);
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
 //----------------------------------------------------------------------
diff --git a/mozilla/layout/html/base/src/nsBlockFrame.cpp b/mozilla/layout/html/base/src/nsBlockFrame.cpp
index de26654f45d..1aad2a2a540 100644
--- a/mozilla/layout/html/base/src/nsBlockFrame.cpp
+++ b/mozilla/layout/html/base/src/nsBlockFrame.cpp
@@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 
@@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 #endif
@@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
     GetAvailableSpaceBand(aState, aY);
 
     // Get the type of floater
-    nsIStyleContext*  styleContext = floater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+     
+    floater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
   
@@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
       // both the line and the floaters are pushed to the next-in-flow...
     }
   } else {
-    lineHeight = aState.lineStart->GetHeight();
+    nsSize  size;
+
+    aState.lineStart->GetSize(size);
+    lineHeight = size.height;
   }
 
   // The first line always fits
@@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
   nsIFrame* lastFrame = aState.lineStart;
   PRInt32 lineLen = aState.lineLength - 1;
   while (--lineLen >= 0) {
-    lastFrame = lastFrame->GetNextSibling();
+    lastFrame->GetNextSibling(lastFrame);
   }
 
   // Update maxElementSize
@@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
 {
   nsIFrame* prevFrame = aState.prevLineLastFrame;
   NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
-  NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
-                  "bad prev line");
+#ifdef NS_DEBUG
+  nsIFrame* nextSibling;
+
+  prevFrame->GetNextSibling(nextSibling);
+  NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
+#endif
 
 #ifdef NS_DEBUG
   PRInt32 numKids = LengthOf(mFirstChild);
@@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
   PRInt32 kids = 0;
   while (nsnull != kid) {
     kids++;
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
   mChildCount = kids;
 
@@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // Get kid and its style
   // XXX How is this any different than what was passed in to us as aKidMol?
-  nsIContent* kid = kidFrame->GetContent();
-  nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
+  nsIContent* kid;
+  nsIStyleContext* kidSC;
+   
+  kidFrame->GetContent(kid);
+  kidFrame->GetStyleContext(aCX, kidSC);
   nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
   NS_RELEASE(kid);
 
@@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     nsIFrame* lastFrame = aState.lineStart;
     PRInt32   lineLen = aState.lineLength - 1;
     while (--lineLen >= 0) {
-      lastFrame = lastFrame->GetNextSibling();
+      lastFrame->GetNextSibling(lastFrame);
     }
 
     if (!AdvanceToNextLine(aCX, aState)) {
@@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     // Get the style for the last child, and see if it wanted to clear floaters.
     // This handles the BR tag, which is the only inline element for which clear
     // applies
-    nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
+    nsIStyleContext* lastChildSC;
+     
+    lastFrame->GetStyleContext(aCX, lastChildSC);
     nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID); 
     if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
       ClearFloaters(aState, lastChildMol->clear);
@@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
           GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
 
           // Reflow splittable children
-          if (kidFrame->IsSplittable()) {
+          PRBool  isSplittable;
+
+          kidFrame->IsSplittable(isSplittable);
+          if (isSplittable) {
             // Update size info now that we are on the next line. Then
             // reflow the child into the new available space.
             GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
             // If we just reflowed our last child then update the
             // mLastContentIsComplete state.
-            if (nsnull == kidFrame->GetNextSibling()) {
+            nsIFrame* nextSibling;
+
+            kidFrame->GetNextSibling(nextSibling);
+            if (nsnull == nextSibling) {
               // Use state from the reflow we just did
               mLastContentIsComplete = PRBool(status == frComplete);
             }
@@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // If we just reflowed our last child then update the
   // mLastContentIsComplete state.
-  if (nsnull == kidFrame->GetNextSibling()) {
+  nsIFrame* nextSibling;
+
+  kidFrame->GetNextSibling(nextSibling);
+  if (nsnull == nextSibling) {
     // Use state from the reflow we just did
     mLastContentIsComplete = PRBool(status == frComplete);
   }
@@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
   nsIFrame* prevKidFrame = nsnull;
 
   for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     NS_RELEASE(kid);
@@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
     }
 
     // Is the child complete?
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
     if (frComplete == status) {
       // Yes, the child is complete
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+      NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
     } else {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         mChildCount++;
@@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
 
     // Get the next child frame
     prevKidFrame = kidFrame;
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
   }
 
- push_done:;
-  // Update the child count member data
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
-
+ push_done:
 #ifdef NS_DEBUG
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+
   PRInt32 len = LengthOf(mFirstChild);
   NS_POSTCONDITION(len == mChildCount, "bad child count");
   VerifyLastIsComplete();
@@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     mFirstContentOffset = prev->NextChildOffset();
     if (PR_FALSE == prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
 
   // Place our children, one at a time until we are out of children
   PRInt32 kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     } else {
       // Since kid has a prev-in-flow, use that to create the next
       // frame.
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
+      kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
     }
 
     // Link child frame into the list of children. If the frame ends
     // up not fitting and getting pushed, the PushKids code will fixup
     // the child count for us.
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // We ran out of room.
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         NS_RELEASE(kid);
@@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       if (frNotComplete == status) {
         // Child didn't complete so create a continuing frame
         kidPrevInFlow = kidFrame;
-        nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
         // Add the continuing frame to the sibling list
-        continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+        nsIFrame* kidNextSibling;
+
+        kidFrame->GetNextSibling(kidNextSibling);
+        continuingFrame->SetNextSibling(kidNextSibling);
         kidFrame->SetNextSibling(continuingFrame);
         kidFrame = continuingFrame;
         mChildCount++;
 
         // Switch to new kid style
         NS_RELEASE(kidSC);
-        kidSC = kidFrame->GetStyleContext(aCX);
+        kidFrame->GetStyleContext(aCX, kidSC);
         kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       }
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
+#ifdef NS_DEBUG
+      nsIFrame* kidNextInFlow;
+
+      kidFrame->GetNextInFlow(kidNextInFlow);
+      NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
+#endif
     } while (frNotComplete == status);
     NS_RELEASE(kid);
     NS_RELEASE(kidSC);
 
     // The child that we just reflowed is complete
-    NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+#ifdef NS_DEBUG
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
+    NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
+#endif
     kidIndex++;
     kidPrevInFlow = nsnull;
   }
@@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
   // children OR we are a pseudo-frame and we ran into a block
   // element. In either case our last content MUST be complete.
   NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 
  push_done:
@@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
   PRBool result = PR_TRUE;
   nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   while (nsnull != nextInFlow) {
     // Get first available frame from the next-in-flow
     nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     }
 
     // Get style information for the pulled up kid
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
 
@@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // Push the kids that didn't fit back down to the next-in-flow
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         result = PR_FALSE;
@@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
       if (frNotComplete == status) {
         // Child is not complete
-        nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         if (nsnull == kidNextInFlow) {
           // Create a continuing frame for the incomplete child
-          nsIFrame* continuingFrame =
-            kidFrame->CreateContinuingFrame(aCX, this);
+          nsIFrame* continuingFrame;
+           
+          kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
           // Add the continuing frame to our sibling list.
-          continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+          nsIFrame* nextSibling;
+
+          kidFrame->GetNextSibling(nextSibling);
+          continuingFrame->SetNextSibling(nextSibling);
           kidFrame->SetNextSibling(continuingFrame);
           prevKidFrame = kidFrame;
           kidFrame = continuingFrame;
@@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
           // Switch to new kid style
           NS_RELEASE(kidSC);
-          kidSC = kidFrame->GetStyleContext(aCX);
+          kidFrame->GetStyleContext(aCX, kidSC);
           kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
         } else {
           // The child has a next-in-flow, but it's not one of ours.
           // It *must* be in one of our next-in-flows. Collect it
           // then.
-          NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
-                       "busted kid next-in-flow");
+          NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
           break;
         }
       }
@@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     // in our next-in-flows (and reflowing any continunations they
     // have). Therefore we KNOW that our last child is complete.
     NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
 }
 
 #include "nsUnitConversion.h"/* XXX */
-nsIFrame::ReflowStatus
-nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
-                           nsISpaceManager* aSpaceManager,
-                           const nsSize& aMaxSize,
-                           nsRect& aDesiredRect,
-                           nsSize* aMaxElementSize)
+NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
+                                     nsISpaceManager* aSpaceManager,
+                                     const nsSize& aMaxSize,
+                                     nsRect& aDesiredRect,
+                                     nsSize* aMaxElementSize,
+                                     ReflowStatus& aStatus)
 {
   nsBlockReflowState state;
   SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
-  return DoResizeReflow(aCX, state, aDesiredRect);
+  return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
-                             nsBlockReflowState& aState,
-                             nsRect& aDesiredRect)
+nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
+                                      nsBlockReflowState& aState,
+                                      nsRect& aDesiredRect,
+                                      ReflowStatus& aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
@@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 
   // First reflow any existing frames
   PRBool reflowMappedOK = PR_TRUE;
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aCX, aState);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
       // unmapped.  We need to return the correct completion status,
       // so see if there is more to reflow.
       if (MoreToReflow(aCX)) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (MoreToReflow(aCX)) {
       // Try and pull-up some children from a next-in-flow
       if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
         // If we still have unmapped children then create some new frames
         if (MoreToReflow(aCX)) {
-          status = ReflowAppendedChildren(aCX, aState);
+          aStatus = ReflowAppendedChildren(aCX, aState);
         }
       } else {
         // We were unable to pull-up all the existing frames from the
         // next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
@@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 #endif
 
       PushKids(aState);
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there is room for it.
     nscoord margin = aState.prevMaxPosBottomMargin -
@@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   aDesiredRect.height = aState.y;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
 #ifdef NOISY
   ListTag(stdout);
@@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   DumpFlow();
 #endif
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
           kid->JustifyReflow(aCX, availableSpace);
           kid->SizeTo(r.width + availableSpace, r.height);
         }
-        kid = kid->GetNextSibling();
+        kid->GetNextSibling(kid);
       } else {
         // XXX Get justification of multiple elements working
         while (--lineLength >= 0) {
-          kid = kid->GetNextSibling();
+          kid->GetNextSibling(kid);
         }
       }
     }
@@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
   }
 }
 
-nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
-                                              nsIFrame* aParent)
+NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
+                                              nsIFrame* aParent,
+                                              nsIFrame*& aContinuingFrame)
 {
   nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aCX, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
-                                nsISpaceManager* aSpaceManager,
-                                const nsSize& aMaxSize,
-                                nsRect& aDesiredRect,
-                                nsReflowCommand& aReflowCommand)
+NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
+                                          nsISpaceManager* aSpaceManager,
+                                          const nsSize& aMaxSize,
+                                          nsRect& aDesiredRect,
+                                          nsReflowCommand& aReflowCommand,
+                                          ReflowStatus& aStatus)
 {
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
 
   if (aReflowCommand.GetTarget() == this) {
     // XXX for now, just do a complete reflow mapped (it'll kinda
@@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
     SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
     PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   } else {
     // XXX not yet implemented
@@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
   }
 
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
 {
   do {
-    nsIFrame* parent = aFrame->GetGeometricParent();
+    nsIFrame* parent;
+     
+    aFrame->GetGeometricParent(parent);
   
     // See if there are any non-zero sized child frames that precede aFrame
     // in the child list
-    nsIFrame* child = parent->FirstChild();
-  
+    nsIFrame* child;
+     
+    parent->FirstChild(child);
     while ((nsnull != child) && (aFrame != child)) {
+      nsSize  size;
+
       // Is the child zero-sized?
-      if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
+      child->GetSize(size);
+      if ((size.width > 0) || (size.height > 0)) {
         // We found a non-zero sized child frame that precedes aFrame
         return PR_FALSE;
       }
   
-      child = child->GetNextSibling();
+      child->GetNextSibling(child);
     }
   
     // aFrame is the left-most non-zero sized frame in its geometric parent.
@@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   // todo list and we'll handle it when we flush out the line
   if (IsLeftMostChild(aPlaceholder)) {
     // Get the type of floater
-    nsIStyleContext*  styleContext = aFloater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+
+    aFloater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
 
@@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   }
 }
 
-void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
-                                   nsIPresContext* aPresContext,
-                                   nsIContent* aContainer)
+NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
+                                        nsIPresContext* aPresContext,
+                                        nsIContent* aContainer)
 {
-  // Zip down to the end-of-flow
-  nsBlockFrame* flow = this;
-  for (;;) {
-    nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
-    if (nsnull == next) {
-      break;
-    }
-    flow = next;
-  }
+  // Get the last-in-flow
+  nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
 
   PRInt32 kidIndex = flow->NextChildOffset();
   PRInt32 startIndex = kidIndex;
-  nsIFrame* prevKidFrame = flow->LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  flow->LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
           NS_RELEASE(kidSC);
           NS_RELEASE(kid);
   
-          return;
+          return NS_OK;
         }
         // FALL THROUGH (and create frame)
   
@@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
 
     // Link child frame into the list of children
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
                           startIndex);
     aShell->AppendReflowCommand(rc);
   }
+  return NS_OK;
 }
 
 PRIntn nsBlockFrame::GetSkipSides() const
@@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
   return eHTMLFrame_Block;
 }
 
-void nsBlockFrame::ListTag(FILE* out) const
+NS_METHOD nsBlockFrame::ListTag(FILE* out) const
 {
   if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
     fprintf(out, "*block(%d)@%p", mIndexInParent, this);
   } else {
     nsHTMLContainerFrame::ListTag(out);
   }
+  return NS_OK;
 }
 
 #ifdef NS_DEBUG
diff --git a/mozilla/layout/html/base/src/nsBlockFrame.h b/mozilla/layout/html/base/src/nsBlockFrame.h
index ab55c5dbeed..1f348962776 100644
--- a/mozilla/layout/html/base/src/nsBlockFrame.h
+++ b/mozilla/layout/html/base/src/nsBlockFrame.h
@@ -198,24 +198,27 @@ public:
 
   NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
-                                    nsISpaceManager* aSpaceManager,
-                                    const nsSize& aMaxSize,
-                                    nsRect& aDesiredRect,
-                                    nsSize* aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsISpaceManager* aSpaceManager,
+                          const nsSize& aMaxSize,
+                          nsRect& aDesiredRect,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
-                                         nsISpaceManager* aSpaceManager,
-                                         const nsSize& aMaxSize,
-                                         nsRect& aDesiredRect,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
+                               nsISpaceManager* aSpaceManager,
+                               const nsSize& aMaxSize,
+                               nsRect& aDesiredRect,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus& aStatus);
 
-  virtual void ContentAppended(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer);
+  NS_IMETHOD ContentAppended(nsIPresShell* aShell,
+                             nsIPresContext* aPresContext,
+                             nsIContent* aContainer);
 
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame* aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame* aParent,
+                                   nsIFrame*& aContinuingFrame);
 
   virtual PRBool AddFloater(nsIPresContext* aCX,
                             nsIFrame* aFloater,
@@ -224,7 +227,7 @@ public:
                             nsIFrame* aFloater,
                             PlaceholderFrame* aPlaceholder);
 
-  virtual void ListTag(FILE* out = stdout) const;
+  NS_IMETHOD ListTag(FILE* out = stdout) const;
 
   virtual nsHTMLFrameType GetFrameType() const;
 
@@ -277,9 +280,10 @@ protected:
                   const nsSize& aMaxSize, nsSize* aMaxElementSize,
                   nsISpaceManager* aSpaceManager);
 
-  ReflowStatus DoResizeReflow(nsIPresContext* aPresContext,
-                              nsBlockReflowState& aState,
-                              nsRect& aDesiredRect);
+  nsresult DoResizeReflow(nsIPresContext* aPresContext,
+                          nsBlockReflowState& aState,
+                          nsRect& aDesiredRect,
+                          ReflowStatus& aStatus);
 
   PRBool ReflowMappedChildren(nsIPresContext* aPresContext,
                               nsBlockReflowState& aState);
diff --git a/mozilla/layout/html/base/src/nsBlockReflowState.cpp b/mozilla/layout/html/base/src/nsBlockReflowState.cpp
index de26654f45d..1aad2a2a540 100644
--- a/mozilla/layout/html/base/src/nsBlockReflowState.cpp
+++ b/mozilla/layout/html/base/src/nsBlockReflowState.cpp
@@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 
@@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 #endif
@@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
     GetAvailableSpaceBand(aState, aY);
 
     // Get the type of floater
-    nsIStyleContext*  styleContext = floater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+     
+    floater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
   
@@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
       // both the line and the floaters are pushed to the next-in-flow...
     }
   } else {
-    lineHeight = aState.lineStart->GetHeight();
+    nsSize  size;
+
+    aState.lineStart->GetSize(size);
+    lineHeight = size.height;
   }
 
   // The first line always fits
@@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
   nsIFrame* lastFrame = aState.lineStart;
   PRInt32 lineLen = aState.lineLength - 1;
   while (--lineLen >= 0) {
-    lastFrame = lastFrame->GetNextSibling();
+    lastFrame->GetNextSibling(lastFrame);
   }
 
   // Update maxElementSize
@@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
 {
   nsIFrame* prevFrame = aState.prevLineLastFrame;
   NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
-  NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
-                  "bad prev line");
+#ifdef NS_DEBUG
+  nsIFrame* nextSibling;
+
+  prevFrame->GetNextSibling(nextSibling);
+  NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
+#endif
 
 #ifdef NS_DEBUG
   PRInt32 numKids = LengthOf(mFirstChild);
@@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
   PRInt32 kids = 0;
   while (nsnull != kid) {
     kids++;
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
   mChildCount = kids;
 
@@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // Get kid and its style
   // XXX How is this any different than what was passed in to us as aKidMol?
-  nsIContent* kid = kidFrame->GetContent();
-  nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
+  nsIContent* kid;
+  nsIStyleContext* kidSC;
+   
+  kidFrame->GetContent(kid);
+  kidFrame->GetStyleContext(aCX, kidSC);
   nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
   NS_RELEASE(kid);
 
@@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     nsIFrame* lastFrame = aState.lineStart;
     PRInt32   lineLen = aState.lineLength - 1;
     while (--lineLen >= 0) {
-      lastFrame = lastFrame->GetNextSibling();
+      lastFrame->GetNextSibling(lastFrame);
     }
 
     if (!AdvanceToNextLine(aCX, aState)) {
@@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     // Get the style for the last child, and see if it wanted to clear floaters.
     // This handles the BR tag, which is the only inline element for which clear
     // applies
-    nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
+    nsIStyleContext* lastChildSC;
+     
+    lastFrame->GetStyleContext(aCX, lastChildSC);
     nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID); 
     if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
       ClearFloaters(aState, lastChildMol->clear);
@@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
           GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
 
           // Reflow splittable children
-          if (kidFrame->IsSplittable()) {
+          PRBool  isSplittable;
+
+          kidFrame->IsSplittable(isSplittable);
+          if (isSplittable) {
             // Update size info now that we are on the next line. Then
             // reflow the child into the new available space.
             GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
             // If we just reflowed our last child then update the
             // mLastContentIsComplete state.
-            if (nsnull == kidFrame->GetNextSibling()) {
+            nsIFrame* nextSibling;
+
+            kidFrame->GetNextSibling(nextSibling);
+            if (nsnull == nextSibling) {
               // Use state from the reflow we just did
               mLastContentIsComplete = PRBool(status == frComplete);
             }
@@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // If we just reflowed our last child then update the
   // mLastContentIsComplete state.
-  if (nsnull == kidFrame->GetNextSibling()) {
+  nsIFrame* nextSibling;
+
+  kidFrame->GetNextSibling(nextSibling);
+  if (nsnull == nextSibling) {
     // Use state from the reflow we just did
     mLastContentIsComplete = PRBool(status == frComplete);
   }
@@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
   nsIFrame* prevKidFrame = nsnull;
 
   for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     NS_RELEASE(kid);
@@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
     }
 
     // Is the child complete?
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
     if (frComplete == status) {
       // Yes, the child is complete
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+      NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
     } else {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         mChildCount++;
@@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
 
     // Get the next child frame
     prevKidFrame = kidFrame;
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
   }
 
- push_done:;
-  // Update the child count member data
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
-
+ push_done:
 #ifdef NS_DEBUG
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+
   PRInt32 len = LengthOf(mFirstChild);
   NS_POSTCONDITION(len == mChildCount, "bad child count");
   VerifyLastIsComplete();
@@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     mFirstContentOffset = prev->NextChildOffset();
     if (PR_FALSE == prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
 
   // Place our children, one at a time until we are out of children
   PRInt32 kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     } else {
       // Since kid has a prev-in-flow, use that to create the next
       // frame.
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
+      kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
     }
 
     // Link child frame into the list of children. If the frame ends
     // up not fitting and getting pushed, the PushKids code will fixup
     // the child count for us.
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // We ran out of room.
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         NS_RELEASE(kid);
@@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       if (frNotComplete == status) {
         // Child didn't complete so create a continuing frame
         kidPrevInFlow = kidFrame;
-        nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
         // Add the continuing frame to the sibling list
-        continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+        nsIFrame* kidNextSibling;
+
+        kidFrame->GetNextSibling(kidNextSibling);
+        continuingFrame->SetNextSibling(kidNextSibling);
         kidFrame->SetNextSibling(continuingFrame);
         kidFrame = continuingFrame;
         mChildCount++;
 
         // Switch to new kid style
         NS_RELEASE(kidSC);
-        kidSC = kidFrame->GetStyleContext(aCX);
+        kidFrame->GetStyleContext(aCX, kidSC);
         kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       }
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
+#ifdef NS_DEBUG
+      nsIFrame* kidNextInFlow;
+
+      kidFrame->GetNextInFlow(kidNextInFlow);
+      NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
+#endif
     } while (frNotComplete == status);
     NS_RELEASE(kid);
     NS_RELEASE(kidSC);
 
     // The child that we just reflowed is complete
-    NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+#ifdef NS_DEBUG
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
+    NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
+#endif
     kidIndex++;
     kidPrevInFlow = nsnull;
   }
@@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
   // children OR we are a pseudo-frame and we ran into a block
   // element. In either case our last content MUST be complete.
   NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 
  push_done:
@@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
   PRBool result = PR_TRUE;
   nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   while (nsnull != nextInFlow) {
     // Get first available frame from the next-in-flow
     nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     }
 
     // Get style information for the pulled up kid
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
 
@@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // Push the kids that didn't fit back down to the next-in-flow
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         result = PR_FALSE;
@@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
       if (frNotComplete == status) {
         // Child is not complete
-        nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         if (nsnull == kidNextInFlow) {
           // Create a continuing frame for the incomplete child
-          nsIFrame* continuingFrame =
-            kidFrame->CreateContinuingFrame(aCX, this);
+          nsIFrame* continuingFrame;
+           
+          kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
           // Add the continuing frame to our sibling list.
-          continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+          nsIFrame* nextSibling;
+
+          kidFrame->GetNextSibling(nextSibling);
+          continuingFrame->SetNextSibling(nextSibling);
           kidFrame->SetNextSibling(continuingFrame);
           prevKidFrame = kidFrame;
           kidFrame = continuingFrame;
@@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
           // Switch to new kid style
           NS_RELEASE(kidSC);
-          kidSC = kidFrame->GetStyleContext(aCX);
+          kidFrame->GetStyleContext(aCX, kidSC);
           kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
         } else {
           // The child has a next-in-flow, but it's not one of ours.
           // It *must* be in one of our next-in-flows. Collect it
           // then.
-          NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
-                       "busted kid next-in-flow");
+          NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
           break;
         }
       }
@@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     // in our next-in-flows (and reflowing any continunations they
     // have). Therefore we KNOW that our last child is complete.
     NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
 }
 
 #include "nsUnitConversion.h"/* XXX */
-nsIFrame::ReflowStatus
-nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
-                           nsISpaceManager* aSpaceManager,
-                           const nsSize& aMaxSize,
-                           nsRect& aDesiredRect,
-                           nsSize* aMaxElementSize)
+NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
+                                     nsISpaceManager* aSpaceManager,
+                                     const nsSize& aMaxSize,
+                                     nsRect& aDesiredRect,
+                                     nsSize* aMaxElementSize,
+                                     ReflowStatus& aStatus)
 {
   nsBlockReflowState state;
   SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
-  return DoResizeReflow(aCX, state, aDesiredRect);
+  return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
-                             nsBlockReflowState& aState,
-                             nsRect& aDesiredRect)
+nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
+                                      nsBlockReflowState& aState,
+                                      nsRect& aDesiredRect,
+                                      ReflowStatus& aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
@@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 
   // First reflow any existing frames
   PRBool reflowMappedOK = PR_TRUE;
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aCX, aState);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
       // unmapped.  We need to return the correct completion status,
       // so see if there is more to reflow.
       if (MoreToReflow(aCX)) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (MoreToReflow(aCX)) {
       // Try and pull-up some children from a next-in-flow
       if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
         // If we still have unmapped children then create some new frames
         if (MoreToReflow(aCX)) {
-          status = ReflowAppendedChildren(aCX, aState);
+          aStatus = ReflowAppendedChildren(aCX, aState);
         }
       } else {
         // We were unable to pull-up all the existing frames from the
         // next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
@@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 #endif
 
       PushKids(aState);
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there is room for it.
     nscoord margin = aState.prevMaxPosBottomMargin -
@@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   aDesiredRect.height = aState.y;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
 #ifdef NOISY
   ListTag(stdout);
@@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   DumpFlow();
 #endif
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
           kid->JustifyReflow(aCX, availableSpace);
           kid->SizeTo(r.width + availableSpace, r.height);
         }
-        kid = kid->GetNextSibling();
+        kid->GetNextSibling(kid);
       } else {
         // XXX Get justification of multiple elements working
         while (--lineLength >= 0) {
-          kid = kid->GetNextSibling();
+          kid->GetNextSibling(kid);
         }
       }
     }
@@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
   }
 }
 
-nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
-                                              nsIFrame* aParent)
+NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
+                                              nsIFrame* aParent,
+                                              nsIFrame*& aContinuingFrame)
 {
   nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aCX, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
-                                nsISpaceManager* aSpaceManager,
-                                const nsSize& aMaxSize,
-                                nsRect& aDesiredRect,
-                                nsReflowCommand& aReflowCommand)
+NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
+                                          nsISpaceManager* aSpaceManager,
+                                          const nsSize& aMaxSize,
+                                          nsRect& aDesiredRect,
+                                          nsReflowCommand& aReflowCommand,
+                                          ReflowStatus& aStatus)
 {
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
 
   if (aReflowCommand.GetTarget() == this) {
     // XXX for now, just do a complete reflow mapped (it'll kinda
@@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
     SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
     PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   } else {
     // XXX not yet implemented
@@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
   }
 
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
 {
   do {
-    nsIFrame* parent = aFrame->GetGeometricParent();
+    nsIFrame* parent;
+     
+    aFrame->GetGeometricParent(parent);
   
     // See if there are any non-zero sized child frames that precede aFrame
     // in the child list
-    nsIFrame* child = parent->FirstChild();
-  
+    nsIFrame* child;
+     
+    parent->FirstChild(child);
     while ((nsnull != child) && (aFrame != child)) {
+      nsSize  size;
+
       // Is the child zero-sized?
-      if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
+      child->GetSize(size);
+      if ((size.width > 0) || (size.height > 0)) {
         // We found a non-zero sized child frame that precedes aFrame
         return PR_FALSE;
       }
   
-      child = child->GetNextSibling();
+      child->GetNextSibling(child);
     }
   
     // aFrame is the left-most non-zero sized frame in its geometric parent.
@@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   // todo list and we'll handle it when we flush out the line
   if (IsLeftMostChild(aPlaceholder)) {
     // Get the type of floater
-    nsIStyleContext*  styleContext = aFloater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+
+    aFloater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
 
@@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   }
 }
 
-void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
-                                   nsIPresContext* aPresContext,
-                                   nsIContent* aContainer)
+NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
+                                        nsIPresContext* aPresContext,
+                                        nsIContent* aContainer)
 {
-  // Zip down to the end-of-flow
-  nsBlockFrame* flow = this;
-  for (;;) {
-    nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
-    if (nsnull == next) {
-      break;
-    }
-    flow = next;
-  }
+  // Get the last-in-flow
+  nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
 
   PRInt32 kidIndex = flow->NextChildOffset();
   PRInt32 startIndex = kidIndex;
-  nsIFrame* prevKidFrame = flow->LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  flow->LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
           NS_RELEASE(kidSC);
           NS_RELEASE(kid);
   
-          return;
+          return NS_OK;
         }
         // FALL THROUGH (and create frame)
   
@@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
 
     // Link child frame into the list of children
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
                           startIndex);
     aShell->AppendReflowCommand(rc);
   }
+  return NS_OK;
 }
 
 PRIntn nsBlockFrame::GetSkipSides() const
@@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
   return eHTMLFrame_Block;
 }
 
-void nsBlockFrame::ListTag(FILE* out) const
+NS_METHOD nsBlockFrame::ListTag(FILE* out) const
 {
   if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
     fprintf(out, "*block(%d)@%p", mIndexInParent, this);
   } else {
     nsHTMLContainerFrame::ListTag(out);
   }
+  return NS_OK;
 }
 
 #ifdef NS_DEBUG
diff --git a/mozilla/layout/html/base/src/nsBlockReflowState.h b/mozilla/layout/html/base/src/nsBlockReflowState.h
index de26654f45d..1aad2a2a540 100644
--- a/mozilla/layout/html/base/src/nsBlockReflowState.h
+++ b/mozilla/layout/html/base/src/nsBlockReflowState.h
@@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 
@@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
     printf("  ");
     ((nsFrame*)f)->ListTag(stdout);/* XXX */
     printf("\n");
-    f = f->GetNextSibling();
+    f->GetNextSibling(f);
   }
 }
 #endif
@@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
     GetAvailableSpaceBand(aState, aY);
 
     // Get the type of floater
-    nsIStyleContext*  styleContext = floater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+     
+    floater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
   
@@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
       // both the line and the floaters are pushed to the next-in-flow...
     }
   } else {
-    lineHeight = aState.lineStart->GetHeight();
+    nsSize  size;
+
+    aState.lineStart->GetSize(size);
+    lineHeight = size.height;
   }
 
   // The first line always fits
@@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
   nsIFrame* lastFrame = aState.lineStart;
   PRInt32 lineLen = aState.lineLength - 1;
   while (--lineLen >= 0) {
-    lastFrame = lastFrame->GetNextSibling();
+    lastFrame->GetNextSibling(lastFrame);
   }
 
   // Update maxElementSize
@@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
 {
   nsIFrame* prevFrame = aState.prevLineLastFrame;
   NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
-  NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
-                  "bad prev line");
+#ifdef NS_DEBUG
+  nsIFrame* nextSibling;
+
+  prevFrame->GetNextSibling(nextSibling);
+  NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
+#endif
 
 #ifdef NS_DEBUG
   PRInt32 numKids = LengthOf(mFirstChild);
@@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
   PRInt32 kids = 0;
   while (nsnull != kid) {
     kids++;
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
   mChildCount = kids;
 
@@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // Get kid and its style
   // XXX How is this any different than what was passed in to us as aKidMol?
-  nsIContent* kid = kidFrame->GetContent();
-  nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
+  nsIContent* kid;
+  nsIStyleContext* kidSC;
+   
+  kidFrame->GetContent(kid);
+  kidFrame->GetStyleContext(aCX, kidSC);
   nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
   NS_RELEASE(kid);
 
@@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     nsIFrame* lastFrame = aState.lineStart;
     PRInt32   lineLen = aState.lineLength - 1;
     while (--lineLen >= 0) {
-      lastFrame = lastFrame->GetNextSibling();
+      lastFrame->GetNextSibling(lastFrame);
     }
 
     if (!AdvanceToNextLine(aCX, aState)) {
@@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
     // Get the style for the last child, and see if it wanted to clear floaters.
     // This handles the BR tag, which is the only inline element for which clear
     // applies
-    nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
+    nsIStyleContext* lastChildSC;
+     
+    lastFrame->GetStyleContext(aCX, lastChildSC);
     nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID); 
     if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
       ClearFloaters(aState, lastChildMol->clear);
@@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
           GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
 
           // Reflow splittable children
-          if (kidFrame->IsSplittable()) {
+          PRBool  isSplittable;
+
+          kidFrame->IsSplittable(isSplittable);
+          if (isSplittable) {
             // Update size info now that we are on the next line. Then
             // reflow the child into the new available space.
             GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
             // If we just reflowed our last child then update the
             // mLastContentIsComplete state.
-            if (nsnull == kidFrame->GetNextSibling()) {
+            nsIFrame* nextSibling;
+
+            kidFrame->GetNextSibling(nextSibling);
+            if (nsnull == nextSibling) {
               // Use state from the reflow we just did
               mLastContentIsComplete = PRBool(status == frComplete);
             }
@@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
 
   // If we just reflowed our last child then update the
   // mLastContentIsComplete state.
-  if (nsnull == kidFrame->GetNextSibling()) {
+  nsIFrame* nextSibling;
+
+  kidFrame->GetNextSibling(nextSibling);
+  if (nsnull == nextSibling) {
     // Use state from the reflow we just did
     mLastContentIsComplete = PRBool(status == frComplete);
   }
@@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
   nsIFrame* prevKidFrame = nsnull;
 
   for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     NS_RELEASE(kid);
@@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
     }
 
     // Is the child complete?
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
     if (frComplete == status) {
       // Yes, the child is complete
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+      NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
     } else {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         mChildCount++;
@@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
 
     // Get the next child frame
     prevKidFrame = kidFrame;
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
   }
 
- push_done:;
-  // Update the child count member data
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
-
+ push_done:
 #ifdef NS_DEBUG
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+
   PRInt32 len = LengthOf(mFirstChild);
   NS_POSTCONDITION(len == mChildCount, "bad child count");
   VerifyLastIsComplete();
@@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     mFirstContentOffset = prev->NextChildOffset();
     if (PR_FALSE == prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
 
   // Place our children, one at a time until we are out of children
   PRInt32 kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
     } else {
       // Since kid has a prev-in-flow, use that to create the next
       // frame.
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
+      kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
     }
 
     // Link child frame into the list of children. If the frame ends
     // up not fitting and getting pushed, the PushKids code will fixup
     // the child count for us.
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // We ran out of room.
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         NS_RELEASE(kid);
@@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
       if (frNotComplete == status) {
         // Child didn't complete so create a continuing frame
         kidPrevInFlow = kidFrame;
-        nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
         // Add the continuing frame to the sibling list
-        continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+        nsIFrame* kidNextSibling;
+
+        kidFrame->GetNextSibling(kidNextSibling);
+        continuingFrame->SetNextSibling(kidNextSibling);
         kidFrame->SetNextSibling(continuingFrame);
         kidFrame = continuingFrame;
         mChildCount++;
 
         // Switch to new kid style
         NS_RELEASE(kidSC);
-        kidSC = kidFrame->GetStyleContext(aCX);
+        kidFrame->GetStyleContext(aCX, kidSC);
         kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       }
-      NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
+#ifdef NS_DEBUG
+      nsIFrame* kidNextInFlow;
+
+      kidFrame->GetNextInFlow(kidNextInFlow);
+      NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
+#endif
     } while (frNotComplete == status);
     NS_RELEASE(kid);
     NS_RELEASE(kidSC);
 
     // The child that we just reflowed is complete
-    NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
+#ifdef NS_DEBUG
+    nsIFrame* kidNextInFlow;
+
+    kidFrame->GetNextInFlow(kidNextInFlow);
+    NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
+#endif
     kidIndex++;
     kidPrevInFlow = nsnull;
   }
@@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
   // children OR we are a pseudo-frame and we ran into a block
   // element. In either case our last content MUST be complete.
   NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 
  push_done:
@@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
   PRBool result = PR_TRUE;
   nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   while (nsnull != nextInFlow) {
     // Get first available frame from the next-in-flow
     nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     }
 
     // Get style information for the pulled up kid
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
     nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
 
@@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
       status = aState.reflowStatus;
       if (0 == (placeStatus & PLACE_FIT)) {
         // Push the kids that didn't fit back down to the next-in-flow
-        mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
         PushKids(aState);
 
         result = PR_FALSE;
@@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
       if (frNotComplete == status) {
         // Child is not complete
-        nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         if (nsnull == kidNextInFlow) {
           // Create a continuing frame for the incomplete child
-          nsIFrame* continuingFrame =
-            kidFrame->CreateContinuingFrame(aCX, this);
+          nsIFrame* continuingFrame;
+           
+          kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
 
           // Add the continuing frame to our sibling list.
-          continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+          nsIFrame* nextSibling;
+
+          kidFrame->GetNextSibling(nextSibling);
+          continuingFrame->SetNextSibling(nextSibling);
           kidFrame->SetNextSibling(continuingFrame);
           prevKidFrame = kidFrame;
           kidFrame = continuingFrame;
@@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
 
           // Switch to new kid style
           NS_RELEASE(kidSC);
-          kidSC = kidFrame->GetStyleContext(aCX);
+          kidFrame->GetStyleContext(aCX, kidSC);
           kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
         } else {
           // The child has a next-in-flow, but it's not one of ours.
           // It *must* be in one of our next-in-flows. Collect it
           // then.
-          NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
-                       "busted kid next-in-flow");
+          NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
           break;
         }
       }
@@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
     // in our next-in-flows (and reflowing any continunations they
     // have). Therefore we KNOW that our last child is complete.
     NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
 }
 
 #include "nsUnitConversion.h"/* XXX */
-nsIFrame::ReflowStatus
-nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
-                           nsISpaceManager* aSpaceManager,
-                           const nsSize& aMaxSize,
-                           nsRect& aDesiredRect,
-                           nsSize* aMaxElementSize)
+NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
+                                     nsISpaceManager* aSpaceManager,
+                                     const nsSize& aMaxSize,
+                                     nsRect& aDesiredRect,
+                                     nsSize* aMaxElementSize,
+                                     ReflowStatus& aStatus)
 {
   nsBlockReflowState state;
   SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
-  return DoResizeReflow(aCX, state, aDesiredRect);
+  return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
-                             nsBlockReflowState& aState,
-                             nsRect& aDesiredRect)
+nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
+                                      nsBlockReflowState& aState,
+                                      nsRect& aDesiredRect,
+                                      ReflowStatus& aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
@@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 
   // First reflow any existing frames
   PRBool reflowMappedOK = PR_TRUE;
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aCX, aState);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
       // unmapped.  We need to return the correct completion status,
       // so see if there is more to reflow.
       if (MoreToReflow(aCX)) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (MoreToReflow(aCX)) {
       // Try and pull-up some children from a next-in-flow
       if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
         // If we still have unmapped children then create some new frames
         if (MoreToReflow(aCX)) {
-          status = ReflowAppendedChildren(aCX, aState);
+          aStatus = ReflowAppendedChildren(aCX, aState);
         }
       } else {
         // We were unable to pull-up all the existing frames from the
         // next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
@@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
 #endif
 
       PushKids(aState);
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there is room for it.
     nscoord margin = aState.prevMaxPosBottomMargin -
@@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   aDesiredRect.height = aState.y;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
 #ifdef NOISY
   ListTag(stdout);
@@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
   DumpFlow();
 #endif
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
           kid->JustifyReflow(aCX, availableSpace);
           kid->SizeTo(r.width + availableSpace, r.height);
         }
-        kid = kid->GetNextSibling();
+        kid->GetNextSibling(kid);
       } else {
         // XXX Get justification of multiple elements working
         while (--lineLength >= 0) {
-          kid = kid->GetNextSibling();
+          kid->GetNextSibling(kid);
         }
       }
     }
@@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
   }
 }
 
-nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
-                                              nsIFrame* aParent)
+NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
+                                              nsIFrame* aParent,
+                                              nsIFrame*& aContinuingFrame)
 {
   nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aCX, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
-                                nsISpaceManager* aSpaceManager,
-                                const nsSize& aMaxSize,
-                                nsRect& aDesiredRect,
-                                nsReflowCommand& aReflowCommand)
+NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
+                                          nsISpaceManager* aSpaceManager,
+                                          const nsSize& aMaxSize,
+                                          nsRect& aDesiredRect,
+                                          nsReflowCommand& aReflowCommand,
+                                          ReflowStatus& aStatus)
 {
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;
 
   if (aReflowCommand.GetTarget() == this) {
     // XXX for now, just do a complete reflow mapped (it'll kinda
@@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
     SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
     PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
     if (!reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   } else {
     // XXX not yet implemented
@@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
   }
 
   mCurrentState = nsnull;
-  return status;
+  return NS_OK;
 }
 
 PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
 {
   do {
-    nsIFrame* parent = aFrame->GetGeometricParent();
+    nsIFrame* parent;
+     
+    aFrame->GetGeometricParent(parent);
   
     // See if there are any non-zero sized child frames that precede aFrame
     // in the child list
-    nsIFrame* child = parent->FirstChild();
-  
+    nsIFrame* child;
+     
+    parent->FirstChild(child);
     while ((nsnull != child) && (aFrame != child)) {
+      nsSize  size;
+
       // Is the child zero-sized?
-      if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
+      child->GetSize(size);
+      if ((size.width > 0) || (size.height > 0)) {
         // We found a non-zero sized child frame that precedes aFrame
         return PR_FALSE;
       }
   
-      child = child->GetNextSibling();
+      child->GetNextSibling(child);
     }
   
     // aFrame is the left-most non-zero sized frame in its geometric parent.
@@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   // todo list and we'll handle it when we flush out the line
   if (IsLeftMostChild(aPlaceholder)) {
     // Get the type of floater
-    nsIStyleContext*  styleContext = aFloater->GetStyleContext(aCX);
+    nsIStyleContext*  styleContext;
+
+    aFloater->GetStyleContext(aCX, styleContext);
     nsStyleMolecule*  mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
     NS_RELEASE(styleContext);
 
@@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
   }
 }
 
-void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
-                                   nsIPresContext* aPresContext,
-                                   nsIContent* aContainer)
+NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
+                                        nsIPresContext* aPresContext,
+                                        nsIContent* aContainer)
 {
-  // Zip down to the end-of-flow
-  nsBlockFrame* flow = this;
-  for (;;) {
-    nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
-    if (nsnull == next) {
-      break;
-    }
-    flow = next;
-  }
+  // Get the last-in-flow
+  nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
 
   PRInt32 kidIndex = flow->NextChildOffset();
   PRInt32 startIndex = kidIndex;
-  nsIFrame* prevKidFrame = flow->LastChild();
   nsIFrame* kidFrame = nsnull;
+  nsIFrame* prevKidFrame;
+   
+  flow->LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
           NS_RELEASE(kidSC);
           NS_RELEASE(kid);
   
-          return;
+          return NS_OK;
         }
         // FALL THROUGH (and create frame)
   
@@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
 
     // Link child frame into the list of children
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* nextSibling;
+
+      prevKidFrame->GetNextSibling(nextSibling);
+      NS_ASSERTION(nsnull == nextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
                           startIndex);
     aShell->AppendReflowCommand(rc);
   }
+  return NS_OK;
 }
 
 PRIntn nsBlockFrame::GetSkipSides() const
@@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
   return eHTMLFrame_Block;
 }
 
-void nsBlockFrame::ListTag(FILE* out) const
+NS_METHOD nsBlockFrame::ListTag(FILE* out) const
 {
   if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
     fprintf(out, "*block(%d)@%p", mIndexInParent, this);
   } else {
     nsHTMLContainerFrame::ListTag(out);
   }
+  return NS_OK;
 }
 
 #ifdef NS_DEBUG
diff --git a/mozilla/layout/html/base/src/nsBodyFrame.cpp b/mozilla/layout/html/base/src/nsBodyFrame.cpp
index d98a0080506..949b53757ab 100644
--- a/mozilla/layout/html/base/src/nsBodyFrame.cpp
+++ b/mozilla/layout/html/base/src/nsBodyFrame.cpp
@@ -98,7 +98,7 @@ void nsBodyFrame::CreateColumnFrame(nsIPresContext* aPresContext)
     NS_ASSERTION(prevBody->ChildIsPseudoFrame(prevColumn), "bad previous column");
 
     // Create a continuing column
-    mFirstChild = prevColumn->CreateContinuingFrame(aPresContext, this);
+    prevColumn->CreateContinuingFrame(aPresContext, this, mFirstChild);
     mChildCount = 1;
   }
 }
@@ -130,13 +130,13 @@ nsSize nsBodyFrame::GetColumnAvailSpace(nsIPresContext*  aPresContext,
   return result;
 }
 
-nsIFrame::ReflowStatus
-nsBodyFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                          nsReflowMetrics& aDesiredSize,
-                          const nsSize&    aMaxSize,
-                          nsSize*          aMaxElementSize)
+NS_METHOD nsBodyFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                    nsReflowMetrics& aDesiredSize,
+                                    const nsSize&    aMaxSize,
+                                    nsSize*          aMaxElementSize,
+                                    ReflowStatus&    aStatus)
 {
-  nsIFrame::ReflowStatus  status = frComplete;
+  aStatus = frComplete;  // initialize out parameter
 
   // Do we have any children?
   if (nsnull == mFirstChild) {
@@ -168,8 +168,8 @@ nsBodyFrame::ResizeReflow(nsIPresContext*  aPresContext,
     nsRect  desiredRect;
 
     mSpaceManager->Translate(leftInset, topInset);
-    status = ReflowChild(mFirstChild, aPresContext, mSpaceManager, columnMaxSize,
-                         desiredRect, aMaxElementSize);
+    aStatus = ReflowChild(mFirstChild, aPresContext, mSpaceManager, columnMaxSize,
+                          desiredRect, aMaxElementSize);
     mSpaceManager->Translate(-leftInset, -topInset);
 
     // Place and size the column
@@ -193,16 +193,18 @@ nsBodyFrame::ResizeReflow(nsIPresContext*  aPresContext,
     aDesiredSize.descent = 0;
   }
 
-  return status;
+  return NS_OK;
 }
 
-void nsBodyFrame::VerifyTree() const
+NS_METHOD nsBodyFrame::VerifyTree() const
 {
 #ifdef NS_DEBUG
   // Check our child count
   PRInt32 len = LengthOf(mFirstChild);
   NS_ASSERTION(len == mChildCount, "bad child count");
-  nsIFrame* lastChild = LastChild();
+  nsIFrame* lastChild;
+   
+  LastChild(lastChild);
   if (len != 0) {
     NS_ASSERTION(nsnull != lastChild, "bad last child");
   }
@@ -217,7 +219,7 @@ void nsBodyFrame::VerifyTree() const
   while (nsnull != child) {
     // Make sure that the child's tree is valid
     child->VerifyTree();
-    child = child->GetNextSibling();
+    child->GetNextSibling(child);
   }
 
   // Make sure that our flow blocks offsets are all correct
@@ -233,16 +235,15 @@ void nsBodyFrame::VerifyTree() const
     }
   }
 #endif
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsBodyFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize&    aMaxSize,
-                               nsReflowCommand& aReflowCommand)
+NS_METHOD nsBodyFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                         nsReflowMetrics& aDesiredSize,
+                                         const nsSize&    aMaxSize,
+                                         nsReflowCommand& aReflowCommand,
+                                         ReflowStatus&    aStatus)
 {
-  ReflowStatus  status;
-
   // Get our border/padding info
   nsStyleMolecule* myMol =
     (nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
@@ -276,8 +277,8 @@ nsBodyFrame::IncrementalReflow(nsIPresContext*  aPresContext,
 
     NS_ASSERTION(nsnull != mFirstChild, "no first child");
     mFirstChild->QueryInterface(kIRunaroundIID, (void**)&reflowRunaround);
-    status = reflowRunaround->IncrementalReflow(aPresContext, mSpaceManager,
-      columnMaxSize, aDesiredRect, aReflowCommand);
+    reflowRunaround->IncrementalReflow(aPresContext, mSpaceManager,
+      columnMaxSize, aDesiredRect, aReflowCommand, aStatus);
 
     // Place and size the column
     aDesiredRect.x += leftInset;
@@ -302,7 +303,7 @@ nsBodyFrame::IncrementalReflow(nsIPresContext*  aPresContext,
     nsRect    desiredRect;
     nsIFrame* child;
 
-    status = aReflowCommand.Next(mSpaceManager, desiredRect, aMaxSize, child);
+    aStatus = aReflowCommand.Next(mSpaceManager, desiredRect, aMaxSize, child);
 
     // XXX Deal with next in flow, adjusting of siblings, adjusting the
     // content length...
@@ -315,24 +316,17 @@ nsBodyFrame::IncrementalReflow(nsIPresContext*  aPresContext,
   }
 
   mSpaceManager->Translate(-leftInset, -topInset);
-  return status;
+  return NS_OK;
 }
 
-void nsBodyFrame::ContentAppended(nsIPresShell* aShell,
-                                  nsIPresContext* aPresContext,
-                                  nsIContent* aContainer)
+NS_METHOD nsBodyFrame::ContentAppended(nsIPresShell*   aShell,
+                                       nsIPresContext* aPresContext,
+                                       nsIContent*     aContainer)
 {
   NS_ASSERTION(mContent == aContainer, "bad content-appended target");
 
-  // Zip down to the end-of-flow
-  nsBodyFrame* flow = this;
-  for (;;) {
-    nsBodyFrame* next = (nsBodyFrame*) flow->GetNextInFlow();
-    if (nsnull == next) {
-      break;
-    }
-    flow = next;
-  }
+  // Get the last-in-flow
+  nsBodyFrame* flow = (nsBodyFrame*)GetLastInFlow();
 
   // Since body frame's have only a single pseudo-frame in them,
   // pass on the content-appended call to the pseudo-frame
@@ -344,6 +338,7 @@ void nsBodyFrame::ContentAppended(nsIPresShell* aShell,
     new nsReflowCommand(aPresContext, flow, nsReflowCommand::FrameAppended,
                         oldLastContentOffset);
   aShell->AppendReflowCommand(rc);
+  return NS_OK;
 }
 
 void nsBodyFrame::AddAnchoredItem(nsIFrame*         aAnchoredItem,
@@ -352,26 +347,31 @@ void nsBodyFrame::AddAnchoredItem(nsIFrame*         aAnchoredItem,
 {
   aAnchoredItem->SetGeometricParent(this);
   // Add the item to the end of the child list
-  LastChild()->SetNextSibling(aAnchoredItem);
+  nsIFrame* lastChild;
+
+  LastChild(lastChild);
+  lastChild->SetNextSibling(aAnchoredItem);
   aAnchoredItem->SetNextSibling(nsnull);
   mChildCount++;
 }
 
 void nsBodyFrame::RemoveAnchoredItem(nsIFrame* aAnchoredItem)
 {
-  NS_PRECONDITION(this == aAnchoredItem->GetGeometricParent(), "bad anchored item");
+  NS_PRECONDITION(IsChild(aAnchoredItem), "bad anchored item");
   NS_ASSERTION(aAnchoredItem != mFirstChild, "unexpected anchored item");
   // Remove the anchored item from the child list
   // XXX Implement me
   mChildCount--;
 }
 
-nsIFrame* nsBodyFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                             nsIFrame*       aParent)
+NS_METHOD nsBodyFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                             nsIFrame*       aParent,
+                                             nsIFrame*&      aContinuingFrame)
 {
   nsBodyFrame* cf = new nsBodyFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 // XXX use same logic as block frame?
diff --git a/mozilla/layout/html/base/src/nsBodyFrame.h b/mozilla/layout/html/base/src/nsBodyFrame.h
index 563e779b21b..38d54672ff5 100644
--- a/mozilla/layout/html/base/src/nsBodyFrame.h
+++ b/mozilla/layout/html/base/src/nsBodyFrame.h
@@ -33,22 +33,25 @@ public:
 
   NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
 
-  virtual ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                                     nsReflowMetrics& aDesiredSize,
-                                     const nsSize&    aMaxSize,
-                                     nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&    aMaxSize,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
-  virtual ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                          nsReflowMetrics& aDesiredSize,
-                                          const nsSize&    aMaxSize,
-                                          nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
-  virtual void ContentAppended(nsIPresShell*   aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent*     aContainer);
+  NS_IMETHOD ContentAppended(nsIPresShell*   aShell,
+                             nsIPresContext* aPresContext,
+                             nsIContent*     aContainer);
 
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
   virtual void AddAnchoredItem(nsIFrame*         aAnchoredItem,
                                AnchoringPosition aPosition,
@@ -56,7 +59,7 @@ public:
 
   virtual void RemoveAnchoredItem(nsIFrame* aAnchoredItem);
 
-  virtual void VerifyTree() const;
+  NS_IMETHOD VerifyTree() const;
 
 protected:
   nsBodyFrame(nsIContent* aContent,
diff --git a/mozilla/layout/html/base/src/nsColumnFrame.cpp b/mozilla/layout/html/base/src/nsColumnFrame.cpp
index 5e93a9a86b5..15c71220429 100644
--- a/mozilla/layout/html/base/src/nsColumnFrame.cpp
+++ b/mozilla/layout/html/base/src/nsColumnFrame.cpp
@@ -226,12 +226,12 @@ PRBool ColumnFrame::ReflowMappedChildren(nsIPresContext*    aPresContext,
     nsIFrame::ReflowStatus  status;
 
     // Get top margin for this kid
-    nsIContent* kid = kidFrame->GetContent();
-    nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+    nsIStyleContext* kidSC;
+
+    kidFrame->GetStyleContext(aPresContext, kidSC);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
     nscoord bottomMargin = kidMol->margin.bottom;
-    NS_RELEASE(kid);
     NS_RELEASE(kidSC);
 
     // Figure out the amount of available size for the child (subtract
@@ -297,15 +297,20 @@ PRBool ColumnFrame::ReflowMappedChildren(nsIPresContext*    aPresContext,
     if (frNotComplete == status) {
       // XXX It's good to assume that we might still have room
       // even if the child didn't complete (floaters will want this)
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       if (nsnull == kidNextInFlow) {
         // No the child isn't complete, and it doesn't have a next in flow so
         // create a continuing frame. This hooks the child into the flow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
 
         // Insert the frame. We'll reflow it next pass through the loop
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         if (nsnull == nextSib) {
@@ -319,7 +324,7 @@ PRBool ColumnFrame::ReflowMappedChildren(nsIPresContext*    aPresContext,
 
     // Get the next child
     prevKidFrame = kidFrame;
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
 
     // XXX talk with troy about checking for available space here
   }
@@ -329,7 +334,7 @@ PRBool ColumnFrame::ReflowMappedChildren(nsIPresContext*    aPresContext,
   NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
 
   // Set the last content offset based on the last child we mapped.
-  NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
   SetLastContentOffset(prevKidFrame);
 
 #ifdef NS_DEBUG
@@ -397,7 +402,9 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext*    aPresContext,
 
   // The frame previous to the current frame we are reflowing. This
   // starts out initially as our last frame.
-  nsIFrame*     prevKidFrame = LastChild();
+  nsIFrame*     prevKidFrame;
+   
+  LastChild(prevKidFrame);
 
   // This will hold the prevKidFrame's mLastContentIsComplete
   // status. If we have to push the frame that follows prevKidFrame
@@ -421,8 +428,9 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext*    aPresContext,
     }
 
     // Get top margin for this kid
-    nsIContent* kid = kidFrame->GetContent();
-    nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+    nsIStyleContext* kidSC;
+     
+    kidFrame->GetStyleContext(aPresContext, kidSC);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
     nscoord bottomMargin = kidMol->margin.bottom;
@@ -443,8 +451,8 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext*    aPresContext,
       // out of space.
       if ((kidFrame == mFirstChild) || (kidAvailSize.height > 0)) {
         aState.spaceManager->Translate(kidMol->margin.left, topMargin);
-        status = ReflowChild(kidFrame, aPresContext, aState.spaceManager,
-                             kidAvailSize, kidRect, pKidMaxElementSize);
+        status = ReflowChild(kidFrame, aPresContext, aState.spaceManager, kidAvailSize,
+                             kidRect, pKidMaxElementSize);
         aState.spaceManager->Translate(-kidMol->margin.left, -topMargin);
       }
 
@@ -458,12 +466,14 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext*    aPresContext,
         //
         // Note that if the width is too big that's okay and we allow the
         // child to extend horizontally outside of the reflow area
-        PRBool lastComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
+        nsIFrame* kidNextInFlow;
+
+        kidFrame->GetNextInFlow(kidNextInFlow);
+        PRBool lastComplete = PRBool(nsnull == kidNextInFlow);
         PushChildren(kidFrame, prevKidFrame, lastComplete);
         mLastContentIsComplete = prevLastContentIsComplete;
         mChildCount--;
         result = PR_FALSE;
-        NS_RELEASE(kid);
         NS_RELEASE(kidSC);
         goto push_done;
       }
@@ -492,16 +502,22 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext*    aPresContext,
       // Is the child we just pulled up complete?
       if (frNotComplete == status) {
         // No the child isn't complete.
-        nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         if (nsnull == kidNextInFlow) {
           // The child doesn't have a next-in-flow so create a
           // continuing frame. The creation appends it to the flow and
           // prepares it for reflow.
-          nsIFrame* continuingFrame =
-            kidFrame->CreateContinuingFrame(aPresContext, this);
+          nsIFrame* continuingFrame;
+
+          kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
 
           // Add the continuing frame to our sibling list.
-          continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+          nsIFrame* kidNextSibling;
+
+          kidFrame->GetNextSibling(kidNextSibling);
+          continuingFrame->SetNextSibling(kidNextSibling);
           kidFrame->SetNextSibling(continuingFrame);
           prevKidFrame = kidFrame;
           prevLastContentIsComplete = mLastContentIsComplete;
@@ -511,13 +527,11 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext*    aPresContext,
           // The child has a next-in-flow, but it's not one of ours.
           // It *must* be in one of our next-in-flows. Collect it
           // then.
-          NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
-                       "busted kid next-in-flow");
+          NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
           break;
         }
       }
     } while (frNotComplete == status);
-    NS_RELEASE(kid);
     NS_RELEASE(kidSC);
 
     prevKidFrame = kidFrame;
@@ -527,7 +541,7 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext*    aPresContext,
  push_done:;
   // Update our last content index
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -547,7 +561,7 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext*    aPresContext,
       // the next-in-flows must be empty. Do a sanity check
       while (nsnull != nextInFlow) {
         NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
-        nextInFlow = (ColumnFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
       }
 #endif
     }
@@ -609,7 +623,7 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext*    aPresContext,
     mFirstContentOffset = prev->NextChildOffset();
     if (!prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
 
@@ -619,7 +633,9 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext*    aPresContext,
   nsSize    kidMaxElementSize;
   nsSize*   pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
   PRInt32   kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();  // XXX remember this...
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);  // XXX remember this...
 
   for (;;) {
     // Get the next content object
@@ -681,7 +697,7 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext*    aPresContext,
       }
       kidFrame->SetStyleContext(kidStyleContext);
     } else {
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
+      kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
       if (ChildIsPseudoFrame(kidFrame)) {
         pseudoFrame = (nsBlockFrame*) kidFrame;
       }
@@ -690,7 +706,12 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext*    aPresContext,
     // Link the child frame into the list of children and update the
     // child count
     if (nsnull != prevKidFrame) {
-      NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
+#ifdef NS_DEBUG
+      nsIFrame* prevNextSibling;
+
+      prevKidFrame->GetNextSibling(prevNextSibling);
+      NS_ASSERTION(nsnull == prevNextSibling, "bad append");
+#endif
       prevKidFrame->SetNextSibling(kidFrame);
     } else {
       NS_ASSERTION(nsnull == mFirstChild, "bad create");
@@ -731,7 +752,12 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext*    aPresContext,
         NS_ASSERTION(nsnull == mNextInFlow, "whoops");
 
         // Chop off the part of our child list that's being overflowed
-        NS_ASSERTION(prevKidFrame->GetNextSibling() == kidFrame, "bad list");
+#ifdef NS_DEBUG
+        nsIFrame* prevNextSibling;
+
+        prevKidFrame->GetNextSibling(prevNextSibling);
+        NS_ASSERTION(prevNextSibling == kidFrame, "bad list");
+#endif
         prevKidFrame->SetNextSibling(nsnull);
 
         // Create overflow list
@@ -743,7 +769,7 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext*    aPresContext,
         nsIFrame* f = kidFrame;
         while (nsnull != f) {
           overflowKids++;
-          f = f->GetNextSibling();
+          f->GetNextSibling(f);
         }
         mChildCount -= overflowKids;
         NS_RELEASE(kidStyleContext);
@@ -774,11 +800,15 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext*    aPresContext,
       if (frNotComplete == status) {
         // Child didn't complete so create a continuing frame
         kidPrevInFlow = kidFrame;
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
 
         // Add the continuing frame to the sibling list
-        continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
+        nsIFrame* kidNextSibling;
+
+        kidFrame->GetNextSibling(kidNextSibling);
+        continuingFrame->SetNextSibling(kidNextSibling);
         kidFrame->SetNextSibling(continuingFrame);
         prevKidFrame = kidFrame;
         kidFrame = continuingFrame;
@@ -810,7 +840,7 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext*    aPresContext,
 
 done:
   // Update the content mapping
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   if (0 != mChildCount) {
     SetLastContentOffset(prevKidFrame);
   }
@@ -822,12 +852,12 @@ done:
   return result;
 }
 
-nsIFrame::ReflowStatus
-ColumnFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                          nsISpaceManager* aSpaceManager,
-                          const nsSize&    aMaxSize,
-                          nsRect&          aDesiredRect,
-                          nsSize*          aMaxElementSize)
+NS_METHOD ColumnFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                    nsISpaceManager* aSpaceManager,
+                                    const nsSize&    aMaxSize,
+                                    nsRect&          aDesiredRect,
+                                    nsSize*          aMaxElementSize,
+                                    ReflowStatus&    aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
@@ -838,7 +868,8 @@ ColumnFrame::ResizeReflow(nsIPresContext*  aPresContext,
   //XXX NS_PRECONDITION((aMaxSize.width > 0) && (aMaxSize.height > 0), "unexpected max size");
 
   PRBool        reflowMappedOK = PR_TRUE;
-  ReflowStatus  status = frComplete;
+
+  aStatus = frComplete;  // initialize out parameter
 
   // Initialize out parameter
   if (nsnull != aMaxElementSize) {
@@ -859,7 +890,7 @@ ColumnFrame::ResizeReflow(nsIPresContext*  aPresContext,
     reflowMappedOK =
       ReflowMappedChildren(aPresContext, state, aMaxElementSize);
     if (PR_FALSE == reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -869,7 +900,7 @@ ColumnFrame::ResizeReflow(nsIPresContext*  aPresContext,
     if ((nsnull != mFirstChild) && (state.availSize.height <= 0)) {
       // No space left. Don't try to pull-up children or reflow unmapped
       if (NextChildOffset() < mContent->ChildCount()) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (NextChildOffset() < mContent->ChildCount()) {
       // Try and pull-up some children from a next-in-flow
@@ -877,13 +908,13 @@ ColumnFrame::ResizeReflow(nsIPresContext*  aPresContext,
           PullUpChildren(aPresContext, state, aMaxElementSize)) {
         // If we still have unmapped children then create some new frames
         if (NextChildOffset() < mContent->ChildCount()) {
-          status =
+          aStatus =
             ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
         }
       } else {
         // We were unable to pull-up all the existing frames from the
         // next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
@@ -891,7 +922,7 @@ ColumnFrame::ResizeReflow(nsIPresContext*  aPresContext,
   // Restore the coordinate space
   aSpaceManager->Translate(0, -state.y);
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there's room for it.
     nscoord margin = state.prevMaxPosBottomMargin -
@@ -914,7 +945,7 @@ ColumnFrame::ResizeReflow(nsIPresContext*  aPresContext,
   }
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 
   // Verify we properly restored the coordinate space
   nscoord txOut, tyOut;
@@ -922,21 +953,20 @@ ColumnFrame::ResizeReflow(nsIPresContext*  aPresContext,
   aSpaceManager->GetTranslation(txOut, tyOut);
   NS_POSTCONDITION((txIn == txOut) && (tyIn == tyOut), "bad translation");
 #endif
-  return status;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-ColumnFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                               nsISpaceManager* aSpaceManager,
-                               const nsSize&    aMaxSize,
-                               nsRect&          aDesiredRect,
-                               nsReflowCommand& aReflowCommand)
+NS_METHOD ColumnFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                         nsISpaceManager* aSpaceManager,
+                                         const nsSize&    aMaxSize,
+                                         nsRect&          aDesiredRect,
+                                         nsReflowCommand& aReflowCommand,
+                                         ReflowStatus&    aStatus)
 {
 #ifdef NS_DEBUG
   nscoord txIn, tyIn;
   aSpaceManager->GetTranslation(txIn, tyIn);
 #endif
-  ReflowStatus  status;
 
   // Who's the reflow command targeted for?
   if (aReflowCommand.GetTarget() == mGeometricParent) {
@@ -970,12 +1000,15 @@ ColumnFrame::IncrementalReflow(nsIPresContext*  aPresContext,
           break;
         }
       } else {
-        if (kidFrame->GetIndexInParent() == startOffset) {
+        PRInt32 kidIndexInParent;
+
+        kidFrame->GetIndexInParent(kidIndexInParent);
+        if (kidIndexInParent == startOffset) {
           break;
         }
       }
       prevKidFrame = kidFrame;
-      kidFrame = kidFrame->GetNextSibling();
+      kidFrame->GetNextSibling(kidFrame);
     }
 
     // Factor in the previous kid's bottom margin information
@@ -988,12 +1021,12 @@ ColumnFrame::IncrementalReflow(nsIPresContext*  aPresContext,
       prevKidFrame->GetRect(startKidRect);
 
       // Get style info
-      nsIContent* kid = prevKidFrame->GetContent();
-      nsIStyleContext* kidSC = prevKidFrame->GetStyleContext(aPresContext);
+      nsIStyleContext* kidSC;
+
+      prevKidFrame->GetStyleContext(aPresContext, kidSC);
       nsStyleMolecule* kidMol =
         (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       nscoord bottomMargin = kidMol->margin.bottom;
-      NS_RELEASE(kid);
       NS_RELEASE(kidSC);
 
       state.y = startKidRect.YMost();
@@ -1004,12 +1037,12 @@ ColumnFrame::IncrementalReflow(nsIPresContext*  aPresContext,
       }
     } else {
       // Get style info
-      nsIContent* kid = kidFrame->GetContent();
-      nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+      nsIStyleContext* kidSC;
+
+      kidFrame->GetStyleContext(aPresContext, kidSC);
       nsStyleMolecule* kidMol =
         (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       nscoord topMargin = kidMol->margin.top;
-      NS_RELEASE(kid);
       NS_RELEASE(kidSC);
 
       // Initialize y to start after the top margin
@@ -1029,11 +1062,11 @@ ColumnFrame::IncrementalReflow(nsIPresContext*  aPresContext,
 
     // Now ResizeReflow the appended frames
     while (nsnull != kidFrame) {
-      nsIContent* kid = kidFrame->GetContent();
-      nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+      nsIStyleContext* kidSC;
+
+      kidFrame->GetStyleContext(aPresContext, kidSC);
       nsStyleMolecule* kidMol =
         (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
-      NS_RELEASE(kid);
 
       nsRect kidRect;
       nsSize kidAvailSize(state.availSize);
@@ -1043,8 +1076,8 @@ ColumnFrame::IncrementalReflow(nsIPresContext*  aPresContext,
 
       // Reflow the child
       state.spaceManager->Translate(kidMol->margin.left, 0);
-      status = ReflowChild(kidFrame, aPresContext, state.spaceManager,
-                           kidAvailSize, kidRect, nsnull);
+      aStatus = ReflowChild(kidFrame, aPresContext, state.spaceManager,
+                            kidAvailSize, kidRect, nsnull);
       state.spaceManager->Translate(-kidMol->margin.left, 0);
 
       // Did it fit?
@@ -1074,13 +1107,13 @@ ColumnFrame::IncrementalReflow(nsIPresContext*  aPresContext,
       NS_RELEASE(kidSC);
 
       // XXX Was it complete?
-      if (frNotComplete == status) {
+      if (frNotComplete == aStatus) {
         // XXX Need to push remaining frames and trigger a reflow there
         NS_ABORT();
       }
 
       prevKidFrame = kidFrame;
-      kidFrame = kidFrame->GetNextSibling();
+      kidFrame->GetNextSibling(kidFrame);
     }
     SetLastContentOffset(prevKidFrame);
 
@@ -1110,13 +1143,13 @@ ColumnFrame::IncrementalReflow(nsIPresContext*  aPresContext,
   aSpaceManager->GetTranslation(txOut, tyOut);
   NS_POSTCONDITION((txIn == txOut) && (tyIn == tyOut), "bad translation");
 #endif
-  return status;
+  return NS_OK;
 }
 
 // XXX factor nicely with reflow-unmapped
-void ColumnFrame::ContentAppended(nsIPresShell* aShell,
-                                  nsIPresContext* aPresContext,
-                                  nsIContent* aContainer)
+NS_METHOD ColumnFrame::ContentAppended(nsIPresShell* aShell,
+                                       nsIPresContext* aPresContext,
+                                       nsIContent* aContainer)
 {
   // We must only be called by the body frame since we are a
   // pseudo-frame; the body frame makes sure that it's dealing with
@@ -1127,9 +1160,10 @@ void ColumnFrame::ContentAppended(nsIPresShell* aShell,
   // Get index of where the content has been appended
   PRInt32 kidIndex = NextChildOffset();
   PRInt32 startIndex = kidIndex;
-  nsIFrame* prevKidFrame = LastChild();
   nsIContent* content = mContent;
-
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);
   nsBlockFrame* pseudoFrame = nsnull;
   if ((nsnull != prevKidFrame) && ChildIsPseudoFrame(prevKidFrame)) {
     pseudoFrame = (nsBlockFrame*) prevKidFrame;
@@ -1249,14 +1283,17 @@ void ColumnFrame::ContentAppended(nsIPresShell* aShell,
   SetLastContentOffset(prevKidFrame);
   // Note: Column frames *never* directly generate reflow commands
   // because they are always pseudo-frames for bodies.
+  return NS_OK;
 }
 
-nsIFrame* ColumnFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                             nsIFrame*       aParent)
+NS_METHOD ColumnFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                             nsIFrame*       aParent,
+                                             nsIFrame*&      aContinuingFrame)
 {
   ColumnFrame* cf = new ColumnFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 PRIntn ColumnFrame::GetSkipSides() const
@@ -1266,8 +1303,9 @@ PRIntn ColumnFrame::GetSkipSides() const
   return 0x0F;
 }
 
-void ColumnFrame::ListTag(FILE* out) const
+NS_METHOD ColumnFrame::ListTag(FILE* out) const
 {
   fprintf(out, "*COLUMN@%p", this);
+  return NS_OK;
 }
 
diff --git a/mozilla/layout/html/base/src/nsColumnFrame.h b/mozilla/layout/html/base/src/nsColumnFrame.h
index 0391a5d6c72..94454617233 100644
--- a/mozilla/layout/html/base/src/nsColumnFrame.h
+++ b/mozilla/layout/html/base/src/nsColumnFrame.h
@@ -31,27 +31,30 @@ public:
 
   NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
 
-  virtual ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                                     nsISpaceManager* aSpaceManager,
-                                     const nsSize&    aMaxSize,
-                                     nsRect&          aDesiredRect,
-                                     nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aPresContext,
+                          nsISpaceManager* aSpaceManager,
+                          const nsSize&    aMaxSize,
+                          nsRect&          aDesiredRect,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
-  virtual ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                          nsISpaceManager* aSpaceManager,
-                                          const nsSize&    aMaxSize,
-                                          nsRect&          aDesiredRect,
-                                          nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsISpaceManager* aSpaceManager,
+                               const nsSize&    aMaxSize,
+                               nsRect&          aDesiredRect,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
-  virtual void ContentAppended(nsIPresShell* aShell,
-                               nsIPresContext* aPresContext,
-                               nsIContent* aContainer);
+  NS_IMETHOD ContentAppended(nsIPresShell* aShell,
+                             nsIPresContext* aPresContext,
+                             nsIContent* aContainer);
 
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
   // Debugging
-  virtual void  ListTag(FILE* out = stdout) const;
+  NS_IMETHOD ListTag(FILE* out = stdout) const;
 
 protected:
   ~ColumnFrame();
diff --git a/mozilla/layout/html/base/src/nsHRPart.cpp b/mozilla/layout/html/base/src/nsHRPart.cpp
index ba6ecd4d0c0..e5bc102e93d 100644
--- a/mozilla/layout/html/base/src/nsHRPart.cpp
+++ b/mozilla/layout/html/base/src/nsHRPart.cpp
@@ -73,9 +73,9 @@ public:
              PRInt32 aIndexInParent,
              nsIFrame* aParentFrame);
 
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_METHOD Paint(nsIPresContext& aPresContext,
+                  nsIRenderingContext& aRenderingContext,
+                  const nsRect& aDirtyRect);
 
 protected:
   virtual ~HRuleFrame();
@@ -109,9 +109,9 @@ HRuleFrame::~HRuleFrame()
 {
 }
 
-void HRuleFrame::Paint(nsIPresContext& aPresContext,
-                       nsIRenderingContext& aRenderingContext,
-                       const nsRect& aDirtyRect)
+NS_METHOD HRuleFrame::Paint(nsIPresContext& aPresContext,
+                            nsIRenderingContext& aRenderingContext,
+                            const nsRect& aDirtyRect)
 {
   float p2t = aPresContext.GetPixelsToTwips();
   nscoord thickness = nscoord(p2t * ((HRulePart*)mContent)->mThickness);
@@ -197,6 +197,7 @@ void HRuleFrame::Paint(nsIPresContext& aPresContext,
                                  width - diameter, height);
      }
   }
+  return NS_OK;
 }
 
 // Weird color computing code stolen from winfe which was stolen
diff --git a/mozilla/layout/html/base/src/nsHTMLContainerFrame.cpp b/mozilla/layout/html/base/src/nsHTMLContainerFrame.cpp
index 960b6c0396d..c5026c6058a 100644
--- a/mozilla/layout/html/base/src/nsHTMLContainerFrame.cpp
+++ b/mozilla/layout/html/base/src/nsHTMLContainerFrame.cpp
@@ -44,10 +44,9 @@ nsHTMLContainerFrame::~nsHTMLContainerFrame()
 {
 }
 
-void
-nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
-                            nsIRenderingContext& aRenderingContext,
-                            const nsRect& aDirtyRect)
+NS_METHOD nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
+                                      nsIRenderingContext& aRenderingContext,
+                                      const nsRect& aDirtyRect)
 {
   // Do not paint ourselves if we are a pseudo-frame
   if (PR_FALSE == IsPseudoFrame()) {
@@ -68,6 +67,7 @@ nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
     aRenderingContext.SetColor(NS_RGB(255,0,0));
     aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
   }
+  return NS_OK;
 }
 
 void nsHTMLContainerFrame::TriggerLink(nsIPresContext& aPresContext,
@@ -96,14 +96,15 @@ void nsHTMLContainerFrame::TriggerLink(nsIPresContext& aPresContext,
   }
 }
 
-nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
-                                                nsGUIEvent* aEvent)
+NS_METHOD nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
+                                            nsGUIEvent* aEvent,
+                                            nsEventStatus& aEventStatus)
 {
-  nsEventStatus rv = nsEventStatus_eIgnore; 
+  aEventStatus = nsEventStatus_eIgnore; 
   switch (aEvent->message) {
   case NS_MOUSE_LEFT_BUTTON_UP:
     if (nsEventStatus_eIgnore ==
-        nsContainerFrame::HandleEvent(aPresContext, aEvent)) { 
+        nsContainerFrame::HandleEvent(aPresContext, aEvent, aEventStatus)) { 
       // If our child didn't take the click then since we are an
       // anchor, we take the click.
       nsIAtom* tag = mContent->GetTag();
@@ -112,7 +113,7 @@ nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
         mContent->GetAttribute("href", href);
         mContent->GetAttribute("target", target);
         TriggerLink(aPresContext, base, href, target);
-        rv = nsEventStatus_eConsumeNoDefault; 
+        aEventStatus = nsEventStatus_eConsumeNoDefault; 
       }
       NS_IF_RELEASE(tag);
     }
@@ -123,15 +124,16 @@ nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
     break;
 
   default:
-    rv = nsContainerFrame::HandleEvent(aPresContext, aEvent);
+    nsContainerFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
     break;
   }
-  return rv;
+  return NS_OK;
 }
 
-PRInt32 nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
-                                          const nsPoint& aPoint,
-                                          nsIFrame** aFrame)
+NS_METHOD nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
+                                            const nsPoint& aPoint,
+                                            nsIFrame** aFrame,
+                                            PRInt32& aCursor)
 {
   nsStyleMolecule* mol = (nsStyleMolecule*)
     mStyleContext->GetData(kStyleMoleculeSID);
@@ -139,9 +141,10 @@ PRInt32 nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
     // If this container has a particular cursor, use it, otherwise
     // let the child decide.
     *aFrame = this;
-    return (PRInt32) mol->cursor;
+    aCursor = (PRInt32)mol->cursor;
+    return NS_OK;
   }
-  return nsContainerFrame::GetCursorAt(aPresContext, aPoint, aFrame);
+  return nsContainerFrame::GetCursorAt(aPresContext, aPoint, aFrame, aCursor);
 }
 
 #if 0
diff --git a/mozilla/layout/html/base/src/nsHTMLContainerFrame.h b/mozilla/layout/html/base/src/nsHTMLContainerFrame.h
index 974db84442d..e8e6709fcdb 100644
--- a/mozilla/layout/html/base/src/nsHTMLContainerFrame.h
+++ b/mozilla/layout/html/base/src/nsHTMLContainerFrame.h
@@ -30,16 +30,18 @@ public:
                        PRInt32 aIndexInParent,
                        nsIFrame* aParent);
 
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD  Paint(nsIPresContext& aPresContext,
+                    nsIRenderingContext& aRenderingContext,
+                    const nsRect& aDirtyRect);
 
-  virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
-                                    nsGUIEvent* aEvent);
+  NS_IMETHOD  HandleEvent(nsIPresContext& aPresContext,
+                          nsGUIEvent* aEvent,
+                          nsEventStatus& aEventStatus);
 
-  virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
-                              const nsPoint& aPoint,
-                              nsIFrame** aFrame);
+  NS_IMETHOD  GetCursorAt(nsIPresContext& aPresContext,
+                          const nsPoint& aPoint,
+                          nsIFrame** aFrame,
+                          PRInt32& aCursor);
 
 #if 0
   virtual ReflowStatus IncrementalReflow(nsIPresContext*  aPresContext,
diff --git a/mozilla/layout/html/base/src/nsHTMLImage.cpp b/mozilla/layout/html/base/src/nsHTMLImage.cpp
index b7252c7f684..a62eb0b1d83 100644
--- a/mozilla/layout/html/base/src/nsHTMLImage.cpp
+++ b/mozilla/layout/html/base/src/nsHTMLImage.cpp
@@ -44,16 +44,18 @@ public:
              PRInt32 aIndexInParent,
              nsIFrame* aParentFrame);
 
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
-                                    nsGUIEvent* aEvent);
+  NS_METHOD HandleEvent(nsIPresContext& aPresContext,
+                        nsGUIEvent* aEvent,
+                        nsEventStatus& aEventStatus);
 
-  virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
-                              const nsPoint& aPoint,
-                              nsIFrame** aFrame);
+  NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
+                         const nsPoint& aPoint,
+                         nsIFrame** aFrame,
+                         PRInt32& aCursor);
 
 protected:
   virtual ~ImageFrame();
@@ -131,13 +133,13 @@ nsIImage* ImageFrame::GetImage(nsIPresContext& aPresContext)
   return nsnull;
 }
 
-void ImageFrame::Paint(nsIPresContext& aPresContext,
-                       nsIRenderingContext& aRenderingContext,
-                       const nsRect& aDirtyRect)
+NS_METHOD ImageFrame::Paint(nsIPresContext& aPresContext,
+                            nsIRenderingContext& aRenderingContext,
+                            const nsRect& aDirtyRect)
 {
   nsIImage* image = GetImage(aPresContext);
   if (nsnull == image) {
-    return;
+    return NS_OK;
   }
 
   // First paint background and borders
@@ -156,6 +158,8 @@ void ImageFrame::Paint(nsIPresContext& aPresContext,
       map->Draw(aPresContext, aRenderingContext);
     }
   }
+
+  return NS_OK;
 }
 
 nsIImageMap* ImageFrame::GetImageMap()
@@ -201,10 +205,11 @@ void ImageFrame::TriggerLink(nsIPresContext& aPresContext,
 }
 
 // XXX what about transparent pixels?
-nsEventStatus ImageFrame::HandleEvent(nsIPresContext& aPresContext,
-                                      nsGUIEvent* aEvent)
+NS_METHOD ImageFrame::HandleEvent(nsIPresContext& aPresContext,
+                                  nsGUIEvent* aEvent,
+                                  nsEventStatus& aEventStatus)
 {
-  nsEventStatus rv = nsEventStatus_eIgnore; 
+  aEventStatus = nsEventStatus_eIgnore; 
 
   switch (aEvent->message) {
   case NS_MOUSE_LEFT_BUTTON_UP:
@@ -233,7 +238,7 @@ nsEventStatus ImageFrame::HandleEvent(nsIPresContext& aPresContext,
         if (NS_OK == r) {
           // We hit a clickable area. Time to go somewhere...
           TriggerLink(aPresContext, absURL, target);
-          rv = nsEventStatus_eConsumeNoDefault; 
+          aEventStatus = nsEventStatus_eConsumeNoDefault; 
         }
         break;
       }
@@ -242,15 +247,16 @@ nsEventStatus ImageFrame::HandleEvent(nsIPresContext& aPresContext,
 
   default:
     // Let default event handler deal with it
-    return nsLeafFrame::HandleEvent(aPresContext, aEvent);
+    return nsLeafFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
   }
 
-  return rv;
+  return NS_OK;
 }
 
-PRInt32 ImageFrame::GetCursorAt(nsIPresContext& aPresContext,
-                                const nsPoint& aPoint,
-                                nsIFrame** aFrame)
+NS_METHOD ImageFrame::GetCursorAt(nsIPresContext& aPresContext,
+                                  const nsPoint& aPoint,
+                                  nsIFrame** aFrame,
+                                  PRInt32& aCursor)
 {
   nsStyleMolecule* mol = (nsStyleMolecule*)
     mStyleContext->GetData(kStyleMoleculeSID);
@@ -258,7 +264,7 @@ PRInt32 ImageFrame::GetCursorAt(nsIPresContext& aPresContext,
     // If this container has a particular cursor, use it, otherwise
     // let the child decide.
     *aFrame = this;
-    return (PRInt32) mol->cursor;
+    aCursor = (PRInt32) mol->cursor;
   }
   nsIImageMap* map = GetImageMap();
   if (nsnull != map) {
@@ -270,9 +276,10 @@ PRInt32 ImageFrame::GetCursorAt(nsIPresContext& aPresContext,
       rv = NS_STYLE_CURSOR_HAND;
     }
     NS_RELEASE(map);
-    return rv;
+    return NS_OK;
   }
-  return NS_STYLE_CURSOR_INHERIT;
+  aCursor = NS_STYLE_CURSOR_INHERIT;
+  return NS_OK;
 }
 
 void ImageFrame::GetDesiredSize(nsIPresContext* aPresContext,
diff --git a/mozilla/layout/html/base/src/nsInlineFrame.cpp b/mozilla/layout/html/base/src/nsInlineFrame.cpp
index c795cf6122e..d623ffb10d6 100644
--- a/mozilla/layout/html/base/src/nsInlineFrame.cpp
+++ b/mozilla/layout/html/base/src/nsInlineFrame.cpp
@@ -241,17 +241,22 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No, the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       PRBool lastContentIsComplete = mLastContentIsComplete;
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         if (nsnull == nextSib) {
@@ -264,7 +269,9 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
 
       // We've used up all of our available space so push the remaining
       // children to the next-in-flow
-      nsIFrame* nextSibling = kidFrame->GetNextSibling();
+      nsIFrame* nextSibling;
+       
+      kidFrame->GetNextSibling(nextSibling);
       if (nsnull != nextSibling) {
         PushChildren(nextSibling, kidFrame, lastContentIsComplete);
         SetLastContentOffset(prevKidFrame);
@@ -274,16 +281,22 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
     }
 
     // Get the next child frame
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
 
     // XXX talk with troy about checking for available space here
   }
 
   // Update the child count member data
   mChildCount = childCount;
-  NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
 #ifdef NS_DEBUG
+  NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
+
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
   VerifyLastIsComplete();
 #endif
   return result;
@@ -309,7 +322,9 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
 #ifdef NS_DEBUG
   PRInt32        kidIndex = NextChildOffset();
 #endif
-  nsIFrame*      prevKidFrame = LastChild();
+  nsIFrame*      prevKidFrame;
+   
+  LastChild(prevKidFrame);
 
   // This will hold the prevKidFrame's mLastContentIsComplete
   // status. If we have to push the frame that follows prevKidFrame
@@ -338,7 +353,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
         kidFrame = nextInFlow->mFirstChild;
       } else {
         // We've pulled up all the children, so move to the next-in-flow.
-        nextInFlow = (nsInlineFrame*)nextInFlow->GetNextInFlow();
+        nsIFrame* next;
+
+        nextInFlow->GetNextInFlow(next);
+        nextInFlow = (nsInlineFrame*)next;
         continue;
       }
     }
@@ -346,8 +364,12 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
     // See if the child fits in the available space. If it fits or
     // it's splittable then reflow it. The reason we can't just move
     // it is that we still need ascent/descent information
-    if ((kidFrame->GetWidth() > aState.availSize.width) &&
-        !kidFrame->IsSplittable()) {
+    nsSize  kidFrameSize;
+    PRBool  kidIsSplittable;
+
+    kidFrame->GetSize(kidFrameSize);
+    kidFrame->IsSplittable(kidIsSplittable);
+    if ((kidFrameSize.width > aState.availSize.width) && !kidIsSplittable) {
       result = PR_FALSE;
       mLastContentIsComplete = prevLastContentIsComplete;
       break;
@@ -369,7 +391,7 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
     PlaceChild(kidFrame, mChildCount, aState, kidSize, pKidMaxElementSize);
 
     // Remove the frame from its current parent
-    nextInFlow->mFirstChild = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(nextInFlow->mFirstChild);
     nextInFlow->mChildCount--;
     // Update the next-in-flows first content offset
     if (nsnull != nextInFlow->mFirstChild) {
@@ -378,7 +400,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
 
     // Link the frame into our list of children
     kidFrame->SetGeometricParent(this);
-    if (nextInFlow == kidFrame->GetContentParent()) {
+    nsIFrame* kidContentParent;
+
+    kidFrame->GetContentParent(kidContentParent);
+    if (nextInFlow == kidContentParent) {
       kidFrame->SetContentParent(this);
     }
     if (nsnull == prevKidFrame) {
@@ -398,13 +423,16 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a
         // continuing frame. The creation appends it to the flow and
         // prepares it for reflow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to our sibling list and then push
@@ -432,7 +460,7 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
 
   // Update our last content offset
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -452,7 +480,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
       // the next-in-flows must be empty. Do a sanity check
       while (nsnull != nextInFlow) {
         NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
-        nextInFlow = (nsInlineFrame*)nextInFlow->GetNextInFlow();
+        nsIFrame* next;
+
+        nextInFlow->GetNextInFlow(next);
+        nextInFlow = (nsInlineFrame*)next;
       }
 #endif
     }
@@ -492,7 +523,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
     mFirstContentOffset = prev->NextChildOffset();
     if (!prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
   mLastContentIsComplete = PR_TRUE;
@@ -501,8 +532,9 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
   nsSize    kidMaxElementSize;
   nsSize*   pKidMaxElementSize = (nsnull != aState.maxElementSize) ? &kidMaxElementSize : nsnull;
   PRInt32   kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
 
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -558,7 +590,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
       }
       kidFrame->SetStyleContext(kidStyleContext);
     } else {
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
+      kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
     }
     NS_RELEASE(kid);
     NS_RELEASE(kidStyleContext);
@@ -606,7 +638,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
 
 done:;
   // Update the content mapping
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 #ifdef NS_DEBUG
   PRInt32 len = LengthOf(mFirstChild);
@@ -618,11 +650,11 @@ done:;
   return result;
 }
 
-nsIFrame::ReflowStatus
-nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                            nsReflowMetrics& aDesiredSize,
-                            const nsSize&    aMaxSize,
-                            nsSize*          aMaxElementSize)
+NS_METHOD nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                      nsReflowMetrics& aDesiredSize,
+                                      const nsSize&    aMaxSize,
+                                      nsSize*          aMaxElementSize,
+                                      ReflowStatus&    aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
@@ -630,7 +662,8 @@ nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
 //XXX not now  NS_PRECONDITION((aMaxSize.width > 0) && (aMaxSize.height > 0), "unexpected max size");
 
   PRBool        reflowMappedOK = PR_TRUE;
-  ReflowStatus  status = frComplete;
+
+  aStatus = frComplete;  // initialize out parameter
 
   // Get the style molecule
   nsStyleFont* styleFont =
@@ -651,7 +684,7 @@ nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
     reflowMappedOK = ReflowMappedChildren(aPresContext, state);
 
     if (PR_FALSE == reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -661,18 +694,18 @@ nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
     if (state.availSize.width <= 0) {
       // No space left. Don't try to pull-up children or reflow unmapped
       if (NextChildOffset() < mContent->ChildCount()) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (NextChildOffset() < mContent->ChildCount()) {
       // Try and pull-up some children from a next-in-flow
       if (PullUpChildren(aPresContext, state)) {
         // If we still have unmapped children then create some new frames
         if (NextChildOffset() < mContent->ChildCount()) {
-          status = ReflowUnmappedChildren(aPresContext, state);
+          aStatus = ReflowUnmappedChildren(aPresContext, state);
         }
       } else {
         // We were unable to pull-up all the existing frames from the next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
@@ -694,9 +727,9 @@ nsInlineFrame::ResizeReflow(nsIPresContext*  aPresContext,
   aDesiredSize.height = aDesiredSize.ascent + aDesiredSize.descent;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
-  return status;
+  return NS_OK;
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -717,8 +750,8 @@ PRIntn nsInlineFrame::GetSkipSides() const
 
 // Incremental reflow support
 
-void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
-                                     nsReflowMetrics& aMetrics)
+NS_METHOD nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
+                                          nsReflowMetrics& aMetrics)
 {
   nscoord maxAscent = 0;
   nscoord maxDescent = 0;
@@ -728,7 +761,7 @@ void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
     kid->GetReflowMetrics(aPresContext, kidMetrics);
     if (kidMetrics.ascent > maxAscent) maxAscent = kidMetrics.ascent;
     if (kidMetrics.descent > maxDescent) maxDescent = kidMetrics.descent;
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 
   // XXX what about border & padding
@@ -736,6 +769,8 @@ void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
   aMetrics.height = mRect.height;
   aMetrics.ascent = maxAscent;
   aMetrics.descent = maxDescent;
+
+  return NS_OK;
 }
 
 /**
@@ -765,7 +800,7 @@ PRIntn nsInlineFrame::RecoverState(nsIPresContext* aPresContext,
     // XXX Factor in left and right margins
     x += kidMetrics.width;
 
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
     i++;
   }
   aState.maxAscent = maxAscent;
@@ -774,13 +809,13 @@ PRIntn nsInlineFrame::RecoverState(nsIPresContext* aPresContext,
   return (nsnull == aSkipChild) ? 0 : i;
 }
 
-nsIFrame::ReflowStatus
-nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                                 nsReflowMetrics& aDesiredSize,
-                                 const nsSize&    aMaxSize,
-                                 nsReflowCommand& aReflowCommand)
+NS_METHOD nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                           nsReflowMetrics& aDesiredSize,
+                                           const nsSize&    aMaxSize,
+                                           nsReflowCommand& aReflowCommand,
+                                           ReflowStatus&    aStatus)
 {
-  ReflowStatus status = frComplete;
+  aStatus = frComplete;  // initialize out parameter
 
 #if 0
   if (aReflowCommand.GetTarget() == this) {
@@ -794,7 +829,7 @@ nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
       while (nsnull != flow->mNextInFlow) {
         flow = flow->mNextInFlow;
       }
-      status = flow->ReflowUnmappedChildren(...);
+      aStatus = flow->ReflowUnmappedChildren(...);
       break;
 
     case nsReflowCommand::rcContentInserted:
@@ -875,7 +910,7 @@ nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
 
     // Now pass reflow command down to our child to handle
     nsReflowMetrics kidMetrics;
-    status = aReflowCommand.Next(kidMetrics, aMaxSize, kid);
+    aStatus = aReflowCommand.Next(kidMetrics, aMaxSize, kid);
     // XXX what do we do when the nextInChain's completion status changes?
     // XXX if kid == LastChild() then mLastContentIsComplete needs updating
 
@@ -909,13 +944,13 @@ nsInlineFrame::IncrementalReflow(nsIPresContext*  aPresContext,
       // Update other children that are impacted by the change in
       // nextInChain. In addition, re-apply vertical alignment and
       // relative positioning to the children on the line.
-      status = AdjustChildren(aPresContext, aDesiredSize, aState, kid,
-                              kidMetrics, status);
+      aStatus = AdjustChildren(aPresContext, aDesiredSize, aState, kid,
+                               kidMetrics, aStatus);
     }
   }
 #endif
 
-  return status;
+  return NS_OK;
 }
 
 
@@ -961,7 +996,7 @@ nsInlineFrame::AdjustChildren(nsIPresContext* aPresContext,
     }
     x += r.width;
     // XXX factor in left and right margins
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 
   // Vertically align the children
@@ -981,25 +1016,19 @@ nsInlineFrame::AdjustChildren(nsIPresContext* aPresContext,
 // My container has new content at the end of it. Create frames for
 // the appended content and then generate an incremental reflow
 // command for ourselves.
-void nsInlineFrame::ContentAppended(nsIPresShell* aShell,
-                                    nsIPresContext* aPresContext,
-                                    nsIContent* aContainer)
+NS_METHOD nsInlineFrame::ContentAppended(nsIPresShell* aShell,
+                                         nsIPresContext* aPresContext,
+                                         nsIContent* aContainer)
 {
-  // Zip down to the end-of-flow
-  nsInlineFrame* flow = this;
-  for (;;) {
-    nsInlineFrame* next = (nsInlineFrame*) flow->GetNextInFlow();
-    if (nsnull == next) {
-      break;
-    }
-    flow = next;
-  }
+  // Get the last in flow
+  nsInlineFrame* flow = (nsInlineFrame*)GetLastInFlow();
 
   // Get index of where the content has been appended
   PRInt32 kidIndex = flow->NextChildOffset();
   PRInt32 startIndex = kidIndex;
-  nsIFrame* prevKidFrame = flow->LastChild();
+  nsIFrame* prevKidFrame;
 
+  flow->LastChild(prevKidFrame);
   // Create frames for each new child
   for (;;) {
     // Get the next content object
@@ -1027,4 +1056,5 @@ void nsInlineFrame::ContentAppended(nsIPresShell* aShell,
                           startIndex);
     aShell->AppendReflowCommand(rc);
   }
+  return NS_OK;
 }
diff --git a/mozilla/layout/html/base/src/nsLeafFrame.cpp b/mozilla/layout/html/base/src/nsLeafFrame.cpp
index 052f6bd8ea2..da502bfbe0c 100644
--- a/mozilla/layout/html/base/src/nsLeafFrame.cpp
+++ b/mozilla/layout/html/base/src/nsLeafFrame.cpp
@@ -33,9 +33,9 @@ nsLeafFrame::~nsLeafFrame()
 {
 }
 
-void nsLeafFrame::Paint(nsIPresContext& aPresContext,
-                        nsIRenderingContext& aRenderingContext,
-                        const nsRect& aDirtyRect)
+NS_METHOD nsLeafFrame::Paint(nsIPresContext& aPresContext,
+                             nsIRenderingContext& aRenderingContext,
+                             const nsRect& aDirtyRect)
 {
   nsStyleColor* myColor =
     (nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
@@ -45,13 +45,14 @@ void nsLeafFrame::Paint(nsIPresContext& aPresContext,
                                   aDirtyRect, mRect, *myColor);
   nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
                               aDirtyRect, mRect, *myMol, 0);
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
-                          nsReflowMetrics& aDesiredSize,
-                          const nsSize& aMaxSize,
-                          nsSize* aMaxElementSize)
+NS_METHOD nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                    nsReflowMetrics& aDesiredSize,
+                                    const nsSize& aMaxSize,
+                                    nsSize* aMaxElementSize,
+                                    ReflowStatus& aStatus)
 {
   // XXX add in code to check for width/height being set via css
   // and if set use them instead of calling GetDesiredSize.
@@ -62,14 +63,15 @@ nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
     aMaxElementSize->width = aDesiredSize.width;
     aMaxElementSize->height = aDesiredSize.height;
   }
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize& aMaxSize,
-                               nsReflowCommand& aReflowCommand)
+NS_METHOD nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
+                                         nsReflowMetrics& aDesiredSize,
+                                         const nsSize& aMaxSize,
+                                         nsReflowCommand& aReflowCommand,
+                                         ReflowStatus& aStatus)
 {
   // XXX Unless the reflow command is a style change, we should
   // just return the current size, otherwise we should invoke
@@ -80,7 +82,8 @@ nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
   GetDesiredSize(aPresContext, aDesiredSize, aMaxSize);
   AddBordersAndPadding(aPresContext, aDesiredSize);
 
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
 // XXX how should border&padding effect baseline alignment?
@@ -109,9 +112,11 @@ void nsLeafFrame::GetInnerArea(nsIPresContext* aPresContext,
     (mol->borderPadding.top + mol->borderPadding.bottom);
 }
 
-nsIFrame* nsLeafFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                             nsIFrame*       aParent)
+NS_METHOD nsLeafFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                             nsIFrame*       aParent,
+                                             nsIFrame*&      aContinuingFrame)
 {
   NS_NOTREACHED("Attempt to split the unsplittable");
-  return nsnull;
+  aContinuingFrame = nsnull;
+  return NS_OK;
 }
diff --git a/mozilla/layout/html/base/src/nsLeafFrame.h b/mozilla/layout/html/base/src/nsLeafFrame.h
index 6798e154a77..e979cc2aa06 100644
--- a/mozilla/layout/html/base/src/nsLeafFrame.h
+++ b/mozilla/layout/html/base/src/nsLeafFrame.h
@@ -28,22 +28,25 @@
  */
 class nsLeafFrame : public nsFrame {
 public:
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize& aMaxSize,
-                                    nsSize* aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize& aMaxSize,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
-                                         nsReflowMetrics& aDesiredSize,
-                                         const nsSize& aMaxSize,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize& aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus& aStatus);
 
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
 protected:
   nsLeafFrame(nsIContent* aContent,
diff --git a/mozilla/layout/html/base/src/nsListItemFrame.cpp b/mozilla/layout/html/base/src/nsListItemFrame.cpp
index 6ad8a813d54..0fd883d8785 100644
--- a/mozilla/layout/html/base/src/nsListItemFrame.cpp
+++ b/mozilla/layout/html/base/src/nsListItemFrame.cpp
@@ -54,19 +54,21 @@ public:
               nsIFrame* aParentFrame);
   virtual ~BulletFrame();
 
-  virtual void Paint(nsIPresContext &aCX,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext &aCX,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext* aCX,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize& aMaxSize,
-                                    nsSize* aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aCX,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize& aMaxSize,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext* aCX,
-                                         nsReflowMetrics& aDesiredSize,
-                                         const nsSize& aMaxSize,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext* aCX,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize& aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus& aStatus);
 
   void GetBulletSize(nsIPresContext* aCX,
                      nsReflowMetrics& aDesiredSize,
@@ -95,9 +97,9 @@ BulletFrame::~BulletFrame()
 // XXX padding for around the bullet; should come from style system
 #define PAD_DISC        NS_POINTS_TO_TWIPS_INT(1)
 
-void BulletFrame::Paint(nsIPresContext& aCX,
-                        nsIRenderingContext& aRenderingContext,
-                        const nsRect& aDirtyRect)
+NS_METHOD BulletFrame::Paint(nsIPresContext& aCX,
+                             nsIRenderingContext& aRenderingContext,
+                             const nsRect& aDirtyRect)
 {
   nsStyleFont* myFont =
     (nsStyleFont*)mStyleContext->GetData(kStyleFontSID);
@@ -135,13 +137,14 @@ void BulletFrame::Paint(nsIPresContext& aCX,
     break;
   }
   NS_RELEASE(fm);
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-BulletFrame::ResizeReflow(nsIPresContext* aCX,
-                          nsReflowMetrics& aDesiredSize,
-                          const nsSize& aMaxSize,
-                          nsSize* aMaxElementSize)
+NS_METHOD BulletFrame::ResizeReflow(nsIPresContext* aCX,
+                                    nsReflowMetrics& aDesiredSize,
+                                    const nsSize& aMaxSize,
+                                    nsSize* aMaxElementSize,
+                                    ReflowStatus& aStatus)
 {
   GetBulletSize(aCX, aDesiredSize, aMaxSize);
   if (nsnull != aMaxElementSize) {
@@ -154,22 +157,23 @@ BulletFrame::ResizeReflow(nsIPresContext* aCX,
   // the bullet must be mapping the second content object instead of
   // mapping the first content object.
   mLastContentIsComplete = PR_FALSE;
-
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-BulletFrame::IncrementalReflow(nsIPresContext* aCX,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize& aMaxSize,
-                               nsReflowCommand& aReflowCommand)
+NS_METHOD BulletFrame::IncrementalReflow(nsIPresContext* aCX,
+                                         nsReflowMetrics& aDesiredSize,
+                                         const nsSize& aMaxSize,
+                                         nsReflowCommand& aReflowCommand,
+                                         ReflowStatus& aStatus)
 {
   // XXX Unless the reflow command is a style change, we should
   // just return the current size, otherwise we should invoke
   // GetBulletSize
   GetBulletSize(aCX, aDesiredSize, aMaxSize);
 
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
 PRInt32 BulletFrame::GetListItemOrdinal(nsIPresContext* aCX,
@@ -522,7 +526,9 @@ nsListItemFrame::GetListContainerReflowState(nsIPresContext* aCX)
         // The parent is a block. See if its content object is a list
         // container. Only UL, OL, MENU or DIR can be list containers.
         // XXX need something more flexible, say style?
-        nsIContent* parentContent = parent->GetContent();
+        nsIContent* parentContent;
+         
+        parent->GetContent(parentContent);
         nsIAtom* tag = parentContent->GetTag();
         NS_RELEASE(parentContent);
         if ((tag == nsHTMLAtoms::ul) || (tag == nsHTMLAtoms::ol) ||
@@ -533,7 +539,7 @@ nsListItemFrame::GetListContainerReflowState(nsIPresContext* aCX)
         NS_RELEASE(tag);
       }
     }
-    parent = parent->GetGeometricParent();
+    parent->GetGeometricParent(parent);
   }
   if (nsnull != parent) {
     nsIPresShell* shell = aCX->GetShell();
@@ -550,12 +556,12 @@ nsListItemFrame::GetListContainerReflowState(nsIPresContext* aCX)
  */
 // XXX we may need to grow to accomodate the bullet
 // XXX check for compatability: <LI><H1>dah dah</H1> where is bullet?
-nsIFrame::ReflowStatus
-nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
-                              nsISpaceManager* aSpaceManager,
-                              const nsSize& aMaxSize,
-                              nsRect& aDesiredRect,
-                              nsSize* aMaxElementSize)
+NS_METHOD nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
+                                        nsISpaceManager* aSpaceManager,
+                                        const nsSize& aMaxSize,
+                                        nsRect& aDesiredRect,
+                                        nsSize* aMaxElementSize,
+                                        ReflowStatus& aStatus)
 {
   PRBool insideBullet = PR_FALSE;
 
@@ -586,7 +592,7 @@ nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
       } else {
         // Pull bullet off list (we'll put it back later)
         bullet = mFirstChild;
-        mFirstChild = bullet->GetNextSibling();
+        bullet->GetNextSibling(mFirstChild);
         mChildCount--;
       }
     }
@@ -596,7 +602,7 @@ nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
   nsBlockReflowState state;
   SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
   state.firstChildIsInsideBullet = insideBullet;
-  ReflowStatus rv = DoResizeReflow(aCX, state, aDesiredRect);
+  DoResizeReflow(aCX, state, aDesiredRect, aStatus);
 
   // Now place the bullet and put it at the head of the list of children
   if (!insideBullet && (nsnull != bullet)) {
@@ -616,26 +622,29 @@ nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
       mLines[0]++;
     }
   }
-  return rv;
+  return NS_OK;
 }
 
 // XXX we may need to grow to accomodate the bullet
-nsIFrame::ReflowStatus
-nsListItemFrame::IncrementalReflow(nsIPresContext* aCX,
-                                   nsISpaceManager* aSpaceManager,
-                                   const nsSize& aMaxSize,
-                                   nsRect& aDesiredRect,
-                                   nsReflowCommand& aReflowCommand)
+NS_METHOD nsListItemFrame::IncrementalReflow(nsIPresContext* aCX,
+                                             nsISpaceManager* aSpaceManager,
+                                             const nsSize& aMaxSize,
+                                             nsRect& aDesiredRect,
+                                             nsReflowCommand& aReflowCommand,
+                                             ReflowStatus& aStatus)
 {
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame* nsListItemFrame::CreateContinuingFrame(nsIPresContext* aCX,
-                                                 nsIFrame* aParent)
+NS_METHOD nsListItemFrame::CreateContinuingFrame(nsIPresContext* aCX,
+                                                 nsIFrame* aParent,
+                                                 nsIFrame*& aContinuingFrame)
 {
   nsListItemFrame* cf = new nsListItemFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aCX, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 // aDirtyRect is in our coordinate system
@@ -646,7 +655,9 @@ void nsListItemFrame::PaintChildren(nsIPresContext& aCX,
 {
   nsIFrame* kid = mFirstChild;
   while (nsnull != kid) {
-    nsIView *pView = kid->GetView();
+    nsIView *pView;
+     
+    kid->GetView(pView);
     if (nsnull == pView) {
       nsRect kidRect;
       kid->GetRect(kidRect);
@@ -668,9 +679,9 @@ void nsListItemFrame::PaintChildren(nsIPresContext& aCX,
         }
         aRenderingContext.PopState();
       }
-    }
-    else
+    } else {
       NS_RELEASE(pView);
-    kid = kid->GetNextSibling();
+    }
+    kid->GetNextSibling(kid);
   }
 }
diff --git a/mozilla/layout/html/base/src/nsListItemFrame.h b/mozilla/layout/html/base/src/nsListItemFrame.h
index 7da487cfcf5..c0369ecda63 100644
--- a/mozilla/layout/html/base/src/nsListItemFrame.h
+++ b/mozilla/layout/html/base/src/nsListItemFrame.h
@@ -28,20 +28,23 @@ public:
                            PRInt32     aIndexInParent,
                            nsIFrame*   aParent);
 
-  virtual ReflowStatus  ResizeReflow(nsIPresContext* aCX,
-                                     nsISpaceManager* aSpaceManager,
-                                     const nsSize& aMaxSize,
-                                     nsRect& aDesiredRect,
-                                     nsSize* aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aCX,
+                          nsISpaceManager* aSpaceManager,
+                          const nsSize& aMaxSize,
+                          nsRect& aDesiredRect,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
 
-  virtual ReflowStatus  IncrementalReflow(nsIPresContext* aCX,
-                                          nsISpaceManager* aSpaceManager,
-                                          const nsSize& aMaxSize,
-                                          nsRect& aDesiredRect,
-                                          nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext* aCX,
+                               nsISpaceManager* aSpaceManager,
+                               const nsSize& aMaxSize,
+                               nsRect& aDesiredRect,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus& aStatus);
 
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aCX,
-                                          nsIFrame* aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aCX,
+                                   nsIFrame* aParent,
+                                   nsIFrame*& aContinuingFrame);
 
   /**
    * Return the reflow state for the list container that contains this
diff --git a/mozilla/layout/html/base/src/nsPageFrame.cpp b/mozilla/layout/html/base/src/nsPageFrame.cpp
index 858422d7f5c..7da6ddc801b 100644
--- a/mozilla/layout/html/base/src/nsPageFrame.cpp
+++ b/mozilla/layout/html/base/src/nsPageFrame.cpp
@@ -23,8 +23,8 @@
 #include "nsReflowCommand.h"
 #include "nsIRenderingContext.h"
 
-PageFrame::PageFrame(nsIContent* aContent, nsIFrame* aParent)
-  : nsContainerFrame(aContent, aParent->GetIndexInParent(), aParent)
+PageFrame::PageFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent)
+  : nsContainerFrame(aContent, aIndexInParent, aParent)
 {
 }
 
@@ -56,16 +56,16 @@ void PageFrame::CreateFirstChild(nsIPresContext* aPresContext)
   }
 }
 
-nsIFrame::ReflowStatus
-PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                        nsReflowMetrics& aDesiredSize,
-                        const nsSize&    aMaxSize,
-                        nsSize*          aMaxElementSize)
+NS_METHOD PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                  nsReflowMetrics& aDesiredSize,
+                                  const nsSize&    aMaxSize,
+                                  nsSize*          aMaxElementSize,
+                                  ReflowStatus&    aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
 #endif
-  ReflowStatus  result = frComplete;
+  aStatus = frComplete;  // initialize out parameter
 
   // Do we have any children?
   if (nsnull == mFirstChild) {
@@ -76,10 +76,11 @@ PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
       PageFrame*  prevPage = (PageFrame*)mPrevInFlow;
 
       NS_ASSERTION(!prevPage->mLastContentIsComplete, "bad continuing page");
-      nsIFrame* prevLastChild = prevPage->LastChild();
+      nsIFrame* prevLastChild;
+      prevPage->LastChild(prevLastChild);
 
       // Create a continuing child of the previous page's last child
-      mFirstChild = prevLastChild->CreateContinuingFrame(aPresContext, this);
+      prevLastChild->CreateContinuingFrame(aPresContext, this, mFirstChild);
       mChildCount = 1;
       mLastContentOffset = mFirstContentOffset;
     }
@@ -89,9 +90,9 @@ PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
   // XXX Pay attention to the page's border and padding...
   if (nsnull != mFirstChild) {
     // Get the child's desired size
-    result = ReflowChild(mFirstChild, aPresContext, aDesiredSize, aMaxSize,
-                         aMaxElementSize);
-    mLastContentIsComplete = PRBool(result == frComplete);
+    aStatus = ReflowChild(mFirstChild, aPresContext, aDesiredSize, aMaxSize,
+                          aMaxElementSize);
+    mLastContentIsComplete = PRBool(aStatus == frComplete);
 
     // Make sure the child is at least as tall as our max size (the containing window)
     if (aDesiredSize.height < aMaxSize.height) {
@@ -103,8 +104,11 @@ PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
     mFirstChild->SetRect(rect);
 
     // Is the frame complete?
-    if (frComplete == result) {
-      NS_ASSERTION(nsnull == mFirstChild->GetNextInFlow(), "bad child flow list");
+    if (frComplete == aStatus) {
+      nsIFrame* childNextInFlow;
+
+      mFirstChild->GetNextInFlow(childNextInFlow);
+      NS_ASSERTION(nsnull == childNextInFlow, "bad child flow list");
     }
   }
 
@@ -113,28 +117,27 @@ PageFrame::ResizeReflow(nsIPresContext*  aPresContext,
   aDesiredSize.height = aMaxSize.height;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(result);
+  PostReflowCheck(aStatus);
 #endif
-  return result;
+  return NS_OK;
 }
 
 // XXX Do something sensible in page mode...
-nsIFrame::ReflowStatus
-PageFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&    aMaxSize,
-                             nsReflowCommand& aReflowCommand)
+NS_METHOD PageFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                       nsReflowMetrics& aDesiredSize,
+                                       const nsSize&    aMaxSize,
+                                       nsReflowCommand& aReflowCommand,
+                                       ReflowStatus&    aStatus)
 {
   // We don't expect the target of the reflow command to be page frame
   NS_ASSERTION(aReflowCommand.GetTarget() != this, "page frame is reflow command target");
 
   nsSize        maxSize(aMaxSize.width, NS_UNCONSTRAINEDSIZE);
-  ReflowStatus  status;
   nsIFrame*     child;
 
   // Dispatch the reflow command to our pseudo frame. Allow it to be as high
   // as it wants
-  status = aReflowCommand.Next(aDesiredSize, maxSize, child);
+  aStatus = aReflowCommand.Next(aDesiredSize, maxSize, child);
 
   // Place and size the child. Make sure the child is at least as
   // tall as our max size (the containing window)
@@ -148,20 +151,22 @@ PageFrame::IncrementalReflow(nsIPresContext*  aPresContext,
     child->SetRect(rect);
   }
 
-  return status;
+  return NS_OK;
 }
 
-nsIFrame* PageFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                           nsIFrame*       aParent)
+NS_METHOD PageFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                           nsIFrame*       aParent,
+                                           nsIFrame*&      aContinuingFrame)
 {
-  PageFrame* cf = new PageFrame(mContent, aParent);
+  PageFrame* cf = new PageFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
-void PageFrame::Paint(nsIPresContext&      aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect&        aDirtyRect)
+NS_METHOD PageFrame::Paint(nsIPresContext&      aPresContext,
+                           nsIRenderingContext& aRenderingContext,
+                           const nsRect&        aDirtyRect)
 {
   nsContainerFrame::Paint(aPresContext, aRenderingContext, aDirtyRect);
 
@@ -169,10 +174,12 @@ void PageFrame::Paint(nsIPresContext&      aPresContext,
   // where each page begins and ends
   aRenderingContext.SetColor(NS_RGB(0, 0, 0));
   aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
+  return NS_OK;
 }
 
-void PageFrame::ListTag(FILE* out) const
+NS_METHOD PageFrame::ListTag(FILE* out) const
 {
   fprintf(out, "*PAGE@%p", this);
+  return NS_OK;
 }
 
diff --git a/mozilla/layout/html/base/src/nsPageFrame.h b/mozilla/layout/html/base/src/nsPageFrame.h
index b3d8387c8f5..aaee82d3952 100644
--- a/mozilla/layout/html/base/src/nsPageFrame.h
+++ b/mozilla/layout/html/base/src/nsPageFrame.h
@@ -23,27 +23,30 @@
 // Pseudo frame created by the root content frame
 class PageFrame : public nsContainerFrame {
 public:
-  PageFrame(nsIContent* aContent, nsIFrame* aParent);
+  PageFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext*  aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize&    aMaxSize,
-                                    nsSize*          aMaxElementSize);
+  NS_IMETHOD  ResizeReflow(nsIPresContext*  aPresContext,
+                           nsReflowMetrics& aDesiredSize,
+                           const nsSize&    aMaxSize,
+                           nsSize*          aMaxElementSize,
+                           ReflowStatus&    aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext*  aPresContext,
-                                         nsReflowMetrics& aDesiredSize,
-                                         const nsSize&    aMaxSize,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD  IncrementalReflow(nsIPresContext*  aPresContext,
+                                nsReflowMetrics& aDesiredSize,
+                                const nsSize&    aMaxSize,
+                                nsReflowCommand& aReflowCommand,
+                                ReflowStatus&    aStatus);
 
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame* aParent);
+  NS_IMETHOD  CreateContinuingFrame(nsIPresContext* aPresContext,
+                                    nsIFrame*       aParent,
+                                    nsIFrame*&      aContinuingFrame);
 
-  virtual void          Paint(nsIPresContext&      aPresContext,
-                              nsIRenderingContext& aRenderingContext,
-                              const nsRect&        aDirtyRect);
+  NS_IMETHOD  Paint(nsIPresContext&      aPresContext,
+                    nsIRenderingContext& aRenderingContext,
+                    const nsRect&        aDirtyRect);
 
   // Debugging
-  virtual void  ListTag(FILE* out = stdout) const;
+  NS_IMETHOD  ListTag(FILE* out = stdout) const;
 
 protected:
   void CreateFirstChild(nsIPresContext* aPresContext);
diff --git a/mozilla/layout/html/base/src/nsPlaceholderFrame.cpp b/mozilla/layout/html/base/src/nsPlaceholderFrame.cpp
index 1028f477461..902c2f2603f 100644
--- a/mozilla/layout/html/base/src/nsPlaceholderFrame.cpp
+++ b/mozilla/layout/html/base/src/nsPlaceholderFrame.cpp
@@ -52,16 +52,16 @@ PlaceholderFrame::~PlaceholderFrame()
 {
 }
 
-nsIFrame::ReflowStatus
-PlaceholderFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize&    aMaxSize,
-                               nsSize*          aMaxElementSize)
+NS_METHOD PlaceholderFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                         nsReflowMetrics& aDesiredSize,
+                                         const nsSize&    aMaxSize,
+                                         nsSize*          aMaxElementSize,
+                                         ReflowStatus&    aStatus)
 {
   // Get the floater container in which we're inserted
   nsIFloaterContainer*  container = nsnull;
 
-  for (nsIFrame* parent = mGeometricParent; parent; parent = parent->GetGeometricParent()) {
+  for (nsIFrame* parent = mGeometricParent; parent; parent->GetGeometricParent(parent)) {
     if (NS_OK == parent->QueryInterface(kIFloaterContainerIID, (void**)&container)) {
       break;
     }
@@ -82,7 +82,7 @@ PlaceholderFrame::ResizeReflow(nsIPresContext*  aPresContext,
 
     // Resize reflow the anchored item into the available space
     // XXX Check for complete?
-    mAnchoredItem->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
+    mAnchoredItem->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
     mAnchoredItem->SizeTo(aDesiredSize.width, aDesiredSize.height);
 
     // Now notify our containing block that there's a new floater
@@ -91,11 +91,12 @@ PlaceholderFrame::ResizeReflow(nsIPresContext*  aPresContext,
     container->PlaceFloater(aPresContext, mAnchoredItem, this);
   }
 
-  return nsFrame::ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize);
+  return nsFrame::ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, aStatus);
 }
 
-void PlaceholderFrame::ListTag(FILE* out) const
+NS_METHOD PlaceholderFrame::ListTag(FILE* out) const
 {
   fputs("*placeholder", out);
   fprintf(out, "(%d)@%p", mIndexInParent, this);
+  return NS_OK;
 }
diff --git a/mozilla/layout/html/base/src/nsPlaceholderFrame.h b/mozilla/layout/html/base/src/nsPlaceholderFrame.h
index b3b87673539..6cae7e1c546 100644
--- a/mozilla/layout/html/base/src/nsPlaceholderFrame.h
+++ b/mozilla/layout/html/base/src/nsPlaceholderFrame.h
@@ -36,11 +36,12 @@ public:
   nsIFrame*   GetAnchoredItem() const {return mAnchoredItem;}
 
   // Resize reflow methods
-  virtual ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                                     nsReflowMetrics& aDesiredSize,
-                                     const nsSize&    aMaxSize,
-                                     nsSize*          aMaxElementSize);
-  virtual void          ListTag(FILE* out = stdout) const;
+  NS_IMETHOD  ResizeReflow(nsIPresContext*  aPresContext,
+                           nsReflowMetrics& aDesiredSize,
+                           const nsSize&    aMaxSize,
+                           nsSize*          aMaxElementSize,
+                           ReflowStatus&    aStatus);
+  NS_IMETHOD  ListTag(FILE* out = stdout) const;
 
 protected:
   // Constructor. Takes as arguments the content object, the index in parent,
diff --git a/mozilla/layout/html/base/src/nsRootPart.cpp b/mozilla/layout/html/base/src/nsRootPart.cpp
index 955fb98cef9..55d1b4ab2f6 100644
--- a/mozilla/layout/html/base/src/nsRootPart.cpp
+++ b/mozilla/layout/html/base/src/nsRootPart.cpp
@@ -39,38 +39,43 @@ class RootFrame : public nsContainerFrame {
 public:
   RootFrame(nsIContent* aContent);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext*  aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize&    aMaxSize,
-                                    nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&    aMaxSize,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext*  aPresContext,
-                                         nsReflowMetrics& aDesiredSize,
-                                         const nsSize&    aMaxSize,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
-  virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext, 
-                             nsGUIEvent*     aEvent);
+  NS_IMETHOD HandleEvent(nsIPresContext& aPresContext, 
+                         nsGUIEvent*     aEvent,
+                         nsEventStatus&  aEventStatus);
 };
 
 // Pseudo frame created by the root frame
 class RootContentFrame : public nsContainerFrame {
 public:
-  RootContentFrame(nsIContent* aContent, nsIFrame* aParent);
+  RootContentFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext*  aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize&    aMaxSize,
-                                    nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&    aMaxSize,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
-  virtual ReflowStatus IncrementalReflow(nsIPresContext*  aPresContext,
-                                         nsReflowMetrics& aDesiredSize,
-                                         const nsSize&    aMaxSize,
-                                         nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
-  virtual void Paint(nsIPresContext&      aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect&        aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext&      aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect&        aDirtyRect);
 
 protected:
   void CreateFirstChild(nsIPresContext* aPresContext);
@@ -83,20 +88,21 @@ RootFrame::RootFrame(nsIContent* aContent)
 {
 }
 
-nsIFrame::ReflowStatus RootFrame::ResizeReflow(nsIPresContext* aPresContext,
-                                               nsReflowMetrics& aDesiredSize,
-                                               const nsSize& aMaxSize,
-                                               nsSize* aMaxElementSize)
+NS_METHOD RootFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                  nsReflowMetrics& aDesiredSize,
+                                  const nsSize& aMaxSize,
+                                  nsSize* aMaxElementSize,
+                                  ReflowStatus& aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
 #endif
-  nsIFrame::ReflowStatus  result = frComplete;
+  aStatus = frComplete;
 
   // Do we have any children?
   if (nsnull == mFirstChild) {
     // No. Create a pseudo frame
-    mFirstChild = new RootContentFrame(mContent, this);
+    mFirstChild = new RootContentFrame(mContent, mIndexInParent, this);
     mChildCount = 1;
     nsIStyleContext* style = aPresContext->ResolveStyleContextFor(mContent, this);
     mFirstChild->SetStyleContext(style);
@@ -107,7 +113,8 @@ nsIFrame::ReflowStatus RootFrame::ResizeReflow(nsIPresContext* aPresContext,
   // height its child frame wants...
   if (nsnull != mFirstChild) {
     nsReflowMetrics  desiredSize;
-    result = ReflowChild(mFirstChild, aPresContext, desiredSize, aMaxSize,
+
+    aStatus = ReflowChild(mFirstChild, aPresContext, desiredSize, aMaxSize,
                          aMaxElementSize);
 
     // Place and size the child
@@ -123,26 +130,25 @@ nsIFrame::ReflowStatus RootFrame::ResizeReflow(nsIPresContext* aPresContext,
   aDesiredSize.descent = 0;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(result);
+  PostReflowCheck(aStatus);
 #endif
-  return result;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-RootFrame::IncrementalReflow(nsIPresContext* aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize& aMaxSize,
-                             nsReflowCommand& aReflowCommand)
+NS_METHOD RootFrame::IncrementalReflow(nsIPresContext* aPresContext,
+                                       nsReflowMetrics& aDesiredSize,
+                                       const nsSize& aMaxSize,
+                                       nsReflowCommand& aReflowCommand,
+                                       ReflowStatus& aStatus)
 {
   // We don't expect the target of the reflow command to be the root frame
   NS_ASSERTION(aReflowCommand.GetTarget() != this, "root frame is reflow command target");
 
   nsReflowMetrics  desiredSize;
   nsIFrame*        child;
-  ReflowStatus     status;
 
   // Dispatch the reflow command to our pseudo frame
-  status = aReflowCommand.Next(desiredSize, aMaxSize, child);
+  aStatus = aReflowCommand.Next(desiredSize, aMaxSize, child);
 
   // Place and size the child
   if (nsnull != child) {
@@ -157,18 +163,21 @@ RootFrame::IncrementalReflow(nsIPresContext* aPresContext,
   aDesiredSize.height = aMaxSize.height;
   aDesiredSize.ascent = aMaxSize.height;
   aDesiredSize.descent = 0;
-  return status;
+  return NS_OK;
 }
 
-nsEventStatus RootFrame::HandleEvent(nsIPresContext& aPresContext, 
-                              nsGUIEvent*     aEvent)
+NS_METHOD RootFrame::HandleEvent(nsIPresContext& aPresContext, 
+                                 nsGUIEvent* aEvent,
+                                 nsEventStatus& aEventStatus)
 {
   switch (aEvent->message) {
   case NS_MOUSE_MOVE:
   case NS_MOUSE_ENTER:
     {
       nsIFrame* target = this;
-      PRInt32 cursor = GetCursorAt(aPresContext, aEvent->point, &target);
+      PRInt32 cursor;
+       
+      GetCursorAt(aPresContext, aEvent->point, &target, cursor);
       if (cursor == NS_STYLE_CURSOR_INHERIT) {
         cursor = NS_STYLE_CURSOR_DEFAULT;
       }
@@ -185,26 +194,33 @@ nsEventStatus RootFrame::HandleEvent(nsIPresContext& aPresContext,
         c = eCursor_select;
         break;
       }
-      nsIWidget* window = target->GetWindow();
+      nsIWidget* window;
+      target->GetWindow(window);
       window->SetCursor(c);
     }
     break;
   }
 
-  return nsEventStatus_eIgnore;
+  aEventStatus = nsEventStatus_eIgnore;
+  return NS_OK;
 }
 
 //----------------------------------------------------------------------
 
-RootContentFrame::RootContentFrame(nsIContent* aContent, nsIFrame* aParent)
-  : nsContainerFrame(aContent, aParent->GetIndexInParent(), aParent)
+RootContentFrame::RootContentFrame(nsIContent* aContent,
+                                   PRInt32 aIndexInParent,
+                                   nsIFrame* aParent)
+  : nsContainerFrame(aContent, aIndexInParent, aParent)
 {
   // Create a view
-  nsIFrame* parent = GetParentWithView();
+  nsIFrame* parent;
   nsIView*  view;
 
+  GetParentWithView(parent);
   NS_ASSERTION(parent, "GetParentWithView failed");
-  nsIView* parView = parent->GetView(); 
+  nsIView* parView;
+   
+  parent->GetView(parView);
   NS_ASSERTION(parView, "no parent with view");
 
   // Create a view
@@ -222,7 +238,7 @@ RootContentFrame::RootContentFrame(nsIContent* aContent, nsIFrame* aParent)
     // Initialize the view
     NS_ASSERTION(nsnull != viewManager, "null view manager");
 
-    view->Init(viewManager, GetRect(), rootView);
+    view->Init(viewManager, mRect, rootView);
     viewManager->InsertChild(rootView, view, 0);
 
     NS_RELEASE(viewManager);
@@ -239,7 +255,7 @@ void RootContentFrame::CreateFirstChild(nsIPresContext* aPresContext)
   // Are we paginated?
   if (aPresContext->IsPaginated()) {
     // Yes. Create the first page frame
-    mFirstChild = new PageFrame(mContent, this);
+    mFirstChild = new PageFrame(mContent, mIndexInParent, this);
     mChildCount = 1;
     mLastContentOffset = mFirstContentOffset;
 
@@ -274,16 +290,16 @@ void RootContentFrame::CreateFirstChild(nsIPresContext* aPresContext)
 // XXX Hack
 #define PAGE_SPACING 100
 
-nsIFrame::ReflowStatus
-RootContentFrame::ResizeReflow(nsIPresContext*  aPresContext,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize&    aMaxSize,
-                               nsSize*          aMaxElementSize)
+NS_METHOD RootContentFrame::ResizeReflow(nsIPresContext*  aPresContext,
+                                         nsReflowMetrics& aDesiredSize,
+                                         const nsSize&    aMaxSize,
+                                         nsSize*          aMaxElementSize,
+                                         ReflowStatus&    aStatus)
 {
 #ifdef NS_DEBUG
   PreReflowCheck();
 #endif
-  nsIFrame::ReflowStatus  result = frComplete;
+  aStatus = frComplete;
 
   // Do we have any children?
   if (nsnull == mFirstChild) {
@@ -317,23 +333,31 @@ RootContentFrame::ResizeReflow(nsIPresContext*  aPresContext,
         y += PAGE_SPACING;
 
         // Is the page complete?
-        nsIFrame* nextInFlow = kidFrame->GetNextInFlow();
-
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         if (frComplete == status) {
-          NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
-        } else if (nsnull == nextInFlow) {
+          NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
+        } else if (nsnull == kidNextInFlow) {
           // The page isn't complete and it doesn't have a next-in-flow so
           // create a continuing page
-          nsIFrame*  continuingPage = kidFrame->CreateContinuingFrame(aPresContext, this);
+          nsIFrame*  continuingPage;
+           
+          kidFrame->CreateContinuingFrame(aPresContext, this, continuingPage);
 
           // Add it to our child list
-          NS_ASSERTION(nsnull == kidFrame->GetNextSibling(), "unexpected sibling");
+#ifdef NS_DEBUG
+          nsIFrame* kidNextSibling;
+
+          kidFrame->GetNextSibling(kidNextSibling);
+          NS_ASSERTION(nsnull == kidNextSibling, "unexpected sibling");
+#endif
           kidFrame->SetNextSibling(continuingPage);
           mChildCount++;
         }
 
         // Get the next page
-        kidFrame = kidFrame->GetNextSibling();
+        kidFrame->GetNextSibling(kidFrame);
       }
 
       // Return our desired size
@@ -347,9 +371,9 @@ RootContentFrame::ResizeReflow(nsIPresContext*  aPresContext,
 
       // Get the child's desired size. Our child's desired height is our
       // desired size
-      result = ReflowChild(mFirstChild, aPresContext, aDesiredSize, maxSize,
-                           aMaxElementSize);
-      NS_ASSERTION(frComplete == result, "bad status");
+      aStatus = ReflowChild(mFirstChild, aPresContext, aDesiredSize, maxSize,
+                            aMaxElementSize);
+      NS_ASSERTION(frComplete == aStatus, "bad status");
 
       // Place and size the child. Make sure the child is at least as
       // tall as our max size (the containing window)
@@ -364,29 +388,28 @@ RootContentFrame::ResizeReflow(nsIPresContext*  aPresContext,
   }
 
 #ifdef NS_DEBUG
-  PostReflowCheck(result);
+  PostReflowCheck(aStatus);
 #endif
-  return result;
+  return NS_OK;
 }
 
 // XXX Do something sensible for page mode...
-nsIFrame::ReflowStatus
-RootContentFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize&    aMaxSize,
-                                    nsReflowCommand& aReflowCommand)
+NS_METHOD RootContentFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                              nsReflowMetrics& aDesiredSize,
+                                              const nsSize&    aMaxSize,
+                                              nsReflowCommand& aReflowCommand,
+                                              ReflowStatus&    aStatus)
 {
   // We don't expect the target of the reflow command to be the root
   // content frame
   NS_ASSERTION(aReflowCommand.GetTarget() != this, "root content frame is reflow command target");
 
   nsSize        maxSize(aMaxSize.width, NS_UNCONSTRAINEDSIZE);
-  ReflowStatus  status;
   nsIFrame*     child;
 
   // Dispatch the reflow command to our pseudo frame. Allow it to be as high
   // as it wants
-  status = aReflowCommand.Next(aDesiredSize, maxSize, child);
+  aStatus = aReflowCommand.Next(aDesiredSize, maxSize, child);
 
   // Place and size the child. Make sure the child is at least as
   // tall as our max size (the containing window)
@@ -400,12 +423,12 @@ RootContentFrame::IncrementalReflow(nsIPresContext*  aPresContext,
     child->SetRect(rect);
   }
 
-  return status;
+  return NS_OK;
 }
 
-void RootContentFrame::Paint(nsIPresContext&      aPresContext,
-                             nsIRenderingContext& aRenderingContext,
-                             const nsRect&        aDirtyRect)
+NS_METHOD RootContentFrame::Paint(nsIPresContext&      aPresContext,
+                                  nsIRenderingContext& aRenderingContext,
+                                  const nsRect&        aDirtyRect)
 {
   // If we're paginated then fill the dirty rect with white
   if (aPresContext.IsPaginated()) {
@@ -415,6 +438,7 @@ void RootContentFrame::Paint(nsIPresContext&      aPresContext,
   }
 
   nsContainerFrame::Paint(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 //----------------------------------------------------------------------
diff --git a/mozilla/layout/html/base/src/nsSpacerPart.cpp b/mozilla/layout/html/base/src/nsSpacerPart.cpp
index 00ae544c90e..6cd6152b1e1 100644
--- a/mozilla/layout/html/base/src/nsSpacerPart.cpp
+++ b/mozilla/layout/html/base/src/nsSpacerPart.cpp
@@ -100,7 +100,7 @@ SpacerFrame::ResizeReflow(nsIPresContext* aPresContext,
         break;
       }
     }
-    parent = parent->GetGeometricParent();
+    parent->GetGeometricParent(parent);
   }
   if (nsnull != parent) {
     nsIPresShell* shell = aPresContext->GetShell();
diff --git a/mozilla/layout/html/base/src/nsTextContent.cpp b/mozilla/layout/html/base/src/nsTextContent.cpp
index 1c159858264..68b809cce15 100644
--- a/mozilla/layout/html/base/src/nsTextContent.cpp
+++ b/mozilla/layout/html/base/src/nsTextContent.cpp
@@ -110,26 +110,28 @@ public:
             PRInt32 aIndexInParent,
             nsIFrame* aParentFrame);
 
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  virtual ReflowStatus ResizeReflow(nsIPresContext* aCX,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize& aMaxSize,
-                                    nsSize* aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aCX,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize& aMaxSize,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
 
-  virtual void GetReflowMetrics(nsIPresContext*  aPresContext,
-                                nsReflowMetrics& aMetrics);
+  NS_IMETHOD GetReflowMetrics(nsIPresContext*  aPresContext,
+                              nsReflowMetrics& aMetrics);
 
-  virtual void JustifyReflow(nsIPresContext* aCX,
-                             nscoord aAvailableSpace);
+  NS_IMETHOD JustifyReflow(nsIPresContext* aCX,
+                           nscoord aAvailableSpace);
 
-  virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
-                              const nsPoint& aPoint,
-                              nsIFrame** aFrame);
+  NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
+                         const nsPoint& aPoint,
+                         nsIFrame** aFrame,
+                         PRInt32& aCursor);
 
-  virtual void List(FILE* out, PRInt32 aIndent) const;
+  NS_IMETHOD List(FILE* out, PRInt32 aIndent) const;
 
 protected:
   virtual ~TextFrame();
@@ -340,7 +342,8 @@ void TextTimer::Notify(nsITimer *timer)
     nsPoint offset;
     nsRect bounds;
     text->GetRect(bounds);
-    nsIView* view = text->GetOffsetFromView(offset);
+    nsIView* view;
+    text->GetOffsetFromView(offset, view);
     nsIViewManager* vm = view->GetViewManager();
     bounds.x = offset.x;
     bounds.y = offset.y;
@@ -379,9 +382,10 @@ TextFrame::~TextFrame()
   }
 }
 
-PRInt32 TextFrame::GetCursorAt(nsIPresContext& aPresContext,
-                               const nsPoint& aPoint,
-                               nsIFrame** aFrame)
+NS_METHOD TextFrame::GetCursorAt(nsIPresContext& aPresContext,
+                                 const nsPoint& aPoint,
+                                 nsIFrame** aFrame,
+                                 PRInt32& aCursor)
 {
   nsStyleMolecule* mol = (nsStyleMolecule*)
     mStyleContext->GetData(kStyleMoleculeSID);
@@ -390,18 +394,19 @@ PRInt32 TextFrame::GetCursorAt(nsIPresContext& aPresContext,
     // let the child decide.
     *aFrame = this;
   }
-  return (PRInt32) mol->cursor;
+  aCursor = (PRInt32) mol->cursor;
+  return NS_OK;
 }
 
 // XXX it would be nice to use a method pointer here, but I don't want
 // to pay for the storage.
 
-void TextFrame::Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect)
+NS_METHOD TextFrame::Paint(nsIPresContext& aPresContext,
+                           nsIRenderingContext& aRenderingContext,
+                           const nsRect& aDirtyRect)
 {
   if ((0 != (mFlags & TEXT_BLINK_ON)) && gBlinkTextOff) {
-    return;
+    return NS_OK;
   }
 
   // Get style data
@@ -421,7 +426,7 @@ void TextFrame::Paint(nsIPresContext& aPresContext,
       aRenderingContext.SetColor(color->mBackgroundColor);
       PaintJustifiedText(aRenderingContext, aDirtyRect, onePixel, onePixel);
     }
-    return;
+    return NS_OK;
   }
   PaintRegularText(aRenderingContext, aDirtyRect, 0, 0);
   if (font->mThreeD) {
@@ -429,6 +434,8 @@ void TextFrame::Paint(nsIPresContext& aPresContext,
     aRenderingContext.SetColor(color->mBackgroundColor);
     PaintRegularText(aRenderingContext, aDirtyRect, onePixel, onePixel);
   }
+
+  return NS_OK;
 }
 
 void TextFrame::PaintRegularText(nsIRenderingContext& aRenderingContext,
@@ -619,8 +626,8 @@ void TextFrame::PaintJustifiedText(nsIRenderingContext& aRenderingContext,
   }
 }
 
-void TextFrame::GetReflowMetrics(nsIPresContext* aCX,
-                                 nsReflowMetrics& aMetrics)
+NS_METHOD TextFrame::GetReflowMetrics(nsIPresContext* aCX,
+                                      nsReflowMetrics& aMetrics)
 {
   aMetrics.width = mRect.width;
   aMetrics.height = mRect.height;
@@ -631,13 +638,14 @@ void TextFrame::GetReflowMetrics(nsIPresContext* aCX,
   aMetrics.ascent = fm->GetMaxAscent();
   aMetrics.descent = fm->GetMaxDescent();
   NS_RELEASE(fm);
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-TextFrame::ResizeReflow(nsIPresContext* aCX,
-                        nsReflowMetrics& aDesiredSize,
-                        const nsSize& aMaxSize,
-                        nsSize* aMaxElementSize)
+NS_METHOD TextFrame::ResizeReflow(nsIPresContext* aCX,
+                                  nsReflowMetrics& aDesiredSize,
+                                  const nsSize& aMaxSize,
+                                  nsSize* aMaxElementSize,
+                                  ReflowStatus& aStatus)
 {
 #ifdef NOISY
   ListTag(stdout);
@@ -674,7 +682,7 @@ TextFrame::ResizeReflow(nsIPresContext* aCX,
         break;
       }
     }
-    parent = parent->GetGeometricParent();
+    parent->GetGeometricParent(parent);
   }
   if (nsnull != parent) {
     nsIPresShell* shell = aCX->GetShell();
@@ -698,24 +706,23 @@ TextFrame::ResizeReflow(nsIPresContext* aCX,
   nsStyleMolecule* mol =
     (nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
 
-  ReflowStatus status;
   if (NS_STYLE_WHITESPACE_PRE == mol->whiteSpace) {
     // Use a specialized routine for pre-formatted text
-    status = ReflowPre(aCX, aDesiredSize, aMaxSize,
+    aStatus = ReflowPre(aCX, aDesiredSize, aMaxSize,
                        aMaxElementSize, *font, startingOffset, state);
   } else {
     // Use normal wrapping routine for non-pre text (this includes
     // text that is not wrapping)
-    status = ReflowNormal(aCX, aDesiredSize, aMaxSize,
+    aStatus = ReflowNormal(aCX, aDesiredSize, aMaxSize,
                           aMaxElementSize, *font, *mol, startingOffset, state);
   }
 
 #ifdef NOISY
   ListTag(stdout);
   printf(": reflow %scomplete [flags=%x]\n",
-         ((status == frComplete) ? "" : "not "), mFlags);
+         ((aStatus == frComplete) ? "" : "not "), mFlags);
 #endif
-  return status;
+  return NS_OK;
 }
 
 // Reflow normal text (stuff that doesn't have to deal with horizontal
@@ -960,11 +967,11 @@ TextFrame::ReflowPre(nsIPresContext* aCX,
 
 #define NUM_WORDS 20
 
-void TextFrame::JustifyReflow(nsIPresContext* aCX, nscoord aAvailableSpace)
+NS_METHOD TextFrame::JustifyReflow(nsIPresContext* aCX, nscoord aAvailableSpace)
 {
   if (mFlags & TEXT_IS_PRE) {
     // no way
-    return;
+    return NS_OK;
   }
 
   nsStyleFont* font =
@@ -1145,10 +1152,11 @@ bail:
     delete wp0;
   }
   NS_RELEASE(fm);
+  return NS_OK;
 }
 #undef NUM_WORDS
 
-void TextFrame::List(FILE* out, PRInt32 aIndent) const
+NS_METHOD TextFrame::List(FILE* out, PRInt32 aIndent) const
 {
   PRInt32 i;
   for (i = aIndent; --i >= 0; ) fputs("  ", out);
@@ -1189,6 +1197,7 @@ void TextFrame::List(FILE* out, PRInt32 aIndent) const
     fputs("\n", out);
   }
 #endif
+  return NS_OK;
 }
 
 //----------------------------------------------------------------------
diff --git a/mozilla/layout/html/forms/src/nsInputButton.cpp b/mozilla/layout/html/forms/src/nsInputButton.cpp
index 4172444a910..74cbbd6015c 100644
--- a/mozilla/layout/html/forms/src/nsInputButton.cpp
+++ b/mozilla/layout/html/forms/src/nsInputButton.cpp
@@ -274,7 +274,7 @@ nsInputButtonFrame::~nsInputButtonFrame()
 void
 nsInputButtonFrame::MouseClicked() 
 {
-  nsInputButton* button = (nsInputButton *) GetContent();
+  nsInputButton* button = (nsInputButton *)mContent;
   nsIFormManager* formMan = button->GetFormManager();
   if (nsnull != formMan) {
     if (kInputButtonReset == button->GetButtonType()) {
@@ -284,7 +284,6 @@ nsInputButtonFrame::MouseClicked()
     }
     NS_RELEASE(formMan);
   }
-  NS_RELEASE(button);
 }
 
 
@@ -293,10 +292,9 @@ nsInputButtonFrame::PreInitializeWidget(nsIPresContext* aPresContext, nsSize& aB
 {
   float p2t = aPresContext->GetPixelsToTwips();
 
-  nsInputButton* content = (nsInputButton *)GetContent(); // this must be an nsInputButton 
-  nsIStyleContext* styleContext = GetStyleContext(aPresContext);
+  nsInputButton* content = (nsInputButton *)mContent; // this must be an nsInputButton 
   // should this be the parent
-  nsStyleFont* styleFont = (nsStyleFont*)styleContext->GetData(kStyleFontSID);
+  nsStyleFont* styleFont = (nsStyleFont*)mStyleContext->GetData(kStyleFontSID);
   nsIDeviceContext* deviceContext = aPresContext->GetDeviceContext();
   nsIFontCache* fontCache = deviceContext->GetFontCache();
 
@@ -321,8 +319,6 @@ nsInputButtonFrame::PreInitializeWidget(nsIPresContext* aPresContext, nsSize& aB
   NS_RELEASE(fontMet);
   NS_RELEASE(fontCache);
   NS_RELEASE(deviceContext);
-  NS_RELEASE(styleContext);
-  NS_RELEASE(content);
 }
 
 
diff --git a/mozilla/layout/html/forms/src/nsInputCheckbox.cpp b/mozilla/layout/html/forms/src/nsInputCheckbox.cpp
index 1f289be8049..0fe4c00a76d 100644
--- a/mozilla/layout/html/forms/src/nsInputCheckbox.cpp
+++ b/mozilla/layout/html/forms/src/nsInputCheckbox.cpp
@@ -84,7 +84,7 @@ void
 nsInputCheckboxFrame::PreInitializeWidget(nsIPresContext* aPresContext, 
                                           nsSize& aBounds)
 {
-  nsInputCheckbox* content = (nsInputCheckbox *)GetContent(); // this must be an nsCheckbox 
+  nsInputCheckbox* content = (nsInputCheckbox *)mContent; // this must be an nsCheckbox 
 
   // get the state
   nsHTMLValue value; 
@@ -92,7 +92,6 @@ nsInputCheckboxFrame::PreInitializeWidget(nsIPresContext* aPresContext,
   if (result != eContentAttr_NotThere) {
     mCacheState = PR_TRUE;/* XXX why cache state? */
   }
-  NS_RELEASE(content);
 
   float p2t = aPresContext->GetPixelsToTwips();
   aBounds.width  = (int)(13 * p2t);
@@ -113,7 +112,8 @@ void
 nsInputCheckboxFrame::MouseClicked() 
 {
   nsICheckButton* checkbox;
-  nsIView* view = GetView();
+  nsIView* view;
+  GetView(view);
   if (NS_OK == GetWidget(view, (nsIWidget **)&checkbox)) {
 	PRBool newState = (checkbox->GetState()) ? PR_FALSE : PR_TRUE;
 	checkbox->SetState(newState);
diff --git a/mozilla/layout/html/forms/src/nsInputFrame.cpp b/mozilla/layout/html/forms/src/nsInputFrame.cpp
index d690b18cc28..acc47a3ce0d 100644
--- a/mozilla/layout/html/forms/src/nsInputFrame.cpp
+++ b/mozilla/layout/html/forms/src/nsInputFrame.cpp
@@ -56,7 +56,7 @@ nsInputFrame::~nsInputFrame()
 
 // XXX it would be cool if form element used our rendering sw, then
 // they could be blended, and bordered, and so on...
-void 
+NS_METHOD
 nsInputFrame::Paint(nsIPresContext& aPresContext,
                     nsIRenderingContext& aRenderingContext,
                     const nsRect& aDirtyRect)
@@ -64,11 +64,13 @@ nsInputFrame::Paint(nsIPresContext& aPresContext,
   static NS_DEFINE_IID(kIWidgetIID, NS_IWIDGET_IID);
 
   nsPoint offset;
-  nsIView *parent = GetOffsetFromView(offset);
+  nsIView *parent;
+  GetOffsetFromView(offset, parent);
   if (nsnull == parent) {  // a problem
 	  NS_ASSERTION(0, "parent view was null\n");
   } else {
-	  nsIView* view = GetView();
+	  nsIView* view;
+	  GetView(view);
 	  float t2p = aPresContext.GetTwipsToPixels();
 	  //nsIWidget *widget = view->GetWindow();
 	  nsIWidget* widget;
@@ -90,6 +92,7 @@ nsInputFrame::Paint(nsIPresContext& aPresContext,
 	  NS_RELEASE(view);
     NS_RELEASE(parent);
   }
+  return NS_OK;
 }
 
 PRBool 
@@ -125,16 +128,18 @@ nsInputFrame::PreInitializeWidget(nsIPresContext* aPresContext,
   aBounds.height = (int)(10 * p2t);
 }
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
                           nsReflowMetrics& aDesiredSize,
                           const nsSize& aMaxSize,
-                          nsSize* aMaxElementSize)
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus)
 {
   // XXX add in code to check for width/height being set via css
   // and if set use them instead of calling GetDesiredSize.
 
-  nsIView* view = GetView();  
+  nsIView* view;
+  GetView(view);
   if (nsnull == view) {
 
     static NS_DEFINE_IID(kViewCID, NS_VIEW_CID);
@@ -144,7 +149,8 @@ nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
 	  NSRepository::CreateInstance(kViewCID, nsnull, kIViewIID, (void **)&view);// need to release
 	  if (NS_OK != result) {
 	    NS_ASSERTION(0, "Could not create view for button"); 
-      return frNotComplete;
+      aStatus = frNotComplete;
+      return NS_OK;
 	  }
 	  nsIPresShell   *presShell = aPresContext->GetShell();     // need to release
 	  nsIViewManager *viewMan   = presShell->GetViewManager();  // need to release
@@ -153,7 +159,11 @@ nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
 	  //float t2p = aPresContext->GetTwipsToPixels();
 	  nsRect boundBox(0, 0, mCacheBounds.width, mCacheBounds.height); 
 
-	  nsIView *parView = GetParentWithView()->GetView();
+    nsIFrame* parWithView;
+	  nsIView *parView;
+
+    GetParentWithView(parWithView);
+	  parWithView->GetView(parView);
 
 	  const nsIID id = GetCID();
 	  // initialize the view as hidden since we don't know the (x,y) until Paint
@@ -161,17 +171,17 @@ nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
 		                1.0f, nsViewVisibility_kHide);
     if (NS_OK != result) {
 	    NS_ASSERTION(0, "widget initialization failed"); 
-      return frNotComplete;
+      aStatus = frNotComplete;
+      return NS_OK;
 	  }
 
 	  // set the content's widget, so it can get content modified by the widget
 	  nsIWidget *widget;
 	  result = GetWidget(view, &widget);
 	  if (NS_OK == result) {
-      nsInput* content = (nsInput *)GetContent(); // change this cast to QueryInterface 
+      nsInput* content = (nsInput *)mContent; // change this cast to QueryInterface 
       content->SetWidget(widget);
 	    NS_IF_RELEASE(widget);
-	    NS_RELEASE(content);
 	  } else {
 	    NS_ASSERTION(0, "could not get widget");
 	  }
@@ -195,8 +205,8 @@ nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
 	  aMaxElementSize->height = aDesiredSize.height;
   }
     
-  return frComplete;
-
+  aStatus = frComplete;
+  return NS_OK;
 }
 
 nsresult
@@ -225,13 +235,15 @@ nsInputFrame::GetCID()
   return kButtonCID;
 }
 
-nsEventStatus nsInputFrame::HandleEvent(nsIPresContext& aPresContext, 
-                                        nsGUIEvent* aEvent)
+NS_METHOD nsInputFrame::HandleEvent(nsIPresContext& aPresContext, 
+                                    nsGUIEvent* aEvent,
+                                    nsEventStatus& aEventStatus)
 {
 	// make sure that the widget in the event is this
   static NS_DEFINE_IID(kSupportsIID, NS_ISUPPORTS_IID);
   nsIWidget* thisWidget;
-  nsIView*   view = GetView();
+  nsIView*   view;
+  GetView(view);
   nsresult result = GetWidget(view, &thisWidget);
   nsISupports* thisWidgetSup;
   result = thisWidget->QueryInterface(kSupportsIID, (void **)&thisWidgetSup);
@@ -246,7 +258,8 @@ nsEventStatus nsInputFrame::HandleEvent(nsIPresContext& aPresContext,
   NS_IF_RELEASE(thisWidget);
 
 	if (!isOurEvent) {
-		return nsEventStatus_eIgnore;
+		aEventStatus = nsEventStatus_eIgnore;
+    return NS_OK;
 	}
 
   switch (aEvent->message) {
@@ -273,7 +286,8 @@ nsEventStatus nsInputFrame::HandleEvent(nsIPresContext& aPresContext,
 	    mLastMouseState = eMouseNone;
 	    break;
   }
-  return nsEventStatus_eIgnore;
+  aEventStatus = nsEventStatus_eIgnore;
+  return NS_OK;
 }
 
 
diff --git a/mozilla/layout/html/forms/src/nsInputFrame.h b/mozilla/layout/html/forms/src/nsInputFrame.h
index 61c7a5ab67f..96c6adf8499 100644
--- a/mozilla/layout/html/forms/src/nsInputFrame.h
+++ b/mozilla/layout/html/forms/src/nsInputFrame.h
@@ -59,24 +59,26 @@ public:
     * Respond to a gui event
     * @see nsIFrame::HandleEvent
     */
-  virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext, 
-                                    nsGUIEvent* aEvent);
+  NS_IMETHOD HandleEvent(nsIPresContext& aPresContext, 
+                         nsGUIEvent* aEvent,
+                         nsEventStatus& aEventStatus);
   /**
     * Draw this frame within the context of a presentation context and rendering context
     * @see nsIFrame::Paint
     */
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
   /**
     * Respond to the request to resize and/or reflow
     * @see nsIFrame::ResizeReflow
     */
-  virtual ReflowStatus  ResizeReflow(nsIPresContext*  aCX,
-                                     nsReflowMetrics& aDesiredSize,
-                                     const nsSize&    aMaxSize,
-                                     nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aCX,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&    aMaxSize,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
   // New Behavior
 
diff --git a/mozilla/layout/html/forms/src/nsInputText.cpp b/mozilla/layout/html/forms/src/nsInputText.cpp
index f9a3b01a8a9..2ce4a81a1c6 100644
--- a/mozilla/layout/html/forms/src/nsInputText.cpp
+++ b/mozilla/layout/html/forms/src/nsInputText.cpp
@@ -81,7 +81,7 @@ void
 nsInputTextFrame::PreInitializeWidget(nsIPresContext* aPresContext, 
                                       nsSize& aBounds)
 {
-  nsInputText* content = (nsInputText *)GetContent(); // this must be an nsInputButton 
+  nsInputText* content = (nsInputText *)mContent; // this must be an nsInputButton 
 
   // get the value of the text
   if (nsnull != content->mValue) {
@@ -89,7 +89,6 @@ nsInputTextFrame::PreInitializeWidget(nsIPresContext* aPresContext,
   } else {
     mCacheValue = "";
   }
-  NS_RELEASE(content);
 
   float p2t = aPresContext->GetPixelsToTwips();
   aBounds.width  = (int)(120 * p2t);
diff --git a/mozilla/layout/html/style/src/nsCSSLayout.cpp b/mozilla/layout/html/style/src/nsCSSLayout.cpp
index b21ce611ba6..cfed2ce1fde 100644
--- a/mozilla/layout/html/style/src/nsCSSLayout.cpp
+++ b/mozilla/layout/html/style/src/nsCSSLayout.cpp
@@ -54,8 +54,11 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
   PRIntn kidCount = aChildCount;
   while (--kidCount >= 0) {
     nscoord kidAscent = *aAscents++;
-    nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
-    nsIContent* kidContent = kid->GetContent();
+    nsIStyleContext* kidSC;
+    nsIContent* kidContent;
+
+    kid->GetStyleContext(aCX, kidSC);
+    kid->GetContent(kidContent);
     nsStyleMolecule* kidMol =
       (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     PRIntn verticalAlign = kidMol->verticalAlign;
@@ -124,7 +127,7 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
     y += kidRect.height;
     if (y > maxY) maxY = y;
 
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 
   nscoord lineHeight = maxY - minY;
@@ -135,8 +138,11 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
     kid = aFirstChild;
     while (--kidCount >= 0) {
       // Get kid's vertical align style data
-      nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
-      nsIContent* kidContent = kid->GetContent();
+      nsIStyleContext* kidSC;
+      nsIContent* kidContent;
+
+      kid->GetStyleContext(aCX, kidSC);
+      kid->GetContent(kidContent);
       nsStyleMolecule* kidMol =
         (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       PRIntn verticalAlign = kidMol->verticalAlign;
@@ -154,7 +160,7 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
         }
       }
 
-      kid = kid->GetNextSibling();
+      kid->GetNextSibling(kid);
     }
   }
 
@@ -197,7 +203,7 @@ void nsCSSLayout::HorizontallyPlaceChildren(nsIPresContext* aCX,
   while (--aChildCount >= 0) {
     kid->GetOrigin(origin);
     kid->MoveTo(origin.x + dx, origin.y);
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 }
 
@@ -213,8 +219,11 @@ void nsCSSLayout::RelativePositionChildren(nsIPresContext* aCX,
   nsPoint origin;
   nsIFrame* kid = aFirstChild;
   while (--aChildCount >= 0) {
-    nsIContent* kidContent = kid->GetContent();
-    nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
+    nsIContent* kidContent;
+    nsIStyleContext* kidSC;
+
+    kid->GetContent(kidContent);
+    kid->GetStyleContext(aCX, kidSC);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     if (NS_STYLE_POSITION_RELATIVE == kidMol->positionFlags) {
       kid->GetOrigin(origin);
@@ -224,6 +233,6 @@ void nsCSSLayout::RelativePositionChildren(nsIPresContext* aCX,
     }
     NS_RELEASE(kidContent);
     NS_RELEASE(kidSC);
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 }
diff --git a/mozilla/layout/html/style/src/nsCSSStyleSheet.cpp b/mozilla/layout/html/style/src/nsCSSStyleSheet.cpp
index bacdabafd92..685c07443e8 100644
--- a/mozilla/layout/html/style/src/nsCSSStyleSheet.cpp
+++ b/mozilla/layout/html/style/src/nsCSSStyleSheet.cpp
@@ -215,11 +215,13 @@ PRInt32 CSSStyleSheetImpl::RulesMatching(nsIPresContext* aPresContext,
       selector = selector->mNext;
       nsIFrame* frame = aParentFrame;
       while ((nsnull != selector) && (nsnull != frame)) { // check compound selectors
-        nsIContent* content = frame->GetContent();
+        nsIContent* content;
+         
+        frame->GetContent(content);
         if (SelectorMatches(selector, content)) {
           selector = selector->mNext;
         }
-        frame = frame->GetGeometricParent();
+        frame->GetGeometricParent(frame);
         NS_RELEASE(content);
       }
       if (nsnull == selector) { // ran out, it matched
diff --git a/mozilla/layout/html/table/src/nsCellLayoutData.cpp b/mozilla/layout/html/table/src/nsCellLayoutData.cpp
index 973c9a42f01..87e88f091f8 100644
--- a/mozilla/layout/html/table/src/nsCellLayoutData.cpp
+++ b/mozilla/layout/html/table/src/nsCellLayoutData.cpp
@@ -83,8 +83,11 @@ void nsCellLayoutData::SetMaxElementSize(nsSize * aMaxElementSize)
   **/
 nsStyleMolecule* nsCellLayoutData::GetStyleMolecule()
 {
-  if (mCellFrame != nsnull)
-    return (nsStyleMolecule*)mCellFrame->GetStyleData(kStyleMoleculeSID);
+  if (mCellFrame != nsnull) {
+    nsStyleMolecule*  styleMol;
+    mCellFrame->GetStyleData(kStyleMoleculeSID, (nsStyleStruct*&)styleMol);
+    return styleMol;
+  }
   return nsnull;
 }
 
@@ -398,8 +401,11 @@ nsStyleMolecule* nsCellLayoutData::FindOuterBorder( nsTableFrame* aTableFrame,
     // for the parent frame is also zero
     if (margin == 0)
     { 
-      nsIFrame*         parentFrame = aFrame->GetGeometricParent();
-      nsStyleMolecule*  parentStyle = (nsStyleMolecule*)aFrame->GetStyleData(kStyleMoleculeSID);
+      nsIFrame*         parentFrame;
+      nsStyleMolecule*  parentStyle;
+
+      aFrame->GetGeometricParent(parentFrame);
+      aFrame->GetStyleData(kStyleMoleculeSID, (nsStyleStruct*&)parentStyle);
 
       // if the padding for the parent style is zero just
       // recursively call this routine
@@ -547,7 +553,9 @@ void nsCellLayoutData::RecalcLayoutData(nsTableFrame* aTableFrame,
                                         nsVoidArray* aBoundaryCells[4])
 
 {
-  nsStyleMolecule* cellStyle = (nsStyleMolecule*)mCellFrame->GetStyleData(kStyleMoleculeSID);
+  nsStyleMolecule* cellStyle;
+
+  mCellFrame->GetStyleData(kStyleMoleculeSID, (nsStyleStruct*&)cellStyle);
   
   CalculateBorders(aTableFrame,cellStyle,aBoundaryCells);
   CalculateMargins(aTableFrame,cellStyle,aBoundaryCells);
@@ -558,7 +566,9 @@ void nsCellLayoutData::List(FILE* out, PRInt32 aIndent) const
 {
   PRInt32 indent;
 
-  nsTableCell* cell = (nsTableCell*)mCellFrame->GetContent();
+  nsTableCell* cell;
+
+  mCellFrame->GetContent((nsIContent*&)cell);
   if (cell != nsnull)
   {
     for (indent = aIndent; --indent >= 0; ) fputs("  ", out);
diff --git a/mozilla/layout/html/table/src/nsColLayoutData.cpp b/mozilla/layout/html/table/src/nsColLayoutData.cpp
index 047703342e3..57af73713ae 100644
--- a/mozilla/layout/html/table/src/nsColLayoutData.cpp
+++ b/mozilla/layout/html/table/src/nsColLayoutData.cpp
@@ -100,7 +100,9 @@ PRInt32 nsColLayoutData::IndexOf(nsTableCell* aTableCell) const
         nsTableCellFrame* frame = cellData->GetCellFrame();
         if (frame != nsnull)
         {
-          nsTableCell* cell = (nsTableCell*)frame->GetContent();
+          nsTableCell* cell;
+           
+          frame->GetContent((nsIContent*&)cell);
           if (cell == aTableCell)
           {
             result = index;
diff --git a/mozilla/layout/html/table/src/nsTableCaptionFrame.cpp b/mozilla/layout/html/table/src/nsTableCaptionFrame.cpp
index 5f02504df76..edd68945b9c 100644
--- a/mozilla/layout/html/table/src/nsTableCaptionFrame.cpp
+++ b/mozilla/layout/html/table/src/nsTableCaptionFrame.cpp
@@ -89,14 +89,14 @@ void nsTableCaptionFrame::CreatePsuedoFrame(nsIPresContext* aPresContext)
     NS_ASSERTION(prevFrame->ChildIsPseudoFrame(prevPseudoFrame), "bad previous pseudo-frame");
 
     // Create a continuing column
-    mFirstChild = prevPseudoFrame->CreateContinuingFrame(aPresContext, this);
+    prevPseudoFrame->CreateContinuingFrame(aPresContext, this, mFirstChild);
     mChildCount = 1;
   }
 }
 
-void nsTableCaptionFrame::Paint(nsIPresContext& aPresContext,
-                                nsIRenderingContext& aRenderingContext,
-                                const nsRect& aDirtyRect)
+NS_METHOD nsTableCaptionFrame::Paint(nsIPresContext& aPresContext,
+                                     nsIRenderingContext& aRenderingContext,
+                                     const nsRect& aDirtyRect)
 {
   nsStyleMolecule* myMol =
     (nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
@@ -104,7 +104,7 @@ void nsTableCaptionFrame::Paint(nsIPresContext& aPresContext,
     (nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
   NS_ASSERTION(nsnull!=myColor, "bad style color");
   NS_ASSERTION(nsnull!=myMol, "bad style molecule");
-  if (nsnull==myMol) return;
+  if (nsnull==myMol) return NS_OK;
 
   nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this,
                                   aDirtyRect, mRect, *myColor);
@@ -119,6 +119,7 @@ void nsTableCaptionFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 /**
@@ -142,7 +143,7 @@ void  nsTableCaptionFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
     bottomInset =mol->borderPadding.bottom;
     verticalAlign = mol->verticalAlign;
   }
-  nscoord       height = GetHeight();
+  nscoord       height = mRect.height;
 
   nsRect        kidRect;  
   mFirstChild->GetRect(kidRect);
@@ -177,11 +178,11 @@ void  nsTableCaptionFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
 
 /**
   */
-nsIFrame::ReflowStatus
-nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize&   aMaxSize,
-                               nsSize*         aMaxElementSize)
+NS_METHOD nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                            nsReflowMetrics& aDesiredSize,
+                                            const nsSize&   aMaxSize,
+                                            nsSize*         aMaxElementSize,
+                                            ReflowStatus&   aStatus)
 {
   NS_PRECONDITION(nsnull!=aPresContext, "bad arg");
 
@@ -189,7 +190,7 @@ nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
   PreReflowCheck();
 #endif
 
-  ReflowStatus result = frComplete;
+  aStatus = frComplete;
   if (gsDebug==PR_TRUE)
     printf("nsTableCaptionFrame::ResizeReflow: maxSize=%d,%d\n",
            aMaxSize.width, aMaxSize.height);
@@ -239,7 +240,7 @@ nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
   if (gsDebug==PR_TRUE)
     printf("  nsTableCaptionFrame::ResizeReflow calling ReflowChild with availSize=%d,%d\n",
            availSize.width, availSize.height);
-  result = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
+  aStatus = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
 
   if (gsDebug==PR_TRUE)
   {
@@ -264,7 +265,7 @@ nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
                               kidSize.width, kidSize.height));
   
   
-  if (frNotComplete == result) {
+  if (frNotComplete == aStatus) {
     // If the child didn't finish layout then it means that it used
     // up all of our available space (or needs us to split).
     mLastContentIsComplete = PR_FALSE;
@@ -301,31 +302,32 @@ nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
            aDesiredSize.width, aDesiredSize.height);
 
 #ifdef NS_DEBUG
-  PostReflowCheck(result);
+  PostReflowCheck(aStatus);
 #endif
 
-  return result;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsTableCaptionFrame::IncrementalReflow( nsIPresContext*  aPresContext,
-                                        nsReflowMetrics& aDesiredSize,
-                                        const nsSize&    aMaxSize,
-                                        nsReflowCommand& aReflowCommand)
+NS_METHOD nsTableCaptionFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                                 nsReflowMetrics& aDesiredSize,
+                                                 const nsSize&    aMaxSize,
+                                                 nsReflowCommand& aReflowCommand,
+                                                 ReflowStatus&    aStatus)
 {
   if (gsDebug == PR_TRUE) printf("nsTableCaptionFrame::IncrementalReflow\n");
   // total hack for now, just some hard-coded values
-  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
-
-  return frComplete;
+  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
+  return NS_OK;
 }
 
-nsIFrame* nsTableCaptionFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                     nsIFrame*       aParent)
+NS_METHOD nsTableCaptionFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                     nsIFrame*       aParent,
+                                                     nsIFrame*&      aContinuingFrame)
 {
   nsTableCaptionFrame* cf = new nsTableCaptionFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 /* ----- static methods ----- */
diff --git a/mozilla/layout/html/table/src/nsTableCaptionFrame.h b/mozilla/layout/html/table/src/nsTableCaptionFrame.h
index 760d76dc730..cfef6ae63b7 100644
--- a/mozilla/layout/html/table/src/nsTableCaptionFrame.h
+++ b/mozilla/layout/html/table/src/nsTableCaptionFrame.h
@@ -38,25 +38,28 @@ public:
                            PRInt32     aIndexInParent,
                            nsIFrame*   aParent);
 
-  virtual void  Paint(nsIPresContext&      aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect&        aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext&      aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect&        aDirtyRect);
 
-  virtual ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&    aMaxSize,
-                             nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&    aMaxSize,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
-  virtual ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
   /**
    * @see nsContainerFrame
    */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
   virtual void          VerticallyAlignChild(nsIPresContext* aPresContext);
 
diff --git a/mozilla/layout/html/table/src/nsTableCellFrame.cpp b/mozilla/layout/html/table/src/nsTableCellFrame.cpp
index fc41977b5ee..213e08a502c 100644
--- a/mozilla/layout/html/table/src/nsTableCellFrame.cpp
+++ b/mozilla/layout/html/table/src/nsTableCellFrame.cpp
@@ -51,9 +51,9 @@ nsTableCellFrame::~nsTableCellFrame()
 {
 }
 
-void nsTableCellFrame::Paint(nsIPresContext& aPresContext,
-                             nsIRenderingContext& aRenderingContext,
-                             const nsRect& aDirtyRect)
+NS_METHOD nsTableCellFrame::Paint(nsIPresContext& aPresContext,
+                                  nsIRenderingContext& aRenderingContext,
+                                  const nsRect& aDirtyRect)
 {
   nsStyleColor* myColor =
     (nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
@@ -75,6 +75,7 @@ void nsTableCellFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 /**
@@ -98,7 +99,7 @@ void  nsTableCellFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
     bottomInset =mol->borderPadding.bottom;
     verticalAlign = mol->verticalAlign;
   }
-  nscoord       height = GetHeight();
+  nscoord       height = mRect.height;
 
   nsRect        kidRect;  
   mFirstChild->GetRect(kidRect);
@@ -135,11 +136,10 @@ void  nsTableCellFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
 PRInt32 nsTableCellFrame::GetRowSpan()
 {
   PRInt32 result = 0;
-  nsTableCell *cellContent = (nsTableCell *)GetContent();        // cellContent:  REFCNT++
+  nsTableCell *cellContent = (nsTableCell *)mContent;
   if (nsnull!=cellContent)
   {
     result = cellContent->GetRowSpan();
-    NS_RELEASE(cellContent);                                     // cellContent:  REFCNT--
   }
   return result;
 }
@@ -164,18 +164,18 @@ void nsTableCellFrame::CreatePsuedoFrame(nsIPresContext* aPresContext)
     NS_ASSERTION(prevFrame->ChildIsPseudoFrame(prevPseudoFrame), "bad previous pseudo-frame");
 
     // Create a continuing column
-    mFirstChild = prevPseudoFrame->CreateContinuingFrame(aPresContext, this);
+    prevPseudoFrame->CreateContinuingFrame(aPresContext, this, mFirstChild);
     mChildCount = 1;
   }
 }
 
 /**
   */
-nsIFrame::ReflowStatus
-nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize&   aMaxSize,
-                               nsSize*         aMaxElementSize)
+NS_METHOD nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                         nsReflowMetrics& aDesiredSize,
+                                         const nsSize&   aMaxSize,
+                                         nsSize*         aMaxElementSize,
+                                         ReflowStatus&   aStatus)
 {
   NS_PRECONDITION(nsnull!=aPresContext, "bad arg");
 
@@ -183,7 +183,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
   //PreReflowCheck();
 #endif
 
-  ReflowStatus result = frComplete;
+  aStatus = frComplete;
   if (gsDebug==PR_TRUE)
     printf("nsTableCellFrame::ResizeReflow: maxSize=%d,%d\n",
            aMaxSize.width, aMaxSize.height);
@@ -233,7 +233,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
   if (gsDebug==PR_TRUE)
     printf("  nsTableCellFrame::ResizeReflow calling ReflowChild with availSize=%d,%d\n",
            availSize.width, availSize.height);
-  result = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
+  aStatus = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
 
   if (gsDebug==PR_TRUE)
   {
@@ -258,7 +258,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
                            kidSize.width, kidSize.height));
   
     
-  if (frNotComplete == result) {
+  if (frNotComplete == aStatus) {
     // If the child didn't finish layout then it means that it used
     // up all of our available space (or needs us to split).
     mLastContentIsComplete = PR_FALSE;
@@ -289,28 +289,29 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
   //PostReflowCheck(result);
 #endif
 
-  return result;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsTableCellFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize&    aMaxSize,
-                                    nsReflowCommand& aReflowCommand)
+NS_METHOD nsTableCellFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                              nsReflowMetrics& aDesiredSize,
+                                              const nsSize&    aMaxSize,
+                                              nsReflowCommand& aReflowCommand,
+                                              ReflowStatus&    aStatus)
 {
   if (gsDebug == PR_TRUE) printf("nsTableCellFrame::IncrementalReflow\n");
   // total hack for now, just some hard-coded values
-  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
-
-  return frComplete;
+  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
+  return NS_OK;
 }
 
-nsIFrame* nsTableCellFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                  nsIFrame*       aParent)
+NS_METHOD nsTableCellFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                  nsIFrame*       aParent,
+                                                  nsIFrame*&      aContinuingFrame)
 {
   nsTableCellFrame* cf = new nsTableCellFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 
diff --git a/mozilla/layout/html/table/src/nsTableCellFrame.h b/mozilla/layout/html/table/src/nsTableCellFrame.h
index c71974a1894..3199b6efa5d 100644
--- a/mozilla/layout/html/table/src/nsTableCellFrame.h
+++ b/mozilla/layout/html/table/src/nsTableCellFrame.h
@@ -38,25 +38,28 @@ public:
                            PRInt32     aIndexInParent,
                            nsIFrame*   aParent);
 
-  virtual void  Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  ReflowStatus  ResizeReflow(nsIPresContext* aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&   aMaxSize,
-                             nsSize*         aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&   aMaxSize,
+                          nsSize*         aMaxElementSize,
+                          ReflowStatus&   aStatus);
 
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
   /**
    * @see nsContainerFrame
    */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
   void          VerticallyAlignChild(nsIPresContext* aPresContext);
 
diff --git a/mozilla/layout/html/table/src/nsTableCol.cpp b/mozilla/layout/html/table/src/nsTableCol.cpp
index 895a536d130..8a2ec92b382 100644
--- a/mozilla/layout/html/table/src/nsTableCol.cpp
+++ b/mozilla/layout/html/table/src/nsTableCol.cpp
@@ -42,19 +42,21 @@ public:
                            PRInt32     aIndexInParent,
                            nsIFrame*   aParent);
 
-  void          Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  ReflowStatus  ResizeReflow(nsIPresContext* aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&   aMaxSize,
-                             nsSize*         aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&   aMaxSize,
+                          nsSize*         aMaxElementSize,
+                          ReflowStatus&   aStatus);
 
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
 protected:
 
@@ -79,20 +81,21 @@ nsTableColFrame::~nsTableColFrame()
 {
 }
 
-void nsTableColFrame::Paint(nsIPresContext& aPresContext,
-                            nsIRenderingContext& aRenderingContext,
-                            const nsRect& aDirtyRect)
+NS_METHOD nsTableColFrame::Paint(nsIPresContext& aPresContext,
+                                 nsIRenderingContext& aRenderingContext,
+                                 const nsRect& aDirtyRect)
 {
   if (gsDebug==PR_TRUE)
     printf("nsTableColFrame::Paint\n");
+  return NS_OK;
 }
 
 
-nsIFrame::ReflowStatus
-nsTableColFrame::ResizeReflow(nsIPresContext* aPresContext,
-                        nsReflowMetrics& aDesiredSize,
-                        const nsSize&   aMaxSize,
-                        nsSize*         aMaxElementSize)
+NS_METHOD nsTableColFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                        nsReflowMetrics& aDesiredSize,
+                                        const nsSize&   aMaxSize,
+                                        nsSize*         aMaxElementSize,
+                                        ReflowStatus&   aStatus)
 {
   NS_ASSERTION(nsnull!=aPresContext, "bad arg");
   if (gsDebug==PR_TRUE) printf("nsTableoupFrame::ResizeReflow\n");
@@ -103,20 +106,22 @@ nsTableColFrame::ResizeReflow(nsIPresContext* aPresContext,
     aMaxElementSize->width=0;
     aMaxElementSize->height=0;
   }
-  return nsIFrame::frComplete;
+  aStatus = nsIFrame::frComplete;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsTableColFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                                   nsReflowMetrics& aDesiredSize,
-                                   const nsSize&    aMaxSize,
-                                   nsReflowCommand& aReflowCommand)
+NS_METHOD nsTableColFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                             nsReflowMetrics& aDesiredSize,
+                                             const nsSize&    aMaxSize,
+                                             nsReflowCommand& aReflowCommand,
+                                             ReflowStatus&    aStatus)
 {
   NS_ASSERTION(nsnull!=aPresContext, "bad arg");
   if (gsDebug==PR_TRUE) printf("nsTableColFrame::IncrementalReflow\n");
   aDesiredSize.width=0;
   aDesiredSize.height=0;
-  return nsIFrame::frComplete;
+  aStatus = nsIFrame::frComplete;
+  return NS_OK;
 }
 
 nsresult nsTableColFrame::NewFrame(nsIFrame** aInstancePtrResult,
diff --git a/mozilla/layout/html/table/src/nsTableColGroupFrame.cpp b/mozilla/layout/html/table/src/nsTableColGroupFrame.cpp
index d2741f097ca..f9bee13cc80 100644
--- a/mozilla/layout/html/table/src/nsTableColGroupFrame.cpp
+++ b/mozilla/layout/html/table/src/nsTableColGroupFrame.cpp
@@ -35,20 +35,22 @@ nsTableColGroupFrame::~nsTableColGroupFrame()
 {
 }
 
-void nsTableColGroupFrame::Paint(nsIPresContext& aPresContext,
-                                 nsIRenderingContext& aRenderingContext,
-                                 const nsRect&        aDirtyRect)
+NS_METHOD nsTableColGroupFrame::Paint(nsIPresContext& aPresContext,
+                                      nsIRenderingContext& aRenderingContext,
+                                      const nsRect&        aDirtyRect)
 {
   if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::Paint\n");
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableColGroupFrame::ResizeReflow(nsIPresContext* aPresContext,
                         nsReflowMetrics& aDesiredSize,
                         const nsSize&   aMaxSize,
-                        nsSize*         aMaxElementSize)
+                        nsSize*         aMaxElementSize,
+                        ReflowStatus& aStatus)
 {
   NS_ASSERTION(nsnull!=aPresContext, "bad arg");
   if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::ResizeReflow\n");
@@ -59,21 +61,20 @@ nsTableColGroupFrame::ResizeReflow(nsIPresContext* aPresContext,
     aMaxElementSize->width=0;
     aMaxElementSize->height=0;
   }
-  return nsIFrame::frComplete;
+  aStatus = nsIFrame::frComplete;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableColGroupFrame::IncrementalReflow(nsIPresContext*  aPresContext,
                                         nsReflowMetrics& aDesiredSize,
                                         const nsSize&    aMaxSize,
-                                        nsReflowCommand& aReflowCommand)
+                                        nsReflowCommand& aReflowCommand,
+                                        ReflowStatus&    aStatus)
 {
   NS_ASSERTION(nsnull!=aPresContext, "bad arg");
-  ReflowStatus  status;
-
   if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::IncrementalReflow\n");
-
-  return status;
+  return NS_OK;
 }
 
 nsresult nsTableColGroupFrame::NewFrame(nsIFrame** aInstancePtrResult,
diff --git a/mozilla/layout/html/table/src/nsTableColGroupFrame.h b/mozilla/layout/html/table/src/nsTableColGroupFrame.h
index 260c77c8745..e2a93f7a00b 100644
--- a/mozilla/layout/html/table/src/nsTableColGroupFrame.h
+++ b/mozilla/layout/html/table/src/nsTableColGroupFrame.h
@@ -36,19 +36,21 @@ public:
                            PRInt32     aIndexInParent,
                            nsIFrame*   aParent);
 
-  virtual void  Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  ReflowStatus  ResizeReflow(nsIPresContext* aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&   aMaxSize,
-                             nsSize*         aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&   aMaxSize,
+                          nsSize*         aMaxElementSize,
+                          ReflowStatus&   aStatus);
 
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
 protected:
 
diff --git a/mozilla/layout/html/table/src/nsTableFrame.cpp b/mozilla/layout/html/table/src/nsTableFrame.cpp
index e10b1962c19..d7f0baa342a 100644
--- a/mozilla/layout/html/table/src/nsTableFrame.cpp
+++ b/mozilla/layout/html/table/src/nsTableFrame.cpp
@@ -388,9 +388,9 @@ void nsTableFrame::ResetColumnLayoutData()
 
 
 /* SEC: TODO: adjust the rect for captions */
-void nsTableFrame::Paint(nsIPresContext& aPresContext,
-                         nsIRenderingContext& aRenderingContext,
-                         const nsRect& aDirtyRect)
+NS_METHOD nsTableFrame::Paint(nsIPresContext& aPresContext,
+                              nsIRenderingContext& aRenderingContext,
+                              const nsRect& aDirtyRect)
 {
   // table paint code is concerned primarily with borders and bg color
   nsStyleColor* myColor =
@@ -414,6 +414,7 @@ void nsTableFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 PRBool nsTableFrame::NeedsReflow(const nsSize& aMaxSize)
@@ -444,10 +445,11 @@ PRBool nsTableFrame::NeedsReflow(const nsSize& aMaxSize)
 
 /** Layout the entire inner table.
   */
-nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
-                                                   nsReflowMetrics& aDesiredSize,
-                                                   const nsSize& aMaxSize,
-                                                   nsSize* aMaxElementSize)
+NS_METHOD nsTableFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                     nsReflowMetrics& aDesiredSize,
+                                     const nsSize& aMaxSize,
+                                     nsSize* aMaxElementSize,
+                                     ReflowStatus& aStatus)
 {
   NS_PRECONDITION(nsnull != aPresContext, "null arg");
   if (gsDebug==PR_TRUE) 
@@ -461,7 +463,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
   PreReflowCheck();
 #endif
 
-  ReflowStatus result = frComplete;
+  aStatus = frComplete;
 
   PRIntervalTime startTime = PR_IntervalNow();
 
@@ -479,7 +481,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
     if (PR_FALSE==IsFirstPassValid())
     { // we treat the table as if we've never seen the layout data before
       mPass = kPASS_FIRST;
-      result = ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol);
+      aStatus = ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol);
       // check result
     }
     mPass = kPASS_SECOND;
@@ -490,7 +492,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
     // assign table width
     SetTableWidth(aPresContext, tableStyleMol);
 
-    result = ResizeReflowPass2(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol, 0, 0);
+    aStatus = ResizeReflowPass2(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol, 0, 0);
 
     PRIntervalTime endTime = PR_IntervalNow();
     if (gsTiming) printf("Table reflow took %ld ticks for frame %d\n", endTime-startTime, this);
@@ -503,10 +505,10 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
   }
 
 #ifdef NS_DEBUG
-  PostReflowCheck(result);
+  PostReflowCheck(aStatus);
 #endif  
 
-  return result;
+  return NS_OK;
 }
 
 /** the first of 2 reflow passes
@@ -587,7 +589,9 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresCont
 
       // SEC: TODO:  when content is appended or deleted, be sure to clear out the frame hierarchy!!!!
 
-      nsIFrame* kidFrame = ChildAt(kidIndex);
+      nsIFrame* kidFrame;
+
+      ChildAt(kidIndex, kidFrame);
       // if this is the first time, allocate the caption frame
       if (nsnull==kidFrame)
       {
@@ -662,7 +666,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresCont
   }
 
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
                                            // can't use SetLastContentOffset here
     mLastContentOffset = contentOffset-1;    // takes into account colGroup frame we're not using
     if (gsDebug) printf("INNER: set last content offset to %d\n", GetLastContentOffset()); //@@@
@@ -899,10 +903,14 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext*      aPresContext,
     nsIFrame::ReflowStatus  status;
 
     // Get top margin for this kid
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+
+    kidFrame->GetContent(kid);
     if (((nsTableContent *)kid)->GetType() == nsITableContent::kTableRowGroupType)
     { // skip children that are not row groups
-      nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+      nsIStyleContext* kidSC;
+
+      kidFrame->GetStyleContext(aPresContext, kidSC);
       nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
       nscoord bottomMargin = kidMol->margin.bottom;
@@ -960,17 +968,22 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext*      aPresContext,
 
       // Special handling for incomplete children
       if (frNotComplete == status) {
-        nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         PRBool lastContentIsComplete = mLastContentIsComplete;
         if (nsnull == kidNextInFlow) {
           // The child doesn't have a next-in-flow so create a continuing
           // frame. This hooks the child into the flow
-          nsIFrame* continuingFrame =
-            kidFrame->CreateContinuingFrame(aPresContext, this);
+          nsIFrame* continuingFrame;
+           
+          kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
           NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
           // Add the continuing frame to the sibling list
-          nsIFrame* nextSib = kidFrame->GetNextSibling();
+          nsIFrame* nextSib;
+           
+          kidFrame->GetNextSibling(nextSib);
           continuingFrame->SetNextSibling(nextSib);
           kidFrame->SetNextSibling(continuingFrame);
           if (nsnull == nextSib) {
@@ -982,7 +995,9 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext*      aPresContext,
         }
         // We've used up all of our available space so push the remaining
         // children to the next-in-flow
-        nsIFrame* nextSibling = kidFrame->GetNextSibling();
+        nsIFrame* nextSibling;
+         
+        kidFrame->GetNextSibling(nextSibling);
         if (nsnull != nextSibling) {
           PushChildren(nextSibling, kidFrame, lastContentIsComplete);
           SetLastContentOffset(prevKidFrame);
@@ -993,15 +1008,23 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext*      aPresContext,
     }
 
     // Get the next child
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
 
     // XXX talk with troy about checking for available space here
   }
 
   // Update the child count
   mChildCount = childCount;
+#ifdef NS_DEBUG
   NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
+
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+#endif
 
 #ifdef NS_DEBUG
   VerifyLastIsComplete();
@@ -1067,7 +1090,9 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
 #ifdef NS_DEBUG
   PRInt32        kidIndex = NextChildOffset();
 #endif
-  nsIFrame*      prevKidFrame = LastChild();
+  nsIFrame*      prevKidFrame;
+   
+  LastChild(prevKidFrame);
 
   // This will hold the prevKidFrame's mLastContentIsComplete
   // status. If we have to push the frame that follows prevKidFrame
@@ -1095,7 +1120,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
         kidFrame = nextInFlow->mFirstChild;
       } else {
         // We've pulled up all the children, so move to the next-in-flow.
-        nextInFlow = (nsTableFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
         continue;
       }
     }
@@ -1103,8 +1128,12 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
     // See if the child fits in the available space. If it fits or
     // it's splittable then reflow it. The reason we can't just move
     // it is that we still need ascent/descent information
-    if ((kidFrame->GetHeight() > aState.availSize.height) &&
-        !kidFrame->IsSplittable()) {
+    nsSize  kidFrameSize;
+    PRBool  kidIsSplittable;
+
+    kidFrame->GetSize(kidFrameSize);
+    kidFrame->IsSplittable(kidIsSplittable);
+    if ((kidFrameSize.height > aState.availSize.height) && !kidIsSplittable) {
       result = PR_FALSE;
       mLastContentIsComplete = prevLastContentIsComplete;
       break;
@@ -1134,7 +1163,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
     PlaceChild(aPresContext, aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
 
     // Remove the frame from its current parent
-    nextInFlow->mFirstChild = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(nextInFlow->mFirstChild);
     nextInFlow->mChildCount--;
     // Update the next-in-flows first content offset
     if (nsnull != nextInFlow->mFirstChild) {
@@ -1143,7 +1172,10 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
 
     // Link the frame into our list of children
     kidFrame->SetGeometricParent(this);
-    if (nextInFlow == kidFrame->GetContentParent()) {
+    nsIFrame* contentParent;
+
+    kidFrame->GetContentParent(contentParent);
+    if (nextInFlow == contentParent) {
       kidFrame->SetContentParent(this);
     }
     if (nsnull == prevKidFrame) {
@@ -1163,13 +1195,16 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a
         // continuing frame. The creation appends it to the flow and
         // prepares it for reflow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to our sibling list and then push
@@ -1197,7 +1232,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
 
   // Update our last content offset
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -1217,7 +1252,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
       // the next-in-flows must be empty. Do a sanity check
       while (nsnull != nextInFlow) {
         NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
-        nextInFlow = (nsTableFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
       }
 #endif
     }
@@ -1258,7 +1293,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
     mFirstContentOffset = prev->NextChildOffset();
     if (!prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
   mLastContentIsComplete = PR_TRUE;
@@ -1267,8 +1302,9 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   nsSize    kidMaxElementSize;
   nsSize*   pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
   PRInt32   kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
 
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1301,7 +1337,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
       NS_RELEASE(kidDel);
       kidFrame->SetStyleContext(kidStyleContext);
     } else {
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
+      kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
     }
     NS_RELEASE(kid);
     NS_RELEASE(kidStyleContext);
@@ -1356,7 +1392,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   }
 
   // Update the content mapping
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 #ifdef NS_DEBUG
   PRInt32 len = LengthOf(mFirstChild);
@@ -1536,7 +1572,8 @@ PRBool nsTableFrame::AssignFixedColumnWidths(nsIPresContext* aPresContext, PRInt
         // SEC: TODO -- when we have a style system, set the mol for the col
         nsCellLayoutData * data = (nsCellLayoutData *)(cells->ElementAt(0));
         nsTableCellFrame *cellFrame = data->GetCellFrame();
-        nsTableCell *cell = (nsTableCell *)cellFrame->GetContent();          // cell: REFCNT++
+        nsTableCell *cell;
+        cellFrame->GetContent((nsIContent*&)cell);          // cell: REFCNT++
         nsStyleMolecule* cellStyle = (nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
         NS_ASSERTION(nsnull != cellStyle, "bad style for cell.");
         // SEC: this is the code to replace
@@ -1954,7 +1991,7 @@ void nsTableFrame::SetTableWidth(nsIPresContext* aPresContext,
   nscoord rightInset = aTableStyle->borderPadding.right;
   nscoord leftInset = aTableStyle->borderPadding.left;
   tableWidth += (leftInset + rightInset);
-  nsRect tableSize = GetRect();
+  nsRect tableSize = mRect;
   tableSize.width = tableWidth;
   if (gsDebug==PR_TRUE)
   {
@@ -1975,16 +2012,22 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
   gsDebug = PR_FALSE;  // turn on debug in this method
 #endif
   // iterate children, tell all row groups to ShrinkWrap
-  PRInt32 childCount = ChildCount();
   PRBool atLeastOneRowSpanningCell = PR_FALSE;
   PRInt32 tableHeight = 0;
+  PRInt32 childCount = mChildCount;
+
   for (PRInt32 i = 0; i < childCount; i++)
   {
     PRInt32 childHeight=0;
     // for every child that is a rowFrame, set the row frame height  = sum of row heights
-    nsIFrame * kidFrame = ChildAt(i); // frames are not ref counted
+    // XXX This is a n-squared algorithm. Use GetNextSibling() instead...
+    nsIFrame * kidFrame;
+
+    ChildAt(i, kidFrame); // frames are not ref counted
     NS_ASSERTION(nsnull != kidFrame, "bad kid frame");
-    nsTableContent* kid = (nsTableContent*)(kidFrame->GetContent());  // kid: REFCNT++
+    nsTableContent* kid;
+     
+    kidFrame->GetContent((nsIContent*&)kid);  // kid: REFCNT++
     NS_ASSERTION(nsnull != kid, "bad kid");
     if (kid->GetType() == nsITableContent::kTableRowGroupType)
     {
@@ -1993,33 +2036,48 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
        */
       PRInt32 rowGroupHeight = 0;
       nsTableRowGroupFrame * rowGroupFrame = (nsTableRowGroupFrame *)kidFrame;
-      PRInt32 numRows = rowGroupFrame->ChildCount();
+      PRInt32 numRows;
+      rowGroupFrame->ChildCount(numRows);
       PRInt32 *rowHeights = new PRInt32[numRows];
       if (gsDebug==PR_TRUE) printf("Height Step 1...\n");
       for (PRInt32 rowIndex = 0; rowIndex < numRows; rowIndex++)
       {
         // get the height of the tallest cell in the row (excluding cells that span rows)
-        nsTableRowFrame *rowFrame = (nsTableRowFrame *)(rowGroupFrame->ChildAt(rowIndex));
+        nsTableRowFrame *rowFrame;
+         
+        rowGroupFrame->ChildAt(rowIndex, (nsIFrame*&)rowFrame);
         NS_ASSERTION(nsnull != rowFrame, "bad row frame");
         rowHeights[rowIndex] = rowFrame->GetTallestChild();
-        rowFrame->SizeTo(rowFrame->GetWidth(), rowHeights[rowIndex]);
+
+        nsSize  rowFrameSize;
+
+        rowFrame->GetSize(rowFrameSize);
+        rowFrame->SizeTo(rowFrameSize.width, rowHeights[rowIndex]);
         rowGroupHeight += rowHeights[rowIndex];
         // resize all the cells based on the rowHeight
-        PRInt32 numCells = rowFrame->ChildCount();
+        PRInt32 numCells;
+
+        rowFrame->ChildCount(numCells);
         for (PRInt32 cellIndex = 0; cellIndex < numCells; cellIndex++)
         {
-          nsTableCellFrame *cellFrame = (nsTableCellFrame *)(rowFrame->ChildAt(cellIndex));
+          nsTableCellFrame *cellFrame;
+
+          rowFrame->ChildAt(cellIndex, (nsIFrame*&)cellFrame);
           PRInt32 rowSpan = cellFrame->GetRowSpan();
           if (1==rowSpan)
           {
             if (gsDebug==PR_TRUE) printf("  setting cell[%d,%d] height to %d\n", rowIndex, cellIndex, rowHeights[rowIndex]);
-            cellFrame->SizeTo(cellFrame->GetWidth(), rowHeights[rowIndex]);
+
+            nsSize  cellFrameSize;
+
+            cellFrame->GetSize(cellFrameSize);
+            cellFrame->SizeTo(cellFrameSize.width, rowHeights[rowIndex]);
             // Realign cell content based on new height
             cellFrame->VerticallyAlignChild(aPresContext);
           }
           else
           {
-            if (gsDebug==PR_TRUE) printf("  skipping cell[%d,%d] with a desired height of %d\n", rowIndex, cellIndex, cellFrame->GetHeight());
+            if (gsDebug==PR_TRUE) printf("  skipping cell[%d,%d]\n", rowIndex, cellIndex);
             atLeastOneRowSpanningCell = PR_TRUE;
           }
         }
@@ -2041,11 +2099,16 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
       rowGroupHeight=0;
       for (rowIndex = 0; rowIndex < numRows; rowIndex++)
       {
-        nsTableRowFrame *rowFrame = (nsTableRowFrame *)(rowGroupFrame->ChildAt(rowIndex));
-        PRInt32 numCells = rowFrame->ChildCount();
+        nsTableRowFrame *rowFrame;
+        PRInt32 numCells;
+
+        rowGroupFrame->ChildAt(rowIndex, (nsIFrame*&)rowFrame);
+        rowFrame->ChildCount(numCells);
         for (PRInt32 cellIndex = 0; cellIndex < numCells; cellIndex++)
         {
-          nsTableCellFrame *cellFrame = (nsTableCellFrame *)(rowFrame->ChildAt(cellIndex));
+          nsTableCellFrame *cellFrame;
+
+          rowFrame->ChildAt(cellIndex, (nsIFrame*&)cellFrame);
           PRInt32 rowSpan = cellFrame->GetRowSpan();
           if (1<rowSpan)
           {
@@ -2054,10 +2117,13 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
             for (PRInt32 i=0; i<rowSpan; i++)
               heightOfRowsSpanned += rowHeights[i+rowIndex];
             /* if the cell height fits in the rows, expand the cell height and slap it in */
-            if (heightOfRowsSpanned>cellFrame->GetHeight())
+            nsSize  cellFrameSize;
+
+            cellFrame->GetSize(cellFrameSize);
+            if (heightOfRowsSpanned>cellFrameSize.height)
             {
               if (gsDebug==PR_TRUE) printf("  cell[%d,%d] fits, setting height to %d\n", rowIndex, cellIndex, heightOfRowsSpanned);
-              cellFrame->SizeTo(cellFrame->GetWidth(), heightOfRowsSpanned);
+              cellFrame->SizeTo(cellFrameSize.width, heightOfRowsSpanned);
               // Realign cell content based on new height
               cellFrame->VerticallyAlignChild(aPresContext);
             }
@@ -2066,20 +2132,28 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
              */
             else
             {
-              PRInt32 excessHeight = cellFrame->GetHeight() - heightOfRowsSpanned;
+              PRInt32 excessHeight = cellFrameSize.height - heightOfRowsSpanned;
               PRInt32 excessHeightPerRow = excessHeight/rowSpan;
               if (gsDebug==PR_TRUE) printf("  cell[%d,%d] does not fit, excessHeight = %d, excessHeightPerRow = %d\n", 
                       rowIndex, cellIndex, excessHeight, excessHeightPerRow);
               // for the rows effected...
               for (i=rowIndex; i<numRows; i++)
               {
-                nsTableRowFrame *rowFrameToBeResized = (nsTableRowFrame *)(rowGroupFrame->ChildAt(i));
+                nsTableRowFrame *rowFrameToBeResized;
+
+                rowGroupFrame->ChildAt(i, (nsIFrame*&)rowFrameToBeResized);
                 if (i<rowIndex+rowSpan)
                 {
                   rowHeights[i] += excessHeightPerRow;
                   if (gsDebug==PR_TRUE) printf("    rowHeight[%d] set to %d\n", i, rowHeights[i]);
-                  rowFrameToBeResized->SizeTo(rowFrameToBeResized->GetWidth(), rowHeights[i]);
-                  PRInt32 cellCount = rowFrameToBeResized->ChildCount();
+
+                  nsSize  rowFrameSize;
+
+                  rowFrameToBeResized->GetSize(rowFrameSize);
+                  rowFrameToBeResized->SizeTo(rowFrameSize.width, rowHeights[i]);
+                  PRInt32 cellCount;
+
+                  rowFrameToBeResized->ChildCount(cellCount);
                   for (PRInt32 j=0; j<cellCount; j++)
                   {
                     if (i==rowIndex && j==cellIndex)
@@ -2087,11 +2161,16 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
                       if (gsDebug==PR_TRUE) printf("      cell[%d, %d] skipping self\n", i, j);
                       continue; // don't do math on myself, only the other cells I effect
                     }
-                    nsTableCellFrame *frame = (nsTableCellFrame *)(rowFrameToBeResized->ChildAt(j));
+                    nsTableCellFrame *frame;
+
+                    rowFrameToBeResized->ChildAt(j, (nsIFrame*&)frame);
                     if (frame->GetRowSpan()==1)
                     {
-                      if (gsDebug==PR_TRUE) printf("      cell[%d, %d] set height to %d\n", i, j, frame->GetHeight()+excessHeightPerRow);
-                      frame->SizeTo(frame->GetWidth(), frame->GetHeight()+excessHeightPerRow);
+                      nsSize  frameSize;
+
+                      frame->GetSize(frameSize);
+                      if (gsDebug==PR_TRUE) printf("      cell[%d, %d] set height to %d\n", i, j, frameSize.height+excessHeightPerRow);
+                      frame->SizeTo(frameSize.width, frameSize.height+excessHeightPerRow);
                       // Realign cell content based on new height
                       frame->VerticallyAlignChild(aPresContext);
                     }
@@ -2101,7 +2180,9 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
                 // push that row down by the amount we've expanded the cell heights by
                 if (i>rowIndex)
                 {
-                  nsRect rowRect = rowFrameToBeResized->GetRect();
+                  nsRect rowRect;
+                   
+                  rowFrameToBeResized->GetRect(rowRect);
                   rowFrameToBeResized->MoveTo(rowRect.x, rowRect.y + (excessHeightPerRow*(i-rowIndex)));
                   if (gsDebug==PR_TRUE) printf("      row %d moved to y-offset %d\n", i, 
                                                 rowRect.y + (excessHeightPerRow*(i-rowIndex)));
@@ -2113,7 +2194,11 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
         rowGroupHeight += rowHeights[rowIndex];
       }
       if (gsDebug==PR_TRUE) printf("row group height set to %d\n", rowGroupHeight);
-      rowGroupFrame->SizeTo(rowGroupFrame->GetWidth(), rowGroupHeight);
+
+      nsSize  rowGroupFrameSize;
+
+      rowGroupFrame->GetSize(rowGroupFrameSize);
+      rowGroupFrame->SizeTo(rowGroupFrameSize.width, rowGroupHeight);
       tableHeight += rowGroupHeight;
     }
     NS_RELEASE(kid);                                                  // kid: REFCNT--
@@ -2139,11 +2224,11 @@ PRBool nsTableFrame::IsProportionalWidth(nsStyleMolecule* aMol)
 
 /**
   */
-nsIFrame::ReflowStatus
-nsTableFrame::IncrementalReflow(nsIPresContext*  aCX,
-                              nsReflowMetrics& aDesiredSize,
-                              const nsSize&    aMaxSize,
-                              nsReflowCommand& aReflowCommand)
+NS_METHOD nsTableFrame::IncrementalReflow(nsIPresContext*  aCX,
+                                          nsReflowMetrics& aDesiredSize,
+                                          const nsSize&    aMaxSize,
+                                          nsReflowCommand& aReflowCommand,
+                                          ReflowStatus&    aStatus)
 {
   NS_ASSERTION(nsnull != aCX, "bad arg");
   if (gsDebug==PR_TRUE) printf ("nsTableFrame::IncrementalReflow: maxSize=%d,%d\n",
@@ -2153,7 +2238,8 @@ nsTableFrame::IncrementalReflow(nsIPresContext*  aCX,
 
   aDesiredSize.width = mRect.width;
   aDesiredSize.height = mRect.height;
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
 void nsTableFrame::VerticallyAlignChildren(nsIPresContext* aPresContext,
@@ -2294,7 +2380,9 @@ nsCellLayoutData * nsTableFrame::GetCellLayoutData(nsTableCell *aCell)
       for (PRInt32 i=0; i<count; i++)
       {
         nsCellLayoutData * data = (nsCellLayoutData *)(cells->ElementAt(i));
-        nsTableCell *cell = (nsTableCell *)(data->GetCellFrame()->GetContent());  // cell: REFCNT++
+        nsTableCell *cell;
+         
+        data->GetCellFrame()->GetContent((nsIContent*&)cell);  // cell: REFCNT++
         if (cell == aCell)
         {
           result = data;
@@ -2345,18 +2433,21 @@ PRBool nsTableFrame::AutoColumnWidths(nsStyleMolecule* aTableStyleMol)
   return isAutoColumnWidths;
 }
 
-nsIFrame* nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                              nsIFrame*       aParent)
+NS_METHOD nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                              nsIFrame*       aParent,
+                                              nsIFrame*&      aContinuingFrame)
 {
   nsTableFrame* cf = new nsTableFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
   if (PR_TRUE==gsDebug) printf("nsTableFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
   // set my width, because all frames in a table flow are the same width
   // code in nsTableOuterFrame depends on this being set
-  cf->SetRect(nsRect(0, 0, GetWidth(), 0));
+  cf->SetRect(nsRect(0, 0, mRect.width, 0));
   // add headers and footers to cf
   nsTableFrame * firstInFlow = (nsTableFrame *)GetFirstInFlow();
-  PRInt32 childCount = firstInFlow->ChildCount();
+  PRInt32 childCount;
+   
+  firstInFlow->ChildCount(childCount);
   PRInt32 childIndex = 0;
   for (; childIndex < childCount; childIndex++)
   {
@@ -2364,7 +2455,8 @@ nsIFrame* nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
     // maybe need to do this in ResizeReflow at the beginning, when we determine we are a continuing frame
   }
 
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 PRInt32 nsTableFrame::GetColumnWidth(PRInt32 aColIndex)
diff --git a/mozilla/layout/html/table/src/nsTableFrame.h b/mozilla/layout/html/table/src/nsTableFrame.h
index 29902151fe6..23ace38b50d 100644
--- a/mozilla/layout/html/table/src/nsTableFrame.h
+++ b/mozilla/layout/html/table/src/nsTableFrame.h
@@ -59,9 +59,9 @@ public:
                            nsIFrame*   aParent);
 
   /** @see nsIFrame::Paint */
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
   /** inner tables are reflowed in two steps.
     * <pre>
@@ -81,20 +81,23 @@ public:
     * @see BalanceColumnWidths
     * @see nsIFrame::ResizeReflow 
     */
-  virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize& aMaxSize,
-                                    nsSize* aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize& aMaxSize,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
 
   /** @see nsIFrame::IncrementalReflow */
-  virtual ReflowStatus  IncrementalReflow(nsIPresContext* aPresContext,
-                                          nsReflowMetrics& aDesiredSize,
-                                          const nsSize&    aMaxSize,
-                                          nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus& aStatus);
 
   /** @see nsContainerFrame::CreateContinuingFrame */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
   /** resize myself and my children according to the arcane rules of cell height magic. 
     * By default, the height of a cell is the max (height of cells in its row)
diff --git a/mozilla/layout/html/table/src/nsTableOuterFrame.cpp b/mozilla/layout/html/table/src/nsTableOuterFrame.cpp
index cb926a50202..f6c4d8667eb 100644
--- a/mozilla/layout/html/table/src/nsTableOuterFrame.cpp
+++ b/mozilla/layout/html/table/src/nsTableOuterFrame.cpp
@@ -122,9 +122,9 @@ nsTableOuterFrame::~nsTableOuterFrame()
     delete mBottomCaptions;
 }
 
-void nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
-                               nsIRenderingContext& aRenderingContext,
-                               const nsRect& aDirtyRect)
+NS_METHOD nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
+                                   nsIRenderingContext& aRenderingContext,
+                                   const nsRect& aDirtyRect)
 {
   // for debug...
   if (nsIFrame::GetShowFrameBorders()) {
@@ -133,6 +133,7 @@ void nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 PRBool nsTableOuterFrame::NeedsReflow(const nsSize& aMaxSize)
@@ -163,10 +164,11 @@ void nsTableOuterFrame::SetFirstPassValid(PRBool aValidState)
   * NOTE: for breaking across pages, this method has to account for table content that is not laid out
   *       linearly vis a vis the frames.  That is, content hierarchy and the frame hierarchy do not match.
   */
-nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresContext,
-                                                       nsReflowMetrics& aDesiredSize,
-                                                       const nsSize& aMaxSize,
-                                                       nsSize* aMaxElementSize)
+NS_METHOD nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                          nsReflowMetrics& aDesiredSize,
+                                          const nsSize& aMaxSize,
+                                          nsSize* aMaxElementSize,
+                                          ReflowStatus& aStatus)
 {
   if (PR_TRUE==gsDebug) 
     printf ("***table outer frame reflow \t\t%p\n", this);
@@ -185,8 +187,9 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
     aMaxElementSize->height = 0;
   }
 
-  PRBool        reflowMappedOK = PR_TRUE;
-  ReflowStatus  status = frComplete;
+  PRBool  reflowMappedOK = PR_TRUE;
+
+  aStatus = frComplete;
   nsSize innerTableMaxElementSize(0,0);
 
   // Set up our kids.  They're already present, on an overflow list, 
@@ -201,8 +204,11 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   // at this point, we must have at least one child frame, and we must have an inner table frame
   NS_ASSERTION(nsnull!=mFirstChild, "no children");
   NS_ASSERTION(nsnull!=mInnerTableFrame, "no mInnerTableFrame");
-  if (nsnull==mFirstChild  ||  nsnull==mInnerTableFrame) //ERROR!
-    return frComplete;
+  if (nsnull==mFirstChild  ||  nsnull==mInnerTableFrame) {
+    //ERROR!
+    aStatus = frComplete;
+    return NS_OK;
+  }
 
   nsStyleMolecule* tableStyleMol =
     (nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
@@ -213,7 +219,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   if (PR_FALSE==IsFirstPassValid())
   {
     mFirstPassValid = PR_TRUE;
-    status = ResizeReflowCaptionsPass1(aPresContext, tableStyleMol);
+    aStatus = ResizeReflowCaptionsPass1(aPresContext, tableStyleMol);
 
   }
 
@@ -221,8 +227,8 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   if (PR_FALSE==mInnerTableFrame->IsFirstPassValid())
   { // we treat the table as if we've never seen the layout data before
     mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_FIRST);
-    status = mInnerTableFrame->ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, 
-                                                 &innerTableMaxElementSize, tableStyleMol);
+    aStatus = mInnerTableFrame->ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, 
+                                                  &innerTableMaxElementSize, tableStyleMol);
   
 #ifdef NOISY_MARGINS
     nsIContent* content = mInnerTableFrame->GetContent();
@@ -237,7 +243,10 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   }
   mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_SECOND);
   // assign table width info only if the inner table frame is a first-in-flow
-  if (nsnull==mInnerTableFrame->GetPrevInFlow())
+  nsIFrame* prevInFlow;
+
+  mInnerTableFrame->GetPrevInFlow(prevInFlow);
+  if (nsnull==prevInFlow)
   {
     // assign column widths, and assign aMaxElementSize->width
     mInnerTableFrame->BalanceColumnWidths(aPresContext, tableStyleMol, aMaxSize, aMaxElementSize);
@@ -245,14 +254,17 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
     mInnerTableFrame->SetTableWidth(aPresContext, tableStyleMol);
   }
   // inner table max is now the computed width and assigned  height
-  state.innerTableMaxSize.width = mInnerTableFrame->GetWidth();
+  nsSize  innerTableSize;
+
+  mInnerTableFrame->GetSize(innerTableSize);
+  state.innerTableMaxSize.width = innerTableSize.width;
   state.innerTableMaxSize.height = aMaxSize.height; 
 
   // Reflow the child frames
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aPresContext, state, aMaxElementSize);
     if (PR_FALSE == reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -262,7 +274,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
     if (state.availSize.height <= 0) {
       // No space left. Don't try to pull-up children or reflow unmapped
       if (NextChildOffset() < mContent->ChildCount()) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (NextChildOffset() < mContent->ChildCount()) {
       // Try and pull-up some children from a next-in-flow
@@ -271,12 +283,12 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
         NS_ABORT(); // huge error for tables!
       } else {
         // We were unable to pull-up all the existing frames from the next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there's room for it.
     nscoord margin = state.prevMaxPosBottomMargin -
@@ -320,7 +332,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   */
   // end REMOVE ME!
 
-  return status;
+  return NS_OK;
 
 }
 
@@ -442,7 +454,9 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
                                   kidFrame, aState.processingCaption?"caption":"inner");
 
     // Get top margin for this kid
-    nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+    nsIStyleContext* kidSC;
+
+    kidFrame->GetStyleContext(aPresContext, kidSC);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
     nscoord bottomMargin = kidMol->margin.bottom;
@@ -505,17 +519,22 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No, the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+
+      kidFrame->GetNextInFlow(kidNextInFlow);
       PRBool lastContentIsComplete = mLastContentIsComplete;
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         if (nsnull == nextSib) {
@@ -528,7 +547,9 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
 
       // We've used up all of our available space so push the remaining
       // children to the next-in-flow
-      nsIFrame* nextSibling = kidFrame->GetNextSibling();
+      nsIFrame* nextSibling;
+       
+      kidFrame->GetNextSibling(nextSibling);
       if (nsnull != nextSibling) {
         PushChildren(nextSibling, kidFrame, lastContentIsComplete);
         SetLastContentOffset(prevKidFrame);
@@ -538,7 +559,7 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
     }
 
     // Get the next child
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
 
     // XXX talk with troy about checking for available space here
   }
@@ -548,7 +569,7 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
   NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
 
   // Set the last content offset based on the last child we mapped.
-  NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
   SetLastContentOffset(prevKidFrame);
 
 #ifdef NS_DEBUG
@@ -615,7 +636,9 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
 #ifdef NS_DEBUG
   PRInt32        kidIndex = NextChildOffset();
 #endif
-  nsIFrame*      prevKidFrame = LastChild();
+  nsIFrame*      prevKidFrame;
+   
+  LastChild(prevKidFrame);
 
   // This will hold the prevKidFrame's mLastContentIsComplete
   // status. If we have to push the frame that follows prevKidFrame
@@ -644,7 +667,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
         kidFrame = nextInFlow->mFirstChild;
       } else {
         // We've pulled up all the children, so move to the next-in-flow.
-        nextInFlow = (nsTableOuterFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
         continue;
       }
     }
@@ -652,8 +675,13 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
     // See if the child fits in the available space. If it fits or
     // it's splittable then reflow it. The reason we can't just move
     // it is that we still need ascent/descent information
-    if ((kidFrame->GetWidth() > aState.availSize.height) &&
-        !kidFrame->IsSplittable()) {
+    nsSize  kidFrameSize;
+    PRBool  kidIsSplittable;
+
+    kidFrame->GetSize(kidFrameSize);
+    kidFrame->IsSplittable(kidIsSplittable);
+
+    if ((kidFrameSize.width  > aState.availSize.height) && !kidIsSplittable) {
       result = PR_FALSE;
       mLastContentIsComplete = prevLastContentIsComplete;
       break;
@@ -678,7 +706,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
     PlaceChild(aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
 
     // Remove the frame from its current parent
-    nextInFlow->mFirstChild = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(nextInFlow->mFirstChild);
     nextInFlow->mChildCount--;
     // Update the next-in-flows first content offset
     if (nsnull != nextInFlow->mFirstChild) {
@@ -687,7 +715,10 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
 
     // Link the frame into our list of children
     kidFrame->SetGeometricParent(this);
-    if (nextInFlow == kidFrame->GetContentParent()) {
+    nsIFrame* kidContentParent;
+
+    kidFrame->GetContentParent(kidContentParent);
+    if (nextInFlow == kidContentParent) {
       kidFrame->SetContentParent(this);
     }
     if (nsnull == prevKidFrame) {
@@ -707,13 +738,16 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a
         // continuing frame. The creation appends it to the flow and
         // prepares it for reflow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to our sibling list and then push
@@ -741,7 +775,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
 
   // Update our last content offset
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -761,7 +795,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
       // the next-in-flows must be empty. Do a sanity check
       while (nsnull != nextInFlow) {
         NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
-        nextInFlow = (nsTableOuterFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
       }
 #endif
     }
@@ -799,7 +833,9 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
   */
 void nsTableOuterFrame::SetReflowState(OuterTableReflowState& aState, nsIFrame* aKidFrame)
 {
-  nsIContent *kid = aKidFrame->GetContent();                             // kid: REFCNT++
+  nsIContent *kid;
+   
+  aKidFrame->GetContent(kid);                             // kid: REFCNT++
   nsITableContent *tableContentInterface = nsnull;
   kid->QueryInterface(kITableContentIID, (void**)&tableContentInterface);// tableContentInterface: REFCNT++
   if (nsnull!=tableContentInterface)
@@ -832,7 +868,9 @@ nsTableOuterFrame::ReflowChild( nsIFrame*        aKidFrame,
   if (PR_TRUE==aState.processingCaption)
   { // it's a caption, find out if it's top or bottom
     // Resolve style
-    nsIStyleContext* captionStyleContext = aKidFrame->GetStyleContext(aPresContext);
+    nsIStyleContext* captionStyleContext;
+
+    aKidFrame->GetStyleContext(aPresContext, captionStyleContext);
     NS_ASSERTION(nsnull != captionStyleContext, "null style context for caption");
     nsStyleMolecule* captionStyle =
       (nsStyleMolecule*)captionStyleContext->GetData(kStyleMoleculeSID);
@@ -852,13 +890,16 @@ nsTableOuterFrame::ReflowChild( nsIFrame*        aKidFrame,
                                                            mMinCaptionWidth, mMaxCaptionWidth);
 
   if (frComplete == status) {
-    nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow();
+    nsIFrame* kidNextInFlow;
+     
+    aKidFrame->GetNextInFlow(kidNextInFlow);
     if (nsnull != kidNextInFlow) {
       // Remove all of the childs next-in-flows. Make sure that we ask
       // the right parent to do the removal (it's possible that the
       // parent is not this because we are executing pullup code)
-      nsTableOuterFrame* parent = (nsTableOuterFrame*)
-        aKidFrame->GetGeometricParent();
+      nsTableOuterFrame* parent;
+       
+      aKidFrame->GetGeometricParent((nsIFrame*&)parent);
       parent->DeleteChildsNextInFlow(aKidFrame);
     }
   }
@@ -956,7 +997,8 @@ nsTableOuterFrame::ResizeReflowCaptionsPass1(nsIPresContext* aPresContext, nsSty
       nsSize maxSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
       nsReflowMetrics desiredSize;
       nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);
-      captionFrame->ResizeReflow(aPresContext, desiredSize, maxSize, &maxElementSize);
+      ReflowStatus  status;
+      captionFrame->ResizeReflow(aPresContext, desiredSize, maxSize, &maxElementSize, status);
       if (mMinCaptionWidth<maxElementSize.width)
         mMinCaptionWidth = maxElementSize.width;
       if (mMaxCaptionWidth<desiredSize.width)
@@ -986,7 +1028,9 @@ nsTableOuterFrame::ResizeReflowTopCaptionsPass2(nsIPresContext*  aPresContext,
       nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);
 
       // Resolve style
-      nsIStyleContext* captionStyleContext = captionFrame->GetStyleContext(aPresContext);
+      nsIStyleContext* captionStyleContext;
+       
+      captionFrame->GetStyleContext(aPresContext, captionStyleContext);
       NS_ASSERTION(nsnull != captionStyleContext, "null style context for caption");
       nsStyleMolecule* captionStyle =
         (nsStyleMolecule*)captionStyleContext->GetData(kStyleMoleculeSID);
@@ -1009,7 +1053,10 @@ nsTableOuterFrame::ResizeReflowTopCaptionsPass2(nsIPresContext*  aPresContext,
           else
             topCaptionY = NS_UNCONSTRAINEDSIZE;
           mInnerTableFrame->MoveTo(0, topCaptionY);
-          if (0==captionFrame->GetIndexInParent())
+          PRInt32 captionIndexInParent;
+
+          captionFrame->GetIndexInParent(captionIndexInParent);
+          if (0==captionIndexInParent)
           {
             SetFirstContentOffset(captionFrame);
             if (gsDebug) printf("OUTER: set first content offset to %d\n", GetFirstContentOffset()); //@@@
@@ -1061,7 +1108,9 @@ nsTableOuterFrame::ResizeReflowBottomCaptionsPass2(nsIPresContext*  aPresContext
       result = nsContainerFrame::ReflowChild(captionFrame, aPresContext, desiredSize, aMaxSize, nsnull);
 
       // place the caption
-      nsRect rect = captionFrame->GetRect();
+      nsRect rect;
+       
+      captionFrame->GetRect(rect);
       rect.y = bottomCaptionY;
       rect.width=desiredSize.width;
       rect.height=desiredSize.height;
@@ -1114,27 +1163,29 @@ void nsTableOuterFrame::SetLastContentOffset(const nsIFrame* aLastChild)
 }
 */
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableOuterFrame::IncrementalReflow(nsIPresContext* aPresContext,
                                     nsReflowMetrics& aDesiredSize,
                                     const nsSize&    aMaxSize,
-                                    nsReflowCommand& aReflowCommand)
+                                    nsReflowCommand& aReflowCommand,
+                                     ReflowStatus&   aStatus)
 {
   if (gsDebug == PR_TRUE) printf("nsTableOuterFrame::IncrementalReflow\n");
   // total hack for now, just some hard-coded values
-  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
-
-  return frComplete;
+  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
+  return NS_OK;
 }
 
-nsIFrame* nsTableOuterFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                   nsIFrame*       aParent)
+NS_METHOD nsTableOuterFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                   nsIFrame*       aParent,
+                                                   nsIFrame*&      aContinuingFrame)
 {
   nsTableOuterFrame* cf = new nsTableOuterFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
   cf->SetFirstPassValid(PR_TRUE);
   printf("nsTableOuterFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 void nsTableOuterFrame::PrepareContinuingFrame(nsIPresContext*    aPresContext,
@@ -1169,11 +1220,12 @@ void nsTableOuterFrame::PrepareContinuingFrame(nsIPresContext*    aPresContext,
   NS_RELEASE(styleContext);
 }
 
-void nsTableOuterFrame::VerifyTree() const
+NS_METHOD nsTableOuterFrame::VerifyTree() const
 {
 #ifdef NS_DEBUG
   
 #endif 
+  return NS_OK;
 }
 
 /**
@@ -1191,28 +1243,44 @@ void nsTableOuterFrame::VerifyTree() const
  */
 PRBool nsTableOuterFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
 {
-  NS_PRECONDITION(aChild->GetGeometricParent() == (nsIFrame*)this, "bad geometric parent");
-  NS_PRECONDITION(nsnull != aChild->GetNextInFlow(), "null next-in-flow");
+  NS_PRECONDITION(IsChild(aChild), "bad geometric parent");
 
-  nsIFrame*         nextInFlow = aChild->GetNextInFlow();
-  nsTableOuterFrame* parent = (nsTableOuterFrame*)nextInFlow->GetGeometricParent();
+  nsIFrame* nextInFlow;
+   
+  aChild->GetNextInFlow(nextInFlow);
+
+  NS_PRECONDITION(nsnull != nextInFlow, "null next-in-flow");
+  nsTableOuterFrame* parent;
+   
+  nextInFlow->GetGeometricParent((nsIFrame*&)parent);
 
   // If the next-in-flow has a next-in-flow then delete it too (and
   // delete it first).
-  if (nsnull != nextInFlow->GetNextInFlow()) {
+  nsIFrame* nextNextInFlow;
+
+  nextInFlow->GetNextInFlow(nextNextInFlow);
+  if (nsnull != nextNextInFlow) {
     parent->DeleteChildsNextInFlow(nextInFlow);
   }
 
-  NS_ASSERTION((0 == nextInFlow->ChildCount()) &&
-               (nsnull == nextInFlow->FirstChild()),
-               "deleting !empty next-in-flow");
+#ifdef NS_DEBUG
+  PRInt32   childCount;
+  nsIFrame* firstChild;
+
+  nextInFlow->ChildCount(childCount);
+  nextInFlow->FirstChild(firstChild);
+
+  NS_ASSERTION(childCount == 0, "deleting !empty next-in-flow");
+
+  NS_ASSERTION((0 == childCount) && (nsnull == firstChild), "deleting !empty next-in-flow");
+#endif
 
   // Disconnect the next-in-flow from the flow list
   nextInFlow->BreakFromPrevFlow();
 
   // Take the next-in-flow out of the parent's child list
   if (parent->mFirstChild == nextInFlow) {
-    parent->mFirstChild = nextInFlow->GetNextSibling();
+    nextInFlow->GetNextSibling(parent->mFirstChild);
     if (nsnull != parent->mFirstChild) {
       parent->SetFirstContentOffset(parent->mFirstChild);
       if (parent->IsPseudoFrame()) {
@@ -1229,22 +1297,30 @@ PRBool nsTableOuterFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
     // will be repaired.
 
   } else {
+    nsIFrame* nextSibling;
+
     // Because the next-in-flow is not the first child of the parent
     // we know that it shares a parent with aChild. Therefore, we need
     // to capture the next-in-flow's next sibling (in case the
     // next-in-flow is the last next-in-flow for aChild AND the
     // next-in-flow is not the last child in parent)
-    NS_ASSERTION(aChild->GetGeometricParent() == parent, "screwy flow");
-    NS_ASSERTION(aChild->GetNextSibling() == nextInFlow, "unexpected sibling");
+    NS_ASSERTION(parent->IsChild(aChild), "screwy flow");
+    aChild->GetNextSibling(nextSibling);
+    NS_ASSERTION(nextSibling == nextInFlow, "unexpected sibling");
 
-    aChild->SetNextSibling(nextInFlow->GetNextSibling());
+    nextInFlow->GetNextSibling(nextSibling);
+    aChild->SetNextSibling(nextSibling);
   }
 
   // Delete the next-in-flow frame and adjust it's parent's child count
   nextInFlow->DeleteFrame();
   parent->mChildCount--;
 
-  NS_POSTCONDITION(nsnull == aChild->GetNextInFlow(), "non null next-in-flow");
+#ifdef NS_DEBUG
+  aChild->GetNextInFlow(nextInFlow);
+  NS_POSTCONDITION(nsnull == nextInFlow, "non null next-in-flow");
+#endif
+
   return PR_TRUE;
 }
 
@@ -1268,10 +1344,13 @@ void nsTableOuterFrame::CreateInnerTableFrame(nsIPresContext* aPresContext)
     nsIFrame* prevInnerTable = prevOuterTable->mInnerTableFrame;
 
     // Create a continuing column
-    mInnerTableFrame = (nsTableFrame *)prevInnerTable->GetNextInFlow();
+    prevInnerTable->GetNextInFlow((nsIFrame*&)mInnerTableFrame);
     if (nsnull==mInnerTableFrame)
     {
-      mInnerTableFrame = (nsTableFrame *)prevInnerTable->CreateContinuingFrame(aPresContext, this);
+      nsIFrame* continuingFrame;
+
+      prevInnerTable->CreateContinuingFrame(aPresContext, this, continuingFrame);
+      mInnerTableFrame = (nsTableFrame*)continuingFrame;
       mChildCount++;
     }
   }
diff --git a/mozilla/layout/html/table/src/nsTableOuterFrame.h b/mozilla/layout/html/table/src/nsTableOuterFrame.h
index e4967ec41b0..041f43c25fa 100644
--- a/mozilla/layout/html/table/src/nsTableOuterFrame.h
+++ b/mozilla/layout/html/table/src/nsTableOuterFrame.h
@@ -56,9 +56,9 @@ public:
                            nsIFrame*   aParent);
 
   /** @see nsIFrame::Paint */
-  virtual void  Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
   /** outer tables are reflowed in two steps.
     * Step 1:, we lay out all of the captions and the inner table with
@@ -85,20 +85,23 @@ public:
     * @see nsTableFrame::BalanceColumnWidths
     * @see nsIFrame::ResizeReflow 
     */
-  ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&    aMaxSize,
-                             nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&    aMaxSize,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
   /** @see nsIFrame::IncrementalReflow */
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
   /** @see nsContainerFrame */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
   /** destructor */
   virtual ~nsTableOuterFrame();
 
@@ -205,7 +208,7 @@ protected:
   /** overridden here to handle special caption-table relationship
     * @see nsContainerFrame::VerifyTree
     */
-  virtual void VerifyTree() const;
+  NS_IMETHOD VerifyTree() const;
 
   /** overridden here to handle special caption-table relationship
     * @see nsContainerFrame::PrepareContinuingFrame
diff --git a/mozilla/layout/html/table/src/nsTableRowFrame.cpp b/mozilla/layout/html/table/src/nsTableRowFrame.cpp
index a38993f7956..e493d706124 100644
--- a/mozilla/layout/html/table/src/nsTableRowFrame.cpp
+++ b/mozilla/layout/html/table/src/nsTableRowFrame.cpp
@@ -63,9 +63,9 @@ void nsTableRowFrame::SetMaxChildHeight(PRInt32 aChildHeight)
     mTallestCell = aChildHeight;
 }
 
-void nsTableRowFrame::Paint(nsIPresContext& aPresContext,
-                            nsIRenderingContext& aRenderingContext,
-                            const nsRect& aDirtyRect)
+NS_METHOD nsTableRowFrame::Paint(nsIPresContext& aPresContext,
+                                 nsIRenderingContext& aRenderingContext,
+                                 const nsRect& aDirtyRect)
 {
   // for debug...
   if (nsIFrame::GetShowFrameBorders()) {
@@ -74,6 +74,7 @@ void nsTableRowFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 // aDirtyRect is in our coordinate system
@@ -87,7 +88,9 @@ void nsTableRowFrame::PaintChildren(nsIPresContext&      aPresContext,
 {
   nsIFrame* kid = mFirstChild;
   while (nsnull != kid) {
-    nsIView *pView = kid->GetView();
+    nsIView *pView;
+     
+    kid->GetView(pView);
     if (nsnull == pView) {
       nsRect kidRect;
       kid->GetRect(kidRect);
@@ -103,10 +106,10 @@ void nsTableRowFrame::PaintChildren(nsIPresContext&      aPresContext,
         aRenderingContext.DrawRect(0, 0, kidRect.width, kidRect.height);
       }
       aRenderingContext.PopState();
-    }
-    else
+    } else {
       NS_RELEASE(pView);
-    kid = kid->GetNextSibling();
+    }
+    kid->GetNextSibling(kid);
   }
 }
 
@@ -129,11 +132,12 @@ are present.
   * This method stacks rows horizontally according to HTML 4.0 rules.
   * Rows are responsible for layout of their children.
   */
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
                               nsReflowMetrics& aDesiredSize,
                               const nsSize&    aMaxSize,
-                              nsSize*          aMaxElementSize)
+                              nsSize*          aMaxElementSize,
+                              ReflowStatus&    aStatus)
 {
   if (gsDebug1==PR_TRUE) 
     printf("nsTableRowFrame::ResizeReflow - %p with aMaxSize = %d, %d\n",
@@ -145,7 +149,7 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
   PRInt32 maxCellHeight = 0;
   ResetMaxChildHeight();
 
-  ReflowStatus result = frComplete;
+  aStatus = frComplete;
 
   mFirstContentOffset = mLastContentOffset = 0;
 
@@ -165,17 +169,21 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
 
 // Row doesn't factor in insets, the cells do that
 
-  nsTableFrame *tableFrame = (nsTableFrame *)(GetContentParent()->GetContentParent());
+  nsTableFrame *tableFrame;
+   
+  mContentParent->GetContentParent((nsIFrame*&)tableFrame);
 
   for (;;) {
     nsIContent* kid = c->ChildAt(kidIndex);   // kid: REFCNT++
     if (nsnull == kid) {
-      result = frComplete;
+      aStatus = frComplete;
       break;
     }
 
     // get frame, creating one if needed
-    nsIFrame* kidFrame = ChildAt(kidIndex);
+    nsIFrame* kidFrame;
+     
+    ChildAt(kidIndex, kidFrame);
     if (nsnull==kidFrame)
     {
       nsIContentDelegate* kidDel;
@@ -191,20 +199,24 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
       NS_RELEASE(kidStyleContext);
     }
 
-    nsTableCell* cell = (nsTableCell *)(kidFrame->GetContent());  // cell: ADDREF++
+    nsTableCell* cell;
+     
+    kidFrame->GetContent((nsIContent*&)cell);  // cell: ADDREF++
     // Try to reflow the child into the available space.
     if (NS_UNCONSTRAINEDSIZE == availSize.width)
     {  // Each cell is given the entire row width to try to lay out into
-      result = ReflowChild(kidFrame, aPresContext, kidSize, availSize, &kidMaxSize);
+      aStatus = ReflowChild(kidFrame, aPresContext, kidSize, availSize, &kidMaxSize);
       if (gsDebug1) printf("reflow of cell returned result = %s with desired=%d,%d, min = %d,%d\n",
-                            result==frComplete?"complete":"NOT complete", 
+                            aStatus==frComplete?"complete":"NOT complete", 
                             kidSize.width, kidSize.height, kidMaxSize.width, kidMaxSize.height);
       nsCellLayoutData kidLayoutData((nsTableCellFrame *)kidFrame, &kidSize, &kidMaxSize);
       tableFrame->SetCellLayoutData(&kidLayoutData, cell);
     }
     else
     { // we're in a constrained situation, so get the avail width from the known column widths
-      nsTableFrame *innerTableFrame = (nsTableFrame *)(GetContentParent()->GetContentParent());
+      nsTableFrame *innerTableFrame;
+       
+      mContentParent->GetContentParent((nsIFrame*&)innerTableFrame);
       nsCellLayoutData *cellData = innerTableFrame->GetCellLayoutData(cell);
       PRInt32 cellStartingCol = cell->GetColIndex();
       PRInt32 cellColSpan = cell->GetColSpan();
@@ -213,9 +225,9 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
         availWidth += innerTableFrame->GetColumnWidth(cellStartingCol+numColSpan);
       NS_ASSERTION(0<availWidth, "illegal width for this column");
       nsSize availSizeWithSpans(availWidth, availSize.height);
-      result = ReflowChild(kidFrame, aPresContext, kidSize, availSizeWithSpans, &kidMaxSize);
+      aStatus = ReflowChild(kidFrame, aPresContext, kidSize, availSizeWithSpans, &kidMaxSize);
       if (gsDebug1) printf("reflow of cell returned result = %s with desired=%d,%d, min = %d,%d\n",
-                            result==frComplete?"complete":"NOT complete", 
+                            aStatus==frComplete?"complete":"NOT complete", 
                             kidSize.width, kidSize.height, kidMaxSize.width, kidMaxSize.height);
 
       // SEC: TODO: this next block could be smarter, 
@@ -268,7 +280,7 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
     prevKidFrame = kidFrame;
 
     kidIndex++;
-    if (frNotComplete == result) {
+    if (frNotComplete == aStatus) {
       // If the child didn't finish layout then it means that it used
       // up all of our available space (or needs us to split).
       mLastContentIsComplete = PR_FALSE;
@@ -278,12 +290,11 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
   }
 
   if (nsnull != prevKidFrame) {
-    if (LastChild()!=prevKidFrame)
+    if (!IsLastChild(prevKidFrame))
     {
-      nsIFrame * frame = LastChild();
-      GetGeometricParent()->List();
+      mGeometricParent->List();
     }
-    NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -298,46 +309,48 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
   SetMaxChildHeight(maxCellHeight);  // remember height of tallest child who doesn't have a row span
 
 #ifdef NS_DEBUG
-  PostReflowCheck(result);
+  PostReflowCheck(aStatus);
 #endif
 
   if (gsDebug1==PR_TRUE) 
   {
     if (nsnull!=aMaxElementSize)
       printf("nsTableRowFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=%d,%d\n",
-              result==frComplete?"Complete":"Not Complete",
+              aStatus==frComplete?"Complete":"Not Complete",
               aDesiredSize.width, aDesiredSize.height,
               aMaxElementSize->width, aMaxElementSize->height);
     else
       printf("nsTableRowFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=NSNULL\n", 
-             result==frComplete?"Complete":"Not Complete",
+             aStatus==frComplete?"Complete":"Not Complete",
              aDesiredSize.width, aDesiredSize.height);
   }
   
   // testing...
-  result = frComplete;
-
-  return result;
-
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableRowFrame::IncrementalReflow(nsIPresContext*  aPresContext,
                              nsReflowMetrics& aDesiredSize,
                              const nsSize&    aMaxSize,
-                             nsReflowCommand& aReflowCommand)
+                             nsReflowCommand& aReflowCommand,
+                             ReflowStatus&    aStatus)
 {
   if (gsDebug1==PR_TRUE) printf("nsTableRowFrame::IncrementalReflow\n");
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame* nsTableRowFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                 nsIFrame*       aParent)
+NS_METHOD nsTableRowFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                 nsIFrame*       aParent,
+                                                 nsIFrame*&      aContinuingFrame)
 {
   if (gsDebug1==PR_TRUE) printf("nsTableRowFrame::CreateContinuingFrame\n");
   nsTableRowFrame* cf = new nsTableRowFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 nsresult nsTableRowFrame::NewFrame( nsIFrame** aInstancePtrResult,
diff --git a/mozilla/layout/html/table/src/nsTableRowFrame.h b/mozilla/layout/html/table/src/nsTableRowFrame.h
index 240be6deeed..20446c32384 100644
--- a/mozilla/layout/html/table/src/nsTableRowFrame.h
+++ b/mozilla/layout/html/table/src/nsTableRowFrame.h
@@ -52,9 +52,9 @@ public:
                            nsIFrame*   aParent);
 
   /** @see nsIFrame::Paint */
-  virtual void  Paint(nsIPresContext&      aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect&        aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext&      aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect&        aDirtyRect);
 
 
   /** ask all children to paint themselves, without clipping (for cells with rowspan>1)
@@ -77,20 +77,23 @@ public:
     * @see nsTableFrame::BalanceColumnWidths
     * @see nsTableFrame::ShrinkWrapChildren
     */
-  ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&    aMaxSize,
-                             nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&    aMaxSize,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
   /** @see nsIFrame::IncrementalReflow */
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
   /** @see nsContainerFrame::CreateContinuingFrame */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
   
   /** set mTallestCell to 0 in anticipation of recalculating it */
   void ResetMaxChildHeight();
diff --git a/mozilla/layout/html/table/src/nsTableRowGroupFrame.cpp b/mozilla/layout/html/table/src/nsTableRowGroupFrame.cpp
index 05eb5f4e21c..db5ef6cb8f9 100644
--- a/mozilla/layout/html/table/src/nsTableRowGroupFrame.cpp
+++ b/mozilla/layout/html/table/src/nsTableRowGroupFrame.cpp
@@ -102,9 +102,9 @@ nsTableRowGroupFrame::~nsTableRowGroupFrame()
 }
 
 
-void nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
-                                 nsIRenderingContext& aRenderingContext,
-                                 const nsRect&        aDirtyRect)
+NS_METHOD nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
+                                      nsIRenderingContext& aRenderingContext,
+                                      const nsRect&        aDirtyRect)
 {
 
   // for debug...
@@ -114,6 +114,7 @@ void nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 // aDirtyRect is in our coordinate system
@@ -127,7 +128,9 @@ void nsTableRowGroupFrame::PaintChildren(nsIPresContext&      aPresContext,
 {
   nsIFrame* kid = mFirstChild;
   while (nsnull != kid) {
-    nsIView *pView = kid->GetView();
+    nsIView *pView;
+     
+    kid->GetView(pView);
     if (nsnull == pView) {
       nsRect kidRect;
       kid->GetRect(kidRect);
@@ -146,7 +149,7 @@ void nsTableRowGroupFrame::PaintChildren(nsIPresContext&      aPresContext,
     }
     else
       NS_RELEASE(pView);
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 }
 
@@ -257,8 +260,12 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext*      aPresCon
     nsIFrame::ReflowStatus  status;
 
     // Get top margin for this kid
-    nsIContent* kid = kidFrame->GetContent();
-    nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
+    nsIStyleContext* kidSC;
+     
+    kidFrame->GetStyleContext(aPresContext, kidSC);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
     nscoord bottomMargin = kidMol->margin.bottom;
@@ -331,16 +338,21 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext*      aPresCon
     if (frNotComplete == status) {
       // XXX It's good to assume that we might still have room
       // even if the child didn't complete (floaters will want this)
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
 			PRBool lastContentIsComplete = mLastContentIsComplete;
       if (nsnull == kidNextInFlow) {
         // No the child isn't complete, and it doesn't have a next in flow so
         // create a continuing frame. This hooks the child into the flow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
 
         // Insert the frame. We'll reflow it next pass through the loop
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         if (nsnull == nextSib) {
@@ -352,7 +364,9 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext*      aPresCon
       }
       // We've used up all of our available space so push the remaining
       // children to the next-in-flow
-      nsIFrame* nextSibling = kidFrame->GetNextSibling();
+      nsIFrame* nextSibling;
+       
+      kidFrame->GetNextSibling(nextSibling);
       if (nsnull != nextSibling) {
         PushChildren(nextSibling, kidFrame, lastContentIsComplete);
         SetLastContentOffset(prevKidFrame);
@@ -362,15 +376,23 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext*      aPresCon
     }
 
     // Get the next child
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
 
   }
 
   // Update the child count
   mChildCount = childCount;
 
+#ifdef NS_DEBUG
   NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
-	NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
+
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+	NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+#endif
 
 #ifdef NS_DEBUG
   VerifyLastIsComplete();
@@ -436,7 +458,9 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
 #ifdef NS_DEBUG
   PRInt32        kidIndex = NextChildOffset();
 #endif
-  nsIFrame*      prevKidFrame = LastChild();
+  nsIFrame*      prevKidFrame;
+   
+  LastChild(prevKidFrame);
 
   // This will hold the prevKidFrame's mLastContentIsComplete
   // status. If we have to push the frame that follows prevKidFrame
@@ -465,7 +489,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
         kidFrame = nextInFlow->mFirstChild;
       } else {
         // We've pulled up all the children, so move to the next-in-flow.
-        nextInFlow = (nsTableRowGroupFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
         continue;
       }
     }
@@ -473,8 +497,12 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
     // See if the child fits in the available space. If it fits or
     // it's splittable then reflow it. The reason we can't just move
     // it is that we still need ascent/descent information
-    if ((kidFrame->GetHeight() > aState.availSize.height) &&
-        !kidFrame->IsSplittable()) {
+    nsSize  kidFrameSize;
+    PRBool  kidIsSplittable;
+
+    kidFrame->GetSize(kidFrameSize);
+    kidFrame->IsSplittable(kidIsSplittable);
+    if ((kidFrameSize.height > aState.availSize.height) && !kidIsSplittable) {
       result = PR_FALSE;
       mLastContentIsComplete = prevLastContentIsComplete;
       break;
@@ -499,7 +527,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
     PlaceChild(aPresContext, aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
 
     // Remove the frame from its current parent
-    nextInFlow->mFirstChild = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(nextInFlow->mFirstChild);
     nextInFlow->mChildCount--;
     // Update the next-in-flows first content offset
     if (nsnull != nextInFlow->mFirstChild) {
@@ -508,7 +536,10 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
 
     // Link the frame into our list of children
     kidFrame->SetGeometricParent(this);
-    if (nextInFlow == kidFrame->GetContentParent()) {
+    nsIFrame* kidContentParent;
+
+    kidFrame->GetContentParent(kidContentParent);
+    if (nextInFlow == kidContentParent) {
       kidFrame->SetContentParent(this);
     }
     if (nsnull == prevKidFrame) {
@@ -528,13 +559,16 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a
         // continuing frame. The creation appends it to the flow and
         // prepares it for reflow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to our sibling list and then push
@@ -562,7 +596,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
 
   // Update our last content offset
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -582,7 +616,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
       // the next-in-flows must be empty. Do a sanity check
       while (nsnull != nextInFlow) {
         NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
-        nextInFlow = (nsTableRowGroupFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
       }
 #endif
     }
@@ -643,7 +677,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
     mFirstContentOffset = prev->NextChildOffset();
     if (!prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
 
@@ -653,7 +687,9 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   nsSize    kidMaxElementSize;
   nsSize*   pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
   PRInt32   kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();  // XXX remember this...
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);  // XXX remember this...
 
   for (;;) {
     // Get the next content object
@@ -688,7 +724,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
       NS_RELEASE(kidDel);
       kidFrame->SetStyleContext(kidStyleContext);
     } else {
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
+      kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
     }
 		NS_RELEASE(kid);
     NS_RELEASE(kidStyleContext);
@@ -738,7 +774,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   }
 
   // Update the content mapping
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 #ifdef NS_DEBUG
   PRInt32 len = LengthOf(mFirstChild);
@@ -755,11 +791,12 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   * This method stacks rows vertically according to HTML 4.0 rules.
   * Rows are responsible for layout of their children.
   */
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
                                     nsReflowMetrics& aDesiredSize,
                                     const nsSize&    aMaxSize,
-                                    nsSize*          aMaxElementSize)
+                                    nsSize*          aMaxElementSize,
+                                    ReflowStatus&    aStatus)
 {
   if (gsDebug1==PR_TRUE)
     printf("nsTableRowGroupFrame::ResizeReflow - aMaxSize = %d, %d\n",
@@ -774,8 +811,9 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
     aMaxElementSize->height = 0;
   }
 
-  PRBool        reflowMappedOK = PR_TRUE;
-  ReflowStatus  status = frComplete;
+  PRBool reflowMappedOK = PR_TRUE;
+
+  aStatus = frComplete;
 
   // Check for an overflow list
   MoveOverflowToChildList();
@@ -788,7 +826,7 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aPresContext, state, aMaxElementSize);
     if (PR_FALSE == reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -798,24 +836,24 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
     if (state.availSize.height <= 0) {
       // No space left. Don't try to pull-up children or reflow unmapped
       if (NextChildOffset() < mContent->ChildCount()) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (NextChildOffset() < mContent->ChildCount()) {
       // Try and pull-up some children from a next-in-flow
       if (PullUpChildren(aPresContext, state, aMaxElementSize)) {
         // If we still have unmapped children then create some new frames
         if (NextChildOffset() < mContent->ChildCount()) {
-          status = ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
+          aStatus = ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
         }
       } else {
         // We were unable to pull-up all the existing frames from the
         // next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there's room for it.
     nscoord margin = state.prevMaxPosBottomMargin -
@@ -832,31 +870,32 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
   aDesiredSize.height = state.y;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
 
   if (gsDebug1==PR_TRUE) 
   {
     if (nsnull!=aMaxElementSize)
       printf("nsTableRowGroupFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=%d,%d\n",
-              status==frComplete?"Complete":"Not Complete",
+              aStatus==frComplete?"Complete":"Not Complete",
               aDesiredSize.width, aDesiredSize.height,
               aMaxElementSize->width, aMaxElementSize->height);
     else
       printf("nsTableRowGroupFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=NSNULL\n", 
-             status==frComplete?"Complete":"Not Complete",
+             aStatus==frComplete?"Complete":"Not Complete",
              aDesiredSize.width, aDesiredSize.height);
   }
 
-  return status;
+  return NS_OK;
 
 }
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableRowGroupFrame::IncrementalReflow(nsIPresContext*  aPresContext,
                                         nsReflowMetrics& aDesiredSize,
                                         const nsSize&    aMaxSize,
-                                        nsReflowCommand& aReflowCommand)
+                                        nsReflowCommand& aReflowCommand,
+                                        ReflowStatus&    aStatus)
 {
   if (gsDebug1==PR_TRUE) printf("nsTableRowGroupFrame::IncrementalReflow\n");
 
@@ -864,16 +903,19 @@ nsTableRowGroupFrame::IncrementalReflow(nsIPresContext*  aPresContext,
   aDesiredSize.width = aMaxSize.width;
   aDesiredSize.height = aMaxSize.height;
 
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame* nsTableRowGroupFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                      nsIFrame*       aParent)
+NS_METHOD nsTableRowGroupFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                      nsIFrame*       aParent,
+                                                      nsIFrame*&      aContinuingFrame)
 {
   nsTableRowGroupFrame* cf = new nsTableRowGroupFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
   if (PR_TRUE==gsDebug1) printf("nsTableRowGroupFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 /* ----- static methods ----- */
diff --git a/mozilla/layout/html/table/src/nsTableRowGroupFrame.h b/mozilla/layout/html/table/src/nsTableRowGroupFrame.h
index 6b04e1238ef..1a1045aef22 100644
--- a/mozilla/layout/html/table/src/nsTableRowGroupFrame.h
+++ b/mozilla/layout/html/table/src/nsTableRowGroupFrame.h
@@ -53,9 +53,9 @@ public:
                            nsIFrame*   aParent);
 
   /** @see nsIFrame::Paint */
-  virtual void  Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
   /** ask all children to paint themselves, without clipping (for cells with rowspan>1)
     * @see nsIFrame::Paint 
@@ -73,19 +73,22 @@ public:
     *
     * @see nsIFrame::ResizeReflow
     */
-  ReflowStatus  ResizeReflow(nsIPresContext* aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&   aMaxSize,
-                             nsSize*         aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&   aMaxSize,
+                          nsSize*         aMaxElementSize,
+                          ReflowStatus&   aStatus);
   /** @see nsIFrame::IncrementalReflow */
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
   /** @see nsContainerFrame::CreateContinuingFrame */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
 protected:
 
diff --git a/mozilla/layout/html/tests/TestInlineFrame.cpp b/mozilla/layout/html/tests/TestInlineFrame.cpp
index 3c6a01978f6..6de56e9dc77 100644
--- a/mozilla/layout/html/tests/TestInlineFrame.cpp
+++ b/mozilla/layout/html/tests/TestInlineFrame.cpp
@@ -213,11 +213,13 @@ InlineFrame::InlineFrame(nsIContent* aContent,
 {
 }
 
+#if 0
 PRInt32 InlineFrame::MaxChildWidth()
 {
   PRInt32 maxWidth = 0;
 
-  for (nsIFrame* f = FirstChild(); nsnull != f; f = f->GetNextSibling()) {
+  nsIFrame* f;
+  for (FirstChild(f); nsnull != f; f->GetNextSibling(f)) {
     if (f->GetWidth() > maxWidth) {
       maxWidth = f->GetWidth();
     }
@@ -1576,9 +1578,11 @@ TestMaxElementSize(nsIPresContext* presContext)
   NS_RELEASE(b);
   return PR_TRUE;
 }
+#endif
 
 int main(int argc, char** argv)
 {
+#if 0
   // Create test document and presentation context
   MyDocument *myDoc = new MyDocument();
   nsIPresContext* presContext;
@@ -1643,5 +1647,6 @@ int main(int argc, char** argv)
 
   presContext->Release();
   myDoc->Release();
+#endif
   return 0;
 }
diff --git a/mozilla/layout/style/nsCSSStyleSheet.cpp b/mozilla/layout/style/nsCSSStyleSheet.cpp
index bacdabafd92..685c07443e8 100644
--- a/mozilla/layout/style/nsCSSStyleSheet.cpp
+++ b/mozilla/layout/style/nsCSSStyleSheet.cpp
@@ -215,11 +215,13 @@ PRInt32 CSSStyleSheetImpl::RulesMatching(nsIPresContext* aPresContext,
       selector = selector->mNext;
       nsIFrame* frame = aParentFrame;
       while ((nsnull != selector) && (nsnull != frame)) { // check compound selectors
-        nsIContent* content = frame->GetContent();
+        nsIContent* content;
+         
+        frame->GetContent(content);
         if (SelectorMatches(selector, content)) {
           selector = selector->mNext;
         }
-        frame = frame->GetGeometricParent();
+        frame->GetGeometricParent(frame);
         NS_RELEASE(content);
       }
       if (nsnull == selector) { // ran out, it matched
diff --git a/mozilla/layout/style/nsStyleContext.cpp b/mozilla/layout/style/nsStyleContext.cpp
index eb03ec0ccb8..1cd8ee15641 100644
--- a/mozilla/layout/style/nsStyleContext.cpp
+++ b/mozilla/layout/style/nsStyleContext.cpp
@@ -526,7 +526,9 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
     // It's text (!)
     mMolecule.display = NS_STYLE_DISPLAY_INLINE;
     mMolecule.cursor = NS_STYLE_CURSOR_IBEAM;
-    nsIContent* content = aParentFrame->GetContent();
+    nsIContent* content;
+     
+    aParentFrame->GetContent(content);
     nsIAtom* parentTag = content->GetTag();
     parentTag->ToString(buf);
     NS_RELEASE(content);
@@ -539,9 +541,13 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
 //      mFont.mFont.decorations = NS_FONT_DECORATION_UNDERLINE;
       // This simulates a <PRE><A>text inheritance rule
       // Check the parent of the A
-      nsIFrame* parentParentFrame = aParentFrame->GetGeometricParent();
+      nsIFrame* parentParentFrame;
+       
+      aParentFrame->GetGeometricParent(parentParentFrame);
       if (nsnull != parentParentFrame) {
-        nsIContent* parentParentContent = parentParentFrame->GetContent();
+        nsIContent* parentParentContent;
+         
+        parentParentFrame->GetContent(parentParentContent);
         nsIAtom* parentParentTag = parentParentContent->GetTag();
         parentParentTag->ToString(buf);
         NS_RELEASE(parentParentTag);
@@ -607,7 +613,7 @@ NS_NewStyleContext(nsIStyleContext** aInstancePtrResult,
 
   nsIStyleContext* parent = nsnull;
   if (nsnull != aParentFrame) {
-    parent = aParentFrame->GetStyleContext(aPresContext);
+    aParentFrame->GetStyleContext(aPresContext, parent);
     NS_ASSERTION(nsnull != parent, "parent frame must have style context");
   }
 
diff --git a/mozilla/layout/style/nsStyleSet.cpp b/mozilla/layout/style/nsStyleSet.cpp
index 31eb9f37ced..94ea2a5c0e7 100644
--- a/mozilla/layout/style/nsStyleSet.cpp
+++ b/mozilla/layout/style/nsStyleSet.cpp
@@ -454,7 +454,7 @@ nsIStyleContext* StyleSetImpl::ResolveStyleFor(nsIPresContext* aPresContext,
   nsIStyleContext* parentContext = nsnull;
   
   if (nsnull != aParentFrame) {
-    parentContext = aParentFrame->GetStyleContext(aPresContext);
+    aParentFrame->GetStyleContext(aPresContext, parentContext);
     NS_ASSERTION(nsnull != parentContext, "parent must have style context");
   }
 
diff --git a/mozilla/layout/tables/nsTableCellFrame.cpp b/mozilla/layout/tables/nsTableCellFrame.cpp
index fc41977b5ee..213e08a502c 100644
--- a/mozilla/layout/tables/nsTableCellFrame.cpp
+++ b/mozilla/layout/tables/nsTableCellFrame.cpp
@@ -51,9 +51,9 @@ nsTableCellFrame::~nsTableCellFrame()
 {
 }
 
-void nsTableCellFrame::Paint(nsIPresContext& aPresContext,
-                             nsIRenderingContext& aRenderingContext,
-                             const nsRect& aDirtyRect)
+NS_METHOD nsTableCellFrame::Paint(nsIPresContext& aPresContext,
+                                  nsIRenderingContext& aRenderingContext,
+                                  const nsRect& aDirtyRect)
 {
   nsStyleColor* myColor =
     (nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
@@ -75,6 +75,7 @@ void nsTableCellFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 /**
@@ -98,7 +99,7 @@ void  nsTableCellFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
     bottomInset =mol->borderPadding.bottom;
     verticalAlign = mol->verticalAlign;
   }
-  nscoord       height = GetHeight();
+  nscoord       height = mRect.height;
 
   nsRect        kidRect;  
   mFirstChild->GetRect(kidRect);
@@ -135,11 +136,10 @@ void  nsTableCellFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
 PRInt32 nsTableCellFrame::GetRowSpan()
 {
   PRInt32 result = 0;
-  nsTableCell *cellContent = (nsTableCell *)GetContent();        // cellContent:  REFCNT++
+  nsTableCell *cellContent = (nsTableCell *)mContent;
   if (nsnull!=cellContent)
   {
     result = cellContent->GetRowSpan();
-    NS_RELEASE(cellContent);                                     // cellContent:  REFCNT--
   }
   return result;
 }
@@ -164,18 +164,18 @@ void nsTableCellFrame::CreatePsuedoFrame(nsIPresContext* aPresContext)
     NS_ASSERTION(prevFrame->ChildIsPseudoFrame(prevPseudoFrame), "bad previous pseudo-frame");
 
     // Create a continuing column
-    mFirstChild = prevPseudoFrame->CreateContinuingFrame(aPresContext, this);
+    prevPseudoFrame->CreateContinuingFrame(aPresContext, this, mFirstChild);
     mChildCount = 1;
   }
 }
 
 /**
   */
-nsIFrame::ReflowStatus
-nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
-                               nsReflowMetrics& aDesiredSize,
-                               const nsSize&   aMaxSize,
-                               nsSize*         aMaxElementSize)
+NS_METHOD nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                         nsReflowMetrics& aDesiredSize,
+                                         const nsSize&   aMaxSize,
+                                         nsSize*         aMaxElementSize,
+                                         ReflowStatus&   aStatus)
 {
   NS_PRECONDITION(nsnull!=aPresContext, "bad arg");
 
@@ -183,7 +183,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
   //PreReflowCheck();
 #endif
 
-  ReflowStatus result = frComplete;
+  aStatus = frComplete;
   if (gsDebug==PR_TRUE)
     printf("nsTableCellFrame::ResizeReflow: maxSize=%d,%d\n",
            aMaxSize.width, aMaxSize.height);
@@ -233,7 +233,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
   if (gsDebug==PR_TRUE)
     printf("  nsTableCellFrame::ResizeReflow calling ReflowChild with availSize=%d,%d\n",
            availSize.width, availSize.height);
-  result = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
+  aStatus = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
 
   if (gsDebug==PR_TRUE)
   {
@@ -258,7 +258,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
                            kidSize.width, kidSize.height));
   
     
-  if (frNotComplete == result) {
+  if (frNotComplete == aStatus) {
     // If the child didn't finish layout then it means that it used
     // up all of our available space (or needs us to split).
     mLastContentIsComplete = PR_FALSE;
@@ -289,28 +289,29 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
   //PostReflowCheck(result);
 #endif
 
-  return result;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
-nsTableCellFrame::IncrementalReflow(nsIPresContext*  aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize&    aMaxSize,
-                                    nsReflowCommand& aReflowCommand)
+NS_METHOD nsTableCellFrame::IncrementalReflow(nsIPresContext*  aPresContext,
+                                              nsReflowMetrics& aDesiredSize,
+                                              const nsSize&    aMaxSize,
+                                              nsReflowCommand& aReflowCommand,
+                                              ReflowStatus&    aStatus)
 {
   if (gsDebug == PR_TRUE) printf("nsTableCellFrame::IncrementalReflow\n");
   // total hack for now, just some hard-coded values
-  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
-
-  return frComplete;
+  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
+  return NS_OK;
 }
 
-nsIFrame* nsTableCellFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                  nsIFrame*       aParent)
+NS_METHOD nsTableCellFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                  nsIFrame*       aParent,
+                                                  nsIFrame*&      aContinuingFrame)
 {
   nsTableCellFrame* cf = new nsTableCellFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 
diff --git a/mozilla/layout/tables/nsTableCellFrame.h b/mozilla/layout/tables/nsTableCellFrame.h
index c71974a1894..3199b6efa5d 100644
--- a/mozilla/layout/tables/nsTableCellFrame.h
+++ b/mozilla/layout/tables/nsTableCellFrame.h
@@ -38,25 +38,28 @@ public:
                            PRInt32     aIndexInParent,
                            nsIFrame*   aParent);
 
-  virtual void  Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  ReflowStatus  ResizeReflow(nsIPresContext* aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&   aMaxSize,
-                             nsSize*         aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&   aMaxSize,
+                          nsSize*         aMaxElementSize,
+                          ReflowStatus&   aStatus);
 
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
   /**
    * @see nsContainerFrame
    */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
   void          VerticallyAlignChild(nsIPresContext* aPresContext);
 
diff --git a/mozilla/layout/tables/nsTableColGroupFrame.cpp b/mozilla/layout/tables/nsTableColGroupFrame.cpp
index d2741f097ca..f9bee13cc80 100644
--- a/mozilla/layout/tables/nsTableColGroupFrame.cpp
+++ b/mozilla/layout/tables/nsTableColGroupFrame.cpp
@@ -35,20 +35,22 @@ nsTableColGroupFrame::~nsTableColGroupFrame()
 {
 }
 
-void nsTableColGroupFrame::Paint(nsIPresContext& aPresContext,
-                                 nsIRenderingContext& aRenderingContext,
-                                 const nsRect&        aDirtyRect)
+NS_METHOD nsTableColGroupFrame::Paint(nsIPresContext& aPresContext,
+                                      nsIRenderingContext& aRenderingContext,
+                                      const nsRect&        aDirtyRect)
 {
   if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::Paint\n");
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableColGroupFrame::ResizeReflow(nsIPresContext* aPresContext,
                         nsReflowMetrics& aDesiredSize,
                         const nsSize&   aMaxSize,
-                        nsSize*         aMaxElementSize)
+                        nsSize*         aMaxElementSize,
+                        ReflowStatus& aStatus)
 {
   NS_ASSERTION(nsnull!=aPresContext, "bad arg");
   if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::ResizeReflow\n");
@@ -59,21 +61,20 @@ nsTableColGroupFrame::ResizeReflow(nsIPresContext* aPresContext,
     aMaxElementSize->width=0;
     aMaxElementSize->height=0;
   }
-  return nsIFrame::frComplete;
+  aStatus = nsIFrame::frComplete;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableColGroupFrame::IncrementalReflow(nsIPresContext*  aPresContext,
                                         nsReflowMetrics& aDesiredSize,
                                         const nsSize&    aMaxSize,
-                                        nsReflowCommand& aReflowCommand)
+                                        nsReflowCommand& aReflowCommand,
+                                        ReflowStatus&    aStatus)
 {
   NS_ASSERTION(nsnull!=aPresContext, "bad arg");
-  ReflowStatus  status;
-
   if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::IncrementalReflow\n");
-
-  return status;
+  return NS_OK;
 }
 
 nsresult nsTableColGroupFrame::NewFrame(nsIFrame** aInstancePtrResult,
diff --git a/mozilla/layout/tables/nsTableColGroupFrame.h b/mozilla/layout/tables/nsTableColGroupFrame.h
index 260c77c8745..e2a93f7a00b 100644
--- a/mozilla/layout/tables/nsTableColGroupFrame.h
+++ b/mozilla/layout/tables/nsTableColGroupFrame.h
@@ -36,19 +36,21 @@ public:
                            PRInt32     aIndexInParent,
                            nsIFrame*   aParent);
 
-  virtual void  Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
-  ReflowStatus  ResizeReflow(nsIPresContext* aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&   aMaxSize,
-                             nsSize*         aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&   aMaxSize,
+                          nsSize*         aMaxElementSize,
+                          ReflowStatus&   aStatus);
 
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
 protected:
 
diff --git a/mozilla/layout/tables/nsTableFrame.cpp b/mozilla/layout/tables/nsTableFrame.cpp
index e10b1962c19..d7f0baa342a 100644
--- a/mozilla/layout/tables/nsTableFrame.cpp
+++ b/mozilla/layout/tables/nsTableFrame.cpp
@@ -388,9 +388,9 @@ void nsTableFrame::ResetColumnLayoutData()
 
 
 /* SEC: TODO: adjust the rect for captions */
-void nsTableFrame::Paint(nsIPresContext& aPresContext,
-                         nsIRenderingContext& aRenderingContext,
-                         const nsRect& aDirtyRect)
+NS_METHOD nsTableFrame::Paint(nsIPresContext& aPresContext,
+                              nsIRenderingContext& aRenderingContext,
+                              const nsRect& aDirtyRect)
 {
   // table paint code is concerned primarily with borders and bg color
   nsStyleColor* myColor =
@@ -414,6 +414,7 @@ void nsTableFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 PRBool nsTableFrame::NeedsReflow(const nsSize& aMaxSize)
@@ -444,10 +445,11 @@ PRBool nsTableFrame::NeedsReflow(const nsSize& aMaxSize)
 
 /** Layout the entire inner table.
   */
-nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
-                                                   nsReflowMetrics& aDesiredSize,
-                                                   const nsSize& aMaxSize,
-                                                   nsSize* aMaxElementSize)
+NS_METHOD nsTableFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                     nsReflowMetrics& aDesiredSize,
+                                     const nsSize& aMaxSize,
+                                     nsSize* aMaxElementSize,
+                                     ReflowStatus& aStatus)
 {
   NS_PRECONDITION(nsnull != aPresContext, "null arg");
   if (gsDebug==PR_TRUE) 
@@ -461,7 +463,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
   PreReflowCheck();
 #endif
 
-  ReflowStatus result = frComplete;
+  aStatus = frComplete;
 
   PRIntervalTime startTime = PR_IntervalNow();
 
@@ -479,7 +481,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
     if (PR_FALSE==IsFirstPassValid())
     { // we treat the table as if we've never seen the layout data before
       mPass = kPASS_FIRST;
-      result = ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol);
+      aStatus = ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol);
       // check result
     }
     mPass = kPASS_SECOND;
@@ -490,7 +492,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
     // assign table width
     SetTableWidth(aPresContext, tableStyleMol);
 
-    result = ResizeReflowPass2(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol, 0, 0);
+    aStatus = ResizeReflowPass2(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol, 0, 0);
 
     PRIntervalTime endTime = PR_IntervalNow();
     if (gsTiming) printf("Table reflow took %ld ticks for frame %d\n", endTime-startTime, this);
@@ -503,10 +505,10 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
   }
 
 #ifdef NS_DEBUG
-  PostReflowCheck(result);
+  PostReflowCheck(aStatus);
 #endif  
 
-  return result;
+  return NS_OK;
 }
 
 /** the first of 2 reflow passes
@@ -587,7 +589,9 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresCont
 
       // SEC: TODO:  when content is appended or deleted, be sure to clear out the frame hierarchy!!!!
 
-      nsIFrame* kidFrame = ChildAt(kidIndex);
+      nsIFrame* kidFrame;
+
+      ChildAt(kidIndex, kidFrame);
       // if this is the first time, allocate the caption frame
       if (nsnull==kidFrame)
       {
@@ -662,7 +666,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresCont
   }
 
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
                                            // can't use SetLastContentOffset here
     mLastContentOffset = contentOffset-1;    // takes into account colGroup frame we're not using
     if (gsDebug) printf("INNER: set last content offset to %d\n", GetLastContentOffset()); //@@@
@@ -899,10 +903,14 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext*      aPresContext,
     nsIFrame::ReflowStatus  status;
 
     // Get top margin for this kid
-    nsIContent* kid = kidFrame->GetContent();
+    nsIContent* kid;
+
+    kidFrame->GetContent(kid);
     if (((nsTableContent *)kid)->GetType() == nsITableContent::kTableRowGroupType)
     { // skip children that are not row groups
-      nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+      nsIStyleContext* kidSC;
+
+      kidFrame->GetStyleContext(aPresContext, kidSC);
       nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
       nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
       nscoord bottomMargin = kidMol->margin.bottom;
@@ -960,17 +968,22 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext*      aPresContext,
 
       // Special handling for incomplete children
       if (frNotComplete == status) {
-        nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+        nsIFrame* kidNextInFlow;
+         
+        kidFrame->GetNextInFlow(kidNextInFlow);
         PRBool lastContentIsComplete = mLastContentIsComplete;
         if (nsnull == kidNextInFlow) {
           // The child doesn't have a next-in-flow so create a continuing
           // frame. This hooks the child into the flow
-          nsIFrame* continuingFrame =
-            kidFrame->CreateContinuingFrame(aPresContext, this);
+          nsIFrame* continuingFrame;
+           
+          kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
           NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
           // Add the continuing frame to the sibling list
-          nsIFrame* nextSib = kidFrame->GetNextSibling();
+          nsIFrame* nextSib;
+           
+          kidFrame->GetNextSibling(nextSib);
           continuingFrame->SetNextSibling(nextSib);
           kidFrame->SetNextSibling(continuingFrame);
           if (nsnull == nextSib) {
@@ -982,7 +995,9 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext*      aPresContext,
         }
         // We've used up all of our available space so push the remaining
         // children to the next-in-flow
-        nsIFrame* nextSibling = kidFrame->GetNextSibling();
+        nsIFrame* nextSibling;
+         
+        kidFrame->GetNextSibling(nextSibling);
         if (nsnull != nextSibling) {
           PushChildren(nextSibling, kidFrame, lastContentIsComplete);
           SetLastContentOffset(prevKidFrame);
@@ -993,15 +1008,23 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext*      aPresContext,
     }
 
     // Get the next child
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
 
     // XXX talk with troy about checking for available space here
   }
 
   // Update the child count
   mChildCount = childCount;
+#ifdef NS_DEBUG
   NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
-  NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
+
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+  NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+#endif
 
 #ifdef NS_DEBUG
   VerifyLastIsComplete();
@@ -1067,7 +1090,9 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
 #ifdef NS_DEBUG
   PRInt32        kidIndex = NextChildOffset();
 #endif
-  nsIFrame*      prevKidFrame = LastChild();
+  nsIFrame*      prevKidFrame;
+   
+  LastChild(prevKidFrame);
 
   // This will hold the prevKidFrame's mLastContentIsComplete
   // status. If we have to push the frame that follows prevKidFrame
@@ -1095,7 +1120,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
         kidFrame = nextInFlow->mFirstChild;
       } else {
         // We've pulled up all the children, so move to the next-in-flow.
-        nextInFlow = (nsTableFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
         continue;
       }
     }
@@ -1103,8 +1128,12 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
     // See if the child fits in the available space. If it fits or
     // it's splittable then reflow it. The reason we can't just move
     // it is that we still need ascent/descent information
-    if ((kidFrame->GetHeight() > aState.availSize.height) &&
-        !kidFrame->IsSplittable()) {
+    nsSize  kidFrameSize;
+    PRBool  kidIsSplittable;
+
+    kidFrame->GetSize(kidFrameSize);
+    kidFrame->IsSplittable(kidIsSplittable);
+    if ((kidFrameSize.height > aState.availSize.height) && !kidIsSplittable) {
       result = PR_FALSE;
       mLastContentIsComplete = prevLastContentIsComplete;
       break;
@@ -1134,7 +1163,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
     PlaceChild(aPresContext, aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
 
     // Remove the frame from its current parent
-    nextInFlow->mFirstChild = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(nextInFlow->mFirstChild);
     nextInFlow->mChildCount--;
     // Update the next-in-flows first content offset
     if (nsnull != nextInFlow->mFirstChild) {
@@ -1143,7 +1172,10 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
 
     // Link the frame into our list of children
     kidFrame->SetGeometricParent(this);
-    if (nextInFlow == kidFrame->GetContentParent()) {
+    nsIFrame* contentParent;
+
+    kidFrame->GetContentParent(contentParent);
+    if (nextInFlow == contentParent) {
       kidFrame->SetContentParent(this);
     }
     if (nsnull == prevKidFrame) {
@@ -1163,13 +1195,16 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a
         // continuing frame. The creation appends it to the flow and
         // prepares it for reflow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to our sibling list and then push
@@ -1197,7 +1232,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
 
   // Update our last content offset
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -1217,7 +1252,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext*      aPresContext,
       // the next-in-flows must be empty. Do a sanity check
       while (nsnull != nextInFlow) {
         NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
-        nextInFlow = (nsTableFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
       }
 #endif
     }
@@ -1258,7 +1293,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
     mFirstContentOffset = prev->NextChildOffset();
     if (!prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
   mLastContentIsComplete = PR_TRUE;
@@ -1267,8 +1302,9 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   nsSize    kidMaxElementSize;
   nsSize*   pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
   PRInt32   kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();
+  nsIFrame* prevKidFrame;
 
+  LastChild(prevKidFrame);
   for (;;) {
     // Get the next content object
     nsIContent* kid = mContent->ChildAt(kidIndex);
@@ -1301,7 +1337,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
       NS_RELEASE(kidDel);
       kidFrame->SetStyleContext(kidStyleContext);
     } else {
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
+      kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
     }
     NS_RELEASE(kid);
     NS_RELEASE(kidStyleContext);
@@ -1356,7 +1392,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   }
 
   // Update the content mapping
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 #ifdef NS_DEBUG
   PRInt32 len = LengthOf(mFirstChild);
@@ -1536,7 +1572,8 @@ PRBool nsTableFrame::AssignFixedColumnWidths(nsIPresContext* aPresContext, PRInt
         // SEC: TODO -- when we have a style system, set the mol for the col
         nsCellLayoutData * data = (nsCellLayoutData *)(cells->ElementAt(0));
         nsTableCellFrame *cellFrame = data->GetCellFrame();
-        nsTableCell *cell = (nsTableCell *)cellFrame->GetContent();          // cell: REFCNT++
+        nsTableCell *cell;
+        cellFrame->GetContent((nsIContent*&)cell);          // cell: REFCNT++
         nsStyleMolecule* cellStyle = (nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
         NS_ASSERTION(nsnull != cellStyle, "bad style for cell.");
         // SEC: this is the code to replace
@@ -1954,7 +1991,7 @@ void nsTableFrame::SetTableWidth(nsIPresContext* aPresContext,
   nscoord rightInset = aTableStyle->borderPadding.right;
   nscoord leftInset = aTableStyle->borderPadding.left;
   tableWidth += (leftInset + rightInset);
-  nsRect tableSize = GetRect();
+  nsRect tableSize = mRect;
   tableSize.width = tableWidth;
   if (gsDebug==PR_TRUE)
   {
@@ -1975,16 +2012,22 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
   gsDebug = PR_FALSE;  // turn on debug in this method
 #endif
   // iterate children, tell all row groups to ShrinkWrap
-  PRInt32 childCount = ChildCount();
   PRBool atLeastOneRowSpanningCell = PR_FALSE;
   PRInt32 tableHeight = 0;
+  PRInt32 childCount = mChildCount;
+
   for (PRInt32 i = 0; i < childCount; i++)
   {
     PRInt32 childHeight=0;
     // for every child that is a rowFrame, set the row frame height  = sum of row heights
-    nsIFrame * kidFrame = ChildAt(i); // frames are not ref counted
+    // XXX This is a n-squared algorithm. Use GetNextSibling() instead...
+    nsIFrame * kidFrame;
+
+    ChildAt(i, kidFrame); // frames are not ref counted
     NS_ASSERTION(nsnull != kidFrame, "bad kid frame");
-    nsTableContent* kid = (nsTableContent*)(kidFrame->GetContent());  // kid: REFCNT++
+    nsTableContent* kid;
+     
+    kidFrame->GetContent((nsIContent*&)kid);  // kid: REFCNT++
     NS_ASSERTION(nsnull != kid, "bad kid");
     if (kid->GetType() == nsITableContent::kTableRowGroupType)
     {
@@ -1993,33 +2036,48 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
        */
       PRInt32 rowGroupHeight = 0;
       nsTableRowGroupFrame * rowGroupFrame = (nsTableRowGroupFrame *)kidFrame;
-      PRInt32 numRows = rowGroupFrame->ChildCount();
+      PRInt32 numRows;
+      rowGroupFrame->ChildCount(numRows);
       PRInt32 *rowHeights = new PRInt32[numRows];
       if (gsDebug==PR_TRUE) printf("Height Step 1...\n");
       for (PRInt32 rowIndex = 0; rowIndex < numRows; rowIndex++)
       {
         // get the height of the tallest cell in the row (excluding cells that span rows)
-        nsTableRowFrame *rowFrame = (nsTableRowFrame *)(rowGroupFrame->ChildAt(rowIndex));
+        nsTableRowFrame *rowFrame;
+         
+        rowGroupFrame->ChildAt(rowIndex, (nsIFrame*&)rowFrame);
         NS_ASSERTION(nsnull != rowFrame, "bad row frame");
         rowHeights[rowIndex] = rowFrame->GetTallestChild();
-        rowFrame->SizeTo(rowFrame->GetWidth(), rowHeights[rowIndex]);
+
+        nsSize  rowFrameSize;
+
+        rowFrame->GetSize(rowFrameSize);
+        rowFrame->SizeTo(rowFrameSize.width, rowHeights[rowIndex]);
         rowGroupHeight += rowHeights[rowIndex];
         // resize all the cells based on the rowHeight
-        PRInt32 numCells = rowFrame->ChildCount();
+        PRInt32 numCells;
+
+        rowFrame->ChildCount(numCells);
         for (PRInt32 cellIndex = 0; cellIndex < numCells; cellIndex++)
         {
-          nsTableCellFrame *cellFrame = (nsTableCellFrame *)(rowFrame->ChildAt(cellIndex));
+          nsTableCellFrame *cellFrame;
+
+          rowFrame->ChildAt(cellIndex, (nsIFrame*&)cellFrame);
           PRInt32 rowSpan = cellFrame->GetRowSpan();
           if (1==rowSpan)
           {
             if (gsDebug==PR_TRUE) printf("  setting cell[%d,%d] height to %d\n", rowIndex, cellIndex, rowHeights[rowIndex]);
-            cellFrame->SizeTo(cellFrame->GetWidth(), rowHeights[rowIndex]);
+
+            nsSize  cellFrameSize;
+
+            cellFrame->GetSize(cellFrameSize);
+            cellFrame->SizeTo(cellFrameSize.width, rowHeights[rowIndex]);
             // Realign cell content based on new height
             cellFrame->VerticallyAlignChild(aPresContext);
           }
           else
           {
-            if (gsDebug==PR_TRUE) printf("  skipping cell[%d,%d] with a desired height of %d\n", rowIndex, cellIndex, cellFrame->GetHeight());
+            if (gsDebug==PR_TRUE) printf("  skipping cell[%d,%d]\n", rowIndex, cellIndex);
             atLeastOneRowSpanningCell = PR_TRUE;
           }
         }
@@ -2041,11 +2099,16 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
       rowGroupHeight=0;
       for (rowIndex = 0; rowIndex < numRows; rowIndex++)
       {
-        nsTableRowFrame *rowFrame = (nsTableRowFrame *)(rowGroupFrame->ChildAt(rowIndex));
-        PRInt32 numCells = rowFrame->ChildCount();
+        nsTableRowFrame *rowFrame;
+        PRInt32 numCells;
+
+        rowGroupFrame->ChildAt(rowIndex, (nsIFrame*&)rowFrame);
+        rowFrame->ChildCount(numCells);
         for (PRInt32 cellIndex = 0; cellIndex < numCells; cellIndex++)
         {
-          nsTableCellFrame *cellFrame = (nsTableCellFrame *)(rowFrame->ChildAt(cellIndex));
+          nsTableCellFrame *cellFrame;
+
+          rowFrame->ChildAt(cellIndex, (nsIFrame*&)cellFrame);
           PRInt32 rowSpan = cellFrame->GetRowSpan();
           if (1<rowSpan)
           {
@@ -2054,10 +2117,13 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
             for (PRInt32 i=0; i<rowSpan; i++)
               heightOfRowsSpanned += rowHeights[i+rowIndex];
             /* if the cell height fits in the rows, expand the cell height and slap it in */
-            if (heightOfRowsSpanned>cellFrame->GetHeight())
+            nsSize  cellFrameSize;
+
+            cellFrame->GetSize(cellFrameSize);
+            if (heightOfRowsSpanned>cellFrameSize.height)
             {
               if (gsDebug==PR_TRUE) printf("  cell[%d,%d] fits, setting height to %d\n", rowIndex, cellIndex, heightOfRowsSpanned);
-              cellFrame->SizeTo(cellFrame->GetWidth(), heightOfRowsSpanned);
+              cellFrame->SizeTo(cellFrameSize.width, heightOfRowsSpanned);
               // Realign cell content based on new height
               cellFrame->VerticallyAlignChild(aPresContext);
             }
@@ -2066,20 +2132,28 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
              */
             else
             {
-              PRInt32 excessHeight = cellFrame->GetHeight() - heightOfRowsSpanned;
+              PRInt32 excessHeight = cellFrameSize.height - heightOfRowsSpanned;
               PRInt32 excessHeightPerRow = excessHeight/rowSpan;
               if (gsDebug==PR_TRUE) printf("  cell[%d,%d] does not fit, excessHeight = %d, excessHeightPerRow = %d\n", 
                       rowIndex, cellIndex, excessHeight, excessHeightPerRow);
               // for the rows effected...
               for (i=rowIndex; i<numRows; i++)
               {
-                nsTableRowFrame *rowFrameToBeResized = (nsTableRowFrame *)(rowGroupFrame->ChildAt(i));
+                nsTableRowFrame *rowFrameToBeResized;
+
+                rowGroupFrame->ChildAt(i, (nsIFrame*&)rowFrameToBeResized);
                 if (i<rowIndex+rowSpan)
                 {
                   rowHeights[i] += excessHeightPerRow;
                   if (gsDebug==PR_TRUE) printf("    rowHeight[%d] set to %d\n", i, rowHeights[i]);
-                  rowFrameToBeResized->SizeTo(rowFrameToBeResized->GetWidth(), rowHeights[i]);
-                  PRInt32 cellCount = rowFrameToBeResized->ChildCount();
+
+                  nsSize  rowFrameSize;
+
+                  rowFrameToBeResized->GetSize(rowFrameSize);
+                  rowFrameToBeResized->SizeTo(rowFrameSize.width, rowHeights[i]);
+                  PRInt32 cellCount;
+
+                  rowFrameToBeResized->ChildCount(cellCount);
                   for (PRInt32 j=0; j<cellCount; j++)
                   {
                     if (i==rowIndex && j==cellIndex)
@@ -2087,11 +2161,16 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
                       if (gsDebug==PR_TRUE) printf("      cell[%d, %d] skipping self\n", i, j);
                       continue; // don't do math on myself, only the other cells I effect
                     }
-                    nsTableCellFrame *frame = (nsTableCellFrame *)(rowFrameToBeResized->ChildAt(j));
+                    nsTableCellFrame *frame;
+
+                    rowFrameToBeResized->ChildAt(j, (nsIFrame*&)frame);
                     if (frame->GetRowSpan()==1)
                     {
-                      if (gsDebug==PR_TRUE) printf("      cell[%d, %d] set height to %d\n", i, j, frame->GetHeight()+excessHeightPerRow);
-                      frame->SizeTo(frame->GetWidth(), frame->GetHeight()+excessHeightPerRow);
+                      nsSize  frameSize;
+
+                      frame->GetSize(frameSize);
+                      if (gsDebug==PR_TRUE) printf("      cell[%d, %d] set height to %d\n", i, j, frameSize.height+excessHeightPerRow);
+                      frame->SizeTo(frameSize.width, frameSize.height+excessHeightPerRow);
                       // Realign cell content based on new height
                       frame->VerticallyAlignChild(aPresContext);
                     }
@@ -2101,7 +2180,9 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
                 // push that row down by the amount we've expanded the cell heights by
                 if (i>rowIndex)
                 {
-                  nsRect rowRect = rowFrameToBeResized->GetRect();
+                  nsRect rowRect;
+                   
+                  rowFrameToBeResized->GetRect(rowRect);
                   rowFrameToBeResized->MoveTo(rowRect.x, rowRect.y + (excessHeightPerRow*(i-rowIndex)));
                   if (gsDebug==PR_TRUE) printf("      row %d moved to y-offset %d\n", i, 
                                                 rowRect.y + (excessHeightPerRow*(i-rowIndex)));
@@ -2113,7 +2194,11 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
         rowGroupHeight += rowHeights[rowIndex];
       }
       if (gsDebug==PR_TRUE) printf("row group height set to %d\n", rowGroupHeight);
-      rowGroupFrame->SizeTo(rowGroupFrame->GetWidth(), rowGroupHeight);
+
+      nsSize  rowGroupFrameSize;
+
+      rowGroupFrame->GetSize(rowGroupFrameSize);
+      rowGroupFrame->SizeTo(rowGroupFrameSize.width, rowGroupHeight);
       tableHeight += rowGroupHeight;
     }
     NS_RELEASE(kid);                                                  // kid: REFCNT--
@@ -2139,11 +2224,11 @@ PRBool nsTableFrame::IsProportionalWidth(nsStyleMolecule* aMol)
 
 /**
   */
-nsIFrame::ReflowStatus
-nsTableFrame::IncrementalReflow(nsIPresContext*  aCX,
-                              nsReflowMetrics& aDesiredSize,
-                              const nsSize&    aMaxSize,
-                              nsReflowCommand& aReflowCommand)
+NS_METHOD nsTableFrame::IncrementalReflow(nsIPresContext*  aCX,
+                                          nsReflowMetrics& aDesiredSize,
+                                          const nsSize&    aMaxSize,
+                                          nsReflowCommand& aReflowCommand,
+                                          ReflowStatus&    aStatus)
 {
   NS_ASSERTION(nsnull != aCX, "bad arg");
   if (gsDebug==PR_TRUE) printf ("nsTableFrame::IncrementalReflow: maxSize=%d,%d\n",
@@ -2153,7 +2238,8 @@ nsTableFrame::IncrementalReflow(nsIPresContext*  aCX,
 
   aDesiredSize.width = mRect.width;
   aDesiredSize.height = mRect.height;
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
 void nsTableFrame::VerticallyAlignChildren(nsIPresContext* aPresContext,
@@ -2294,7 +2380,9 @@ nsCellLayoutData * nsTableFrame::GetCellLayoutData(nsTableCell *aCell)
       for (PRInt32 i=0; i<count; i++)
       {
         nsCellLayoutData * data = (nsCellLayoutData *)(cells->ElementAt(i));
-        nsTableCell *cell = (nsTableCell *)(data->GetCellFrame()->GetContent());  // cell: REFCNT++
+        nsTableCell *cell;
+         
+        data->GetCellFrame()->GetContent((nsIContent*&)cell);  // cell: REFCNT++
         if (cell == aCell)
         {
           result = data;
@@ -2345,18 +2433,21 @@ PRBool nsTableFrame::AutoColumnWidths(nsStyleMolecule* aTableStyleMol)
   return isAutoColumnWidths;
 }
 
-nsIFrame* nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                              nsIFrame*       aParent)
+NS_METHOD nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                              nsIFrame*       aParent,
+                                              nsIFrame*&      aContinuingFrame)
 {
   nsTableFrame* cf = new nsTableFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
   if (PR_TRUE==gsDebug) printf("nsTableFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
   // set my width, because all frames in a table flow are the same width
   // code in nsTableOuterFrame depends on this being set
-  cf->SetRect(nsRect(0, 0, GetWidth(), 0));
+  cf->SetRect(nsRect(0, 0, mRect.width, 0));
   // add headers and footers to cf
   nsTableFrame * firstInFlow = (nsTableFrame *)GetFirstInFlow();
-  PRInt32 childCount = firstInFlow->ChildCount();
+  PRInt32 childCount;
+   
+  firstInFlow->ChildCount(childCount);
   PRInt32 childIndex = 0;
   for (; childIndex < childCount; childIndex++)
   {
@@ -2364,7 +2455,8 @@ nsIFrame* nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
     // maybe need to do this in ResizeReflow at the beginning, when we determine we are a continuing frame
   }
 
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 PRInt32 nsTableFrame::GetColumnWidth(PRInt32 aColIndex)
diff --git a/mozilla/layout/tables/nsTableFrame.h b/mozilla/layout/tables/nsTableFrame.h
index 29902151fe6..23ace38b50d 100644
--- a/mozilla/layout/tables/nsTableFrame.h
+++ b/mozilla/layout/tables/nsTableFrame.h
@@ -59,9 +59,9 @@ public:
                            nsIFrame*   aParent);
 
   /** @see nsIFrame::Paint */
-  virtual void Paint(nsIPresContext& aPresContext,
-                     nsIRenderingContext& aRenderingContext,
-                     const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
   /** inner tables are reflowed in two steps.
     * <pre>
@@ -81,20 +81,23 @@ public:
     * @see BalanceColumnWidths
     * @see nsIFrame::ResizeReflow 
     */
-  virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
-                                    nsReflowMetrics& aDesiredSize,
-                                    const nsSize& aMaxSize,
-                                    nsSize* aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize& aMaxSize,
+                          nsSize* aMaxElementSize,
+                          ReflowStatus& aStatus);
 
   /** @see nsIFrame::IncrementalReflow */
-  virtual ReflowStatus  IncrementalReflow(nsIPresContext* aPresContext,
-                                          nsReflowMetrics& aDesiredSize,
-                                          const nsSize&    aMaxSize,
-                                          nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus& aStatus);
 
   /** @see nsContainerFrame::CreateContinuingFrame */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
   /** resize myself and my children according to the arcane rules of cell height magic. 
     * By default, the height of a cell is the max (height of cells in its row)
diff --git a/mozilla/layout/tables/nsTableOuterFrame.cpp b/mozilla/layout/tables/nsTableOuterFrame.cpp
index cb926a50202..f6c4d8667eb 100644
--- a/mozilla/layout/tables/nsTableOuterFrame.cpp
+++ b/mozilla/layout/tables/nsTableOuterFrame.cpp
@@ -122,9 +122,9 @@ nsTableOuterFrame::~nsTableOuterFrame()
     delete mBottomCaptions;
 }
 
-void nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
-                               nsIRenderingContext& aRenderingContext,
-                               const nsRect& aDirtyRect)
+NS_METHOD nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
+                                   nsIRenderingContext& aRenderingContext,
+                                   const nsRect& aDirtyRect)
 {
   // for debug...
   if (nsIFrame::GetShowFrameBorders()) {
@@ -133,6 +133,7 @@ void nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 PRBool nsTableOuterFrame::NeedsReflow(const nsSize& aMaxSize)
@@ -163,10 +164,11 @@ void nsTableOuterFrame::SetFirstPassValid(PRBool aValidState)
   * NOTE: for breaking across pages, this method has to account for table content that is not laid out
   *       linearly vis a vis the frames.  That is, content hierarchy and the frame hierarchy do not match.
   */
-nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresContext,
-                                                       nsReflowMetrics& aDesiredSize,
-                                                       const nsSize& aMaxSize,
-                                                       nsSize* aMaxElementSize)
+NS_METHOD nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresContext,
+                                          nsReflowMetrics& aDesiredSize,
+                                          const nsSize& aMaxSize,
+                                          nsSize* aMaxElementSize,
+                                          ReflowStatus& aStatus)
 {
   if (PR_TRUE==gsDebug) 
     printf ("***table outer frame reflow \t\t%p\n", this);
@@ -185,8 +187,9 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
     aMaxElementSize->height = 0;
   }
 
-  PRBool        reflowMappedOK = PR_TRUE;
-  ReflowStatus  status = frComplete;
+  PRBool  reflowMappedOK = PR_TRUE;
+
+  aStatus = frComplete;
   nsSize innerTableMaxElementSize(0,0);
 
   // Set up our kids.  They're already present, on an overflow list, 
@@ -201,8 +204,11 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   // at this point, we must have at least one child frame, and we must have an inner table frame
   NS_ASSERTION(nsnull!=mFirstChild, "no children");
   NS_ASSERTION(nsnull!=mInnerTableFrame, "no mInnerTableFrame");
-  if (nsnull==mFirstChild  ||  nsnull==mInnerTableFrame) //ERROR!
-    return frComplete;
+  if (nsnull==mFirstChild  ||  nsnull==mInnerTableFrame) {
+    //ERROR!
+    aStatus = frComplete;
+    return NS_OK;
+  }
 
   nsStyleMolecule* tableStyleMol =
     (nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
@@ -213,7 +219,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   if (PR_FALSE==IsFirstPassValid())
   {
     mFirstPassValid = PR_TRUE;
-    status = ResizeReflowCaptionsPass1(aPresContext, tableStyleMol);
+    aStatus = ResizeReflowCaptionsPass1(aPresContext, tableStyleMol);
 
   }
 
@@ -221,8 +227,8 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   if (PR_FALSE==mInnerTableFrame->IsFirstPassValid())
   { // we treat the table as if we've never seen the layout data before
     mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_FIRST);
-    status = mInnerTableFrame->ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, 
-                                                 &innerTableMaxElementSize, tableStyleMol);
+    aStatus = mInnerTableFrame->ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, 
+                                                  &innerTableMaxElementSize, tableStyleMol);
   
 #ifdef NOISY_MARGINS
     nsIContent* content = mInnerTableFrame->GetContent();
@@ -237,7 +243,10 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   }
   mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_SECOND);
   // assign table width info only if the inner table frame is a first-in-flow
-  if (nsnull==mInnerTableFrame->GetPrevInFlow())
+  nsIFrame* prevInFlow;
+
+  mInnerTableFrame->GetPrevInFlow(prevInFlow);
+  if (nsnull==prevInFlow)
   {
     // assign column widths, and assign aMaxElementSize->width
     mInnerTableFrame->BalanceColumnWidths(aPresContext, tableStyleMol, aMaxSize, aMaxElementSize);
@@ -245,14 +254,17 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
     mInnerTableFrame->SetTableWidth(aPresContext, tableStyleMol);
   }
   // inner table max is now the computed width and assigned  height
-  state.innerTableMaxSize.width = mInnerTableFrame->GetWidth();
+  nsSize  innerTableSize;
+
+  mInnerTableFrame->GetSize(innerTableSize);
+  state.innerTableMaxSize.width = innerTableSize.width;
   state.innerTableMaxSize.height = aMaxSize.height; 
 
   // Reflow the child frames
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aPresContext, state, aMaxElementSize);
     if (PR_FALSE == reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -262,7 +274,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
     if (state.availSize.height <= 0) {
       // No space left. Don't try to pull-up children or reflow unmapped
       if (NextChildOffset() < mContent->ChildCount()) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (NextChildOffset() < mContent->ChildCount()) {
       // Try and pull-up some children from a next-in-flow
@@ -271,12 +283,12 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
         NS_ABORT(); // huge error for tables!
       } else {
         // We were unable to pull-up all the existing frames from the next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there's room for it.
     nscoord margin = state.prevMaxPosBottomMargin -
@@ -320,7 +332,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
   */
   // end REMOVE ME!
 
-  return status;
+  return NS_OK;
 
 }
 
@@ -442,7 +454,9 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
                                   kidFrame, aState.processingCaption?"caption":"inner");
 
     // Get top margin for this kid
-    nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+    nsIStyleContext* kidSC;
+
+    kidFrame->GetStyleContext(aPresContext, kidSC);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
     nscoord bottomMargin = kidMol->margin.bottom;
@@ -505,17 +519,22 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No, the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+
+      kidFrame->GetNextInFlow(kidNextInFlow);
       PRBool lastContentIsComplete = mLastContentIsComplete;
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a continuing
         // frame. This hooks the child into the flow
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to the sibling list
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         if (nsnull == nextSib) {
@@ -528,7 +547,9 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
 
       // We've used up all of our available space so push the remaining
       // children to the next-in-flow
-      nsIFrame* nextSibling = kidFrame->GetNextSibling();
+      nsIFrame* nextSibling;
+       
+      kidFrame->GetNextSibling(nextSibling);
       if (nsnull != nextSibling) {
         PushChildren(nextSibling, kidFrame, lastContentIsComplete);
         SetLastContentOffset(prevKidFrame);
@@ -538,7 +559,7 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
     }
 
     // Get the next child
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
 
     // XXX talk with troy about checking for available space here
   }
@@ -548,7 +569,7 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContex
   NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
 
   // Set the last content offset based on the last child we mapped.
-  NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
   SetLastContentOffset(prevKidFrame);
 
 #ifdef NS_DEBUG
@@ -615,7 +636,9 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
 #ifdef NS_DEBUG
   PRInt32        kidIndex = NextChildOffset();
 #endif
-  nsIFrame*      prevKidFrame = LastChild();
+  nsIFrame*      prevKidFrame;
+   
+  LastChild(prevKidFrame);
 
   // This will hold the prevKidFrame's mLastContentIsComplete
   // status. If we have to push the frame that follows prevKidFrame
@@ -644,7 +667,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
         kidFrame = nextInFlow->mFirstChild;
       } else {
         // We've pulled up all the children, so move to the next-in-flow.
-        nextInFlow = (nsTableOuterFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
         continue;
       }
     }
@@ -652,8 +675,13 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
     // See if the child fits in the available space. If it fits or
     // it's splittable then reflow it. The reason we can't just move
     // it is that we still need ascent/descent information
-    if ((kidFrame->GetWidth() > aState.availSize.height) &&
-        !kidFrame->IsSplittable()) {
+    nsSize  kidFrameSize;
+    PRBool  kidIsSplittable;
+
+    kidFrame->GetSize(kidFrameSize);
+    kidFrame->IsSplittable(kidIsSplittable);
+
+    if ((kidFrameSize.width  > aState.availSize.height) && !kidIsSplittable) {
       result = PR_FALSE;
       mLastContentIsComplete = prevLastContentIsComplete;
       break;
@@ -678,7 +706,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
     PlaceChild(aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
 
     // Remove the frame from its current parent
-    nextInFlow->mFirstChild = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(nextInFlow->mFirstChild);
     nextInFlow->mChildCount--;
     // Update the next-in-flows first content offset
     if (nsnull != nextInFlow->mFirstChild) {
@@ -687,7 +715,10 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
 
     // Link the frame into our list of children
     kidFrame->SetGeometricParent(this);
-    if (nextInFlow == kidFrame->GetContentParent()) {
+    nsIFrame* kidContentParent;
+
+    kidFrame->GetContentParent(kidContentParent);
+    if (nextInFlow == kidContentParent) {
       kidFrame->SetContentParent(this);
     }
     if (nsnull == prevKidFrame) {
@@ -707,13 +738,16 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a
         // continuing frame. The creation appends it to the flow and
         // prepares it for reflow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to our sibling list and then push
@@ -741,7 +775,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
 
   // Update our last content offset
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -761,7 +795,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
       // the next-in-flows must be empty. Do a sanity check
       while (nsnull != nextInFlow) {
         NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
-        nextInFlow = (nsTableOuterFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
       }
 #endif
     }
@@ -799,7 +833,9 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
   */
 void nsTableOuterFrame::SetReflowState(OuterTableReflowState& aState, nsIFrame* aKidFrame)
 {
-  nsIContent *kid = aKidFrame->GetContent();                             // kid: REFCNT++
+  nsIContent *kid;
+   
+  aKidFrame->GetContent(kid);                             // kid: REFCNT++
   nsITableContent *tableContentInterface = nsnull;
   kid->QueryInterface(kITableContentIID, (void**)&tableContentInterface);// tableContentInterface: REFCNT++
   if (nsnull!=tableContentInterface)
@@ -832,7 +868,9 @@ nsTableOuterFrame::ReflowChild( nsIFrame*        aKidFrame,
   if (PR_TRUE==aState.processingCaption)
   { // it's a caption, find out if it's top or bottom
     // Resolve style
-    nsIStyleContext* captionStyleContext = aKidFrame->GetStyleContext(aPresContext);
+    nsIStyleContext* captionStyleContext;
+
+    aKidFrame->GetStyleContext(aPresContext, captionStyleContext);
     NS_ASSERTION(nsnull != captionStyleContext, "null style context for caption");
     nsStyleMolecule* captionStyle =
       (nsStyleMolecule*)captionStyleContext->GetData(kStyleMoleculeSID);
@@ -852,13 +890,16 @@ nsTableOuterFrame::ReflowChild( nsIFrame*        aKidFrame,
                                                            mMinCaptionWidth, mMaxCaptionWidth);
 
   if (frComplete == status) {
-    nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow();
+    nsIFrame* kidNextInFlow;
+     
+    aKidFrame->GetNextInFlow(kidNextInFlow);
     if (nsnull != kidNextInFlow) {
       // Remove all of the childs next-in-flows. Make sure that we ask
       // the right parent to do the removal (it's possible that the
       // parent is not this because we are executing pullup code)
-      nsTableOuterFrame* parent = (nsTableOuterFrame*)
-        aKidFrame->GetGeometricParent();
+      nsTableOuterFrame* parent;
+       
+      aKidFrame->GetGeometricParent((nsIFrame*&)parent);
       parent->DeleteChildsNextInFlow(aKidFrame);
     }
   }
@@ -956,7 +997,8 @@ nsTableOuterFrame::ResizeReflowCaptionsPass1(nsIPresContext* aPresContext, nsSty
       nsSize maxSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
       nsReflowMetrics desiredSize;
       nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);
-      captionFrame->ResizeReflow(aPresContext, desiredSize, maxSize, &maxElementSize);
+      ReflowStatus  status;
+      captionFrame->ResizeReflow(aPresContext, desiredSize, maxSize, &maxElementSize, status);
       if (mMinCaptionWidth<maxElementSize.width)
         mMinCaptionWidth = maxElementSize.width;
       if (mMaxCaptionWidth<desiredSize.width)
@@ -986,7 +1028,9 @@ nsTableOuterFrame::ResizeReflowTopCaptionsPass2(nsIPresContext*  aPresContext,
       nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);
 
       // Resolve style
-      nsIStyleContext* captionStyleContext = captionFrame->GetStyleContext(aPresContext);
+      nsIStyleContext* captionStyleContext;
+       
+      captionFrame->GetStyleContext(aPresContext, captionStyleContext);
       NS_ASSERTION(nsnull != captionStyleContext, "null style context for caption");
       nsStyleMolecule* captionStyle =
         (nsStyleMolecule*)captionStyleContext->GetData(kStyleMoleculeSID);
@@ -1009,7 +1053,10 @@ nsTableOuterFrame::ResizeReflowTopCaptionsPass2(nsIPresContext*  aPresContext,
           else
             topCaptionY = NS_UNCONSTRAINEDSIZE;
           mInnerTableFrame->MoveTo(0, topCaptionY);
-          if (0==captionFrame->GetIndexInParent())
+          PRInt32 captionIndexInParent;
+
+          captionFrame->GetIndexInParent(captionIndexInParent);
+          if (0==captionIndexInParent)
           {
             SetFirstContentOffset(captionFrame);
             if (gsDebug) printf("OUTER: set first content offset to %d\n", GetFirstContentOffset()); //@@@
@@ -1061,7 +1108,9 @@ nsTableOuterFrame::ResizeReflowBottomCaptionsPass2(nsIPresContext*  aPresContext
       result = nsContainerFrame::ReflowChild(captionFrame, aPresContext, desiredSize, aMaxSize, nsnull);
 
       // place the caption
-      nsRect rect = captionFrame->GetRect();
+      nsRect rect;
+       
+      captionFrame->GetRect(rect);
       rect.y = bottomCaptionY;
       rect.width=desiredSize.width;
       rect.height=desiredSize.height;
@@ -1114,27 +1163,29 @@ void nsTableOuterFrame::SetLastContentOffset(const nsIFrame* aLastChild)
 }
 */
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableOuterFrame::IncrementalReflow(nsIPresContext* aPresContext,
                                     nsReflowMetrics& aDesiredSize,
                                     const nsSize&    aMaxSize,
-                                    nsReflowCommand& aReflowCommand)
+                                    nsReflowCommand& aReflowCommand,
+                                     ReflowStatus&   aStatus)
 {
   if (gsDebug == PR_TRUE) printf("nsTableOuterFrame::IncrementalReflow\n");
   // total hack for now, just some hard-coded values
-  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
-
-  return frComplete;
+  ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
+  return NS_OK;
 }
 
-nsIFrame* nsTableOuterFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                   nsIFrame*       aParent)
+NS_METHOD nsTableOuterFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                   nsIFrame*       aParent,
+                                                   nsIFrame*&      aContinuingFrame)
 {
   nsTableOuterFrame* cf = new nsTableOuterFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
   cf->SetFirstPassValid(PR_TRUE);
   printf("nsTableOuterFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 void nsTableOuterFrame::PrepareContinuingFrame(nsIPresContext*    aPresContext,
@@ -1169,11 +1220,12 @@ void nsTableOuterFrame::PrepareContinuingFrame(nsIPresContext*    aPresContext,
   NS_RELEASE(styleContext);
 }
 
-void nsTableOuterFrame::VerifyTree() const
+NS_METHOD nsTableOuterFrame::VerifyTree() const
 {
 #ifdef NS_DEBUG
   
 #endif 
+  return NS_OK;
 }
 
 /**
@@ -1191,28 +1243,44 @@ void nsTableOuterFrame::VerifyTree() const
  */
 PRBool nsTableOuterFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
 {
-  NS_PRECONDITION(aChild->GetGeometricParent() == (nsIFrame*)this, "bad geometric parent");
-  NS_PRECONDITION(nsnull != aChild->GetNextInFlow(), "null next-in-flow");
+  NS_PRECONDITION(IsChild(aChild), "bad geometric parent");
 
-  nsIFrame*         nextInFlow = aChild->GetNextInFlow();
-  nsTableOuterFrame* parent = (nsTableOuterFrame*)nextInFlow->GetGeometricParent();
+  nsIFrame* nextInFlow;
+   
+  aChild->GetNextInFlow(nextInFlow);
+
+  NS_PRECONDITION(nsnull != nextInFlow, "null next-in-flow");
+  nsTableOuterFrame* parent;
+   
+  nextInFlow->GetGeometricParent((nsIFrame*&)parent);
 
   // If the next-in-flow has a next-in-flow then delete it too (and
   // delete it first).
-  if (nsnull != nextInFlow->GetNextInFlow()) {
+  nsIFrame* nextNextInFlow;
+
+  nextInFlow->GetNextInFlow(nextNextInFlow);
+  if (nsnull != nextNextInFlow) {
     parent->DeleteChildsNextInFlow(nextInFlow);
   }
 
-  NS_ASSERTION((0 == nextInFlow->ChildCount()) &&
-               (nsnull == nextInFlow->FirstChild()),
-               "deleting !empty next-in-flow");
+#ifdef NS_DEBUG
+  PRInt32   childCount;
+  nsIFrame* firstChild;
+
+  nextInFlow->ChildCount(childCount);
+  nextInFlow->FirstChild(firstChild);
+
+  NS_ASSERTION(childCount == 0, "deleting !empty next-in-flow");
+
+  NS_ASSERTION((0 == childCount) && (nsnull == firstChild), "deleting !empty next-in-flow");
+#endif
 
   // Disconnect the next-in-flow from the flow list
   nextInFlow->BreakFromPrevFlow();
 
   // Take the next-in-flow out of the parent's child list
   if (parent->mFirstChild == nextInFlow) {
-    parent->mFirstChild = nextInFlow->GetNextSibling();
+    nextInFlow->GetNextSibling(parent->mFirstChild);
     if (nsnull != parent->mFirstChild) {
       parent->SetFirstContentOffset(parent->mFirstChild);
       if (parent->IsPseudoFrame()) {
@@ -1229,22 +1297,30 @@ PRBool nsTableOuterFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
     // will be repaired.
 
   } else {
+    nsIFrame* nextSibling;
+
     // Because the next-in-flow is not the first child of the parent
     // we know that it shares a parent with aChild. Therefore, we need
     // to capture the next-in-flow's next sibling (in case the
     // next-in-flow is the last next-in-flow for aChild AND the
     // next-in-flow is not the last child in parent)
-    NS_ASSERTION(aChild->GetGeometricParent() == parent, "screwy flow");
-    NS_ASSERTION(aChild->GetNextSibling() == nextInFlow, "unexpected sibling");
+    NS_ASSERTION(parent->IsChild(aChild), "screwy flow");
+    aChild->GetNextSibling(nextSibling);
+    NS_ASSERTION(nextSibling == nextInFlow, "unexpected sibling");
 
-    aChild->SetNextSibling(nextInFlow->GetNextSibling());
+    nextInFlow->GetNextSibling(nextSibling);
+    aChild->SetNextSibling(nextSibling);
   }
 
   // Delete the next-in-flow frame and adjust it's parent's child count
   nextInFlow->DeleteFrame();
   parent->mChildCount--;
 
-  NS_POSTCONDITION(nsnull == aChild->GetNextInFlow(), "non null next-in-flow");
+#ifdef NS_DEBUG
+  aChild->GetNextInFlow(nextInFlow);
+  NS_POSTCONDITION(nsnull == nextInFlow, "non null next-in-flow");
+#endif
+
   return PR_TRUE;
 }
 
@@ -1268,10 +1344,13 @@ void nsTableOuterFrame::CreateInnerTableFrame(nsIPresContext* aPresContext)
     nsIFrame* prevInnerTable = prevOuterTable->mInnerTableFrame;
 
     // Create a continuing column
-    mInnerTableFrame = (nsTableFrame *)prevInnerTable->GetNextInFlow();
+    prevInnerTable->GetNextInFlow((nsIFrame*&)mInnerTableFrame);
     if (nsnull==mInnerTableFrame)
     {
-      mInnerTableFrame = (nsTableFrame *)prevInnerTable->CreateContinuingFrame(aPresContext, this);
+      nsIFrame* continuingFrame;
+
+      prevInnerTable->CreateContinuingFrame(aPresContext, this, continuingFrame);
+      mInnerTableFrame = (nsTableFrame*)continuingFrame;
       mChildCount++;
     }
   }
diff --git a/mozilla/layout/tables/nsTableOuterFrame.h b/mozilla/layout/tables/nsTableOuterFrame.h
index e4967ec41b0..041f43c25fa 100644
--- a/mozilla/layout/tables/nsTableOuterFrame.h
+++ b/mozilla/layout/tables/nsTableOuterFrame.h
@@ -56,9 +56,9 @@ public:
                            nsIFrame*   aParent);
 
   /** @see nsIFrame::Paint */
-  virtual void  Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
   /** outer tables are reflowed in two steps.
     * Step 1:, we lay out all of the captions and the inner table with
@@ -85,20 +85,23 @@ public:
     * @see nsTableFrame::BalanceColumnWidths
     * @see nsIFrame::ResizeReflow 
     */
-  ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&    aMaxSize,
-                             nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&    aMaxSize,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
   /** @see nsIFrame::IncrementalReflow */
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
   /** @see nsContainerFrame */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
   /** destructor */
   virtual ~nsTableOuterFrame();
 
@@ -205,7 +208,7 @@ protected:
   /** overridden here to handle special caption-table relationship
     * @see nsContainerFrame::VerifyTree
     */
-  virtual void VerifyTree() const;
+  NS_IMETHOD VerifyTree() const;
 
   /** overridden here to handle special caption-table relationship
     * @see nsContainerFrame::PrepareContinuingFrame
diff --git a/mozilla/layout/tables/nsTableRowFrame.cpp b/mozilla/layout/tables/nsTableRowFrame.cpp
index a38993f7956..e493d706124 100644
--- a/mozilla/layout/tables/nsTableRowFrame.cpp
+++ b/mozilla/layout/tables/nsTableRowFrame.cpp
@@ -63,9 +63,9 @@ void nsTableRowFrame::SetMaxChildHeight(PRInt32 aChildHeight)
     mTallestCell = aChildHeight;
 }
 
-void nsTableRowFrame::Paint(nsIPresContext& aPresContext,
-                            nsIRenderingContext& aRenderingContext,
-                            const nsRect& aDirtyRect)
+NS_METHOD nsTableRowFrame::Paint(nsIPresContext& aPresContext,
+                                 nsIRenderingContext& aRenderingContext,
+                                 const nsRect& aDirtyRect)
 {
   // for debug...
   if (nsIFrame::GetShowFrameBorders()) {
@@ -74,6 +74,7 @@ void nsTableRowFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 // aDirtyRect is in our coordinate system
@@ -87,7 +88,9 @@ void nsTableRowFrame::PaintChildren(nsIPresContext&      aPresContext,
 {
   nsIFrame* kid = mFirstChild;
   while (nsnull != kid) {
-    nsIView *pView = kid->GetView();
+    nsIView *pView;
+     
+    kid->GetView(pView);
     if (nsnull == pView) {
       nsRect kidRect;
       kid->GetRect(kidRect);
@@ -103,10 +106,10 @@ void nsTableRowFrame::PaintChildren(nsIPresContext&      aPresContext,
         aRenderingContext.DrawRect(0, 0, kidRect.width, kidRect.height);
       }
       aRenderingContext.PopState();
-    }
-    else
+    } else {
       NS_RELEASE(pView);
-    kid = kid->GetNextSibling();
+    }
+    kid->GetNextSibling(kid);
   }
 }
 
@@ -129,11 +132,12 @@ are present.
   * This method stacks rows horizontally according to HTML 4.0 rules.
   * Rows are responsible for layout of their children.
   */
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
                               nsReflowMetrics& aDesiredSize,
                               const nsSize&    aMaxSize,
-                              nsSize*          aMaxElementSize)
+                              nsSize*          aMaxElementSize,
+                              ReflowStatus&    aStatus)
 {
   if (gsDebug1==PR_TRUE) 
     printf("nsTableRowFrame::ResizeReflow - %p with aMaxSize = %d, %d\n",
@@ -145,7 +149,7 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
   PRInt32 maxCellHeight = 0;
   ResetMaxChildHeight();
 
-  ReflowStatus result = frComplete;
+  aStatus = frComplete;
 
   mFirstContentOffset = mLastContentOffset = 0;
 
@@ -165,17 +169,21 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
 
 // Row doesn't factor in insets, the cells do that
 
-  nsTableFrame *tableFrame = (nsTableFrame *)(GetContentParent()->GetContentParent());
+  nsTableFrame *tableFrame;
+   
+  mContentParent->GetContentParent((nsIFrame*&)tableFrame);
 
   for (;;) {
     nsIContent* kid = c->ChildAt(kidIndex);   // kid: REFCNT++
     if (nsnull == kid) {
-      result = frComplete;
+      aStatus = frComplete;
       break;
     }
 
     // get frame, creating one if needed
-    nsIFrame* kidFrame = ChildAt(kidIndex);
+    nsIFrame* kidFrame;
+     
+    ChildAt(kidIndex, kidFrame);
     if (nsnull==kidFrame)
     {
       nsIContentDelegate* kidDel;
@@ -191,20 +199,24 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
       NS_RELEASE(kidStyleContext);
     }
 
-    nsTableCell* cell = (nsTableCell *)(kidFrame->GetContent());  // cell: ADDREF++
+    nsTableCell* cell;
+     
+    kidFrame->GetContent((nsIContent*&)cell);  // cell: ADDREF++
     // Try to reflow the child into the available space.
     if (NS_UNCONSTRAINEDSIZE == availSize.width)
     {  // Each cell is given the entire row width to try to lay out into
-      result = ReflowChild(kidFrame, aPresContext, kidSize, availSize, &kidMaxSize);
+      aStatus = ReflowChild(kidFrame, aPresContext, kidSize, availSize, &kidMaxSize);
       if (gsDebug1) printf("reflow of cell returned result = %s with desired=%d,%d, min = %d,%d\n",
-                            result==frComplete?"complete":"NOT complete", 
+                            aStatus==frComplete?"complete":"NOT complete", 
                             kidSize.width, kidSize.height, kidMaxSize.width, kidMaxSize.height);
       nsCellLayoutData kidLayoutData((nsTableCellFrame *)kidFrame, &kidSize, &kidMaxSize);
       tableFrame->SetCellLayoutData(&kidLayoutData, cell);
     }
     else
     { // we're in a constrained situation, so get the avail width from the known column widths
-      nsTableFrame *innerTableFrame = (nsTableFrame *)(GetContentParent()->GetContentParent());
+      nsTableFrame *innerTableFrame;
+       
+      mContentParent->GetContentParent((nsIFrame*&)innerTableFrame);
       nsCellLayoutData *cellData = innerTableFrame->GetCellLayoutData(cell);
       PRInt32 cellStartingCol = cell->GetColIndex();
       PRInt32 cellColSpan = cell->GetColSpan();
@@ -213,9 +225,9 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
         availWidth += innerTableFrame->GetColumnWidth(cellStartingCol+numColSpan);
       NS_ASSERTION(0<availWidth, "illegal width for this column");
       nsSize availSizeWithSpans(availWidth, availSize.height);
-      result = ReflowChild(kidFrame, aPresContext, kidSize, availSizeWithSpans, &kidMaxSize);
+      aStatus = ReflowChild(kidFrame, aPresContext, kidSize, availSizeWithSpans, &kidMaxSize);
       if (gsDebug1) printf("reflow of cell returned result = %s with desired=%d,%d, min = %d,%d\n",
-                            result==frComplete?"complete":"NOT complete", 
+                            aStatus==frComplete?"complete":"NOT complete", 
                             kidSize.width, kidSize.height, kidMaxSize.width, kidMaxSize.height);
 
       // SEC: TODO: this next block could be smarter, 
@@ -268,7 +280,7 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
     prevKidFrame = kidFrame;
 
     kidIndex++;
-    if (frNotComplete == result) {
+    if (frNotComplete == aStatus) {
       // If the child didn't finish layout then it means that it used
       // up all of our available space (or needs us to split).
       mLastContentIsComplete = PR_FALSE;
@@ -278,12 +290,11 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
   }
 
   if (nsnull != prevKidFrame) {
-    if (LastChild()!=prevKidFrame)
+    if (!IsLastChild(prevKidFrame))
     {
-      nsIFrame * frame = LastChild();
-      GetGeometricParent()->List();
+      mGeometricParent->List();
     }
-    NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -298,46 +309,48 @@ nsTableRowFrame::ResizeReflow(nsIPresContext*  aPresContext,
   SetMaxChildHeight(maxCellHeight);  // remember height of tallest child who doesn't have a row span
 
 #ifdef NS_DEBUG
-  PostReflowCheck(result);
+  PostReflowCheck(aStatus);
 #endif
 
   if (gsDebug1==PR_TRUE) 
   {
     if (nsnull!=aMaxElementSize)
       printf("nsTableRowFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=%d,%d\n",
-              result==frComplete?"Complete":"Not Complete",
+              aStatus==frComplete?"Complete":"Not Complete",
               aDesiredSize.width, aDesiredSize.height,
               aMaxElementSize->width, aMaxElementSize->height);
     else
       printf("nsTableRowFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=NSNULL\n", 
-             result==frComplete?"Complete":"Not Complete",
+             aStatus==frComplete?"Complete":"Not Complete",
              aDesiredSize.width, aDesiredSize.height);
   }
   
   // testing...
-  result = frComplete;
-
-  return result;
-
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableRowFrame::IncrementalReflow(nsIPresContext*  aPresContext,
                              nsReflowMetrics& aDesiredSize,
                              const nsSize&    aMaxSize,
-                             nsReflowCommand& aReflowCommand)
+                             nsReflowCommand& aReflowCommand,
+                             ReflowStatus&    aStatus)
 {
   if (gsDebug1==PR_TRUE) printf("nsTableRowFrame::IncrementalReflow\n");
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame* nsTableRowFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                 nsIFrame*       aParent)
+NS_METHOD nsTableRowFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                 nsIFrame*       aParent,
+                                                 nsIFrame*&      aContinuingFrame)
 {
   if (gsDebug1==PR_TRUE) printf("nsTableRowFrame::CreateContinuingFrame\n");
   nsTableRowFrame* cf = new nsTableRowFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 nsresult nsTableRowFrame::NewFrame( nsIFrame** aInstancePtrResult,
diff --git a/mozilla/layout/tables/nsTableRowFrame.h b/mozilla/layout/tables/nsTableRowFrame.h
index 240be6deeed..20446c32384 100644
--- a/mozilla/layout/tables/nsTableRowFrame.h
+++ b/mozilla/layout/tables/nsTableRowFrame.h
@@ -52,9 +52,9 @@ public:
                            nsIFrame*   aParent);
 
   /** @see nsIFrame::Paint */
-  virtual void  Paint(nsIPresContext&      aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect&        aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext&      aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect&        aDirtyRect);
 
 
   /** ask all children to paint themselves, without clipping (for cells with rowspan>1)
@@ -77,20 +77,23 @@ public:
     * @see nsTableFrame::BalanceColumnWidths
     * @see nsTableFrame::ShrinkWrapChildren
     */
-  ReflowStatus  ResizeReflow(nsIPresContext*  aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&    aMaxSize,
-                             nsSize*          aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext*  aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&    aMaxSize,
+                          nsSize*          aMaxElementSize,
+                          ReflowStatus&    aStatus);
 
   /** @see nsIFrame::IncrementalReflow */
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
   /** @see nsContainerFrame::CreateContinuingFrame */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
   
   /** set mTallestCell to 0 in anticipation of recalculating it */
   void ResetMaxChildHeight();
diff --git a/mozilla/layout/tables/nsTableRowGroupFrame.cpp b/mozilla/layout/tables/nsTableRowGroupFrame.cpp
index 05eb5f4e21c..db5ef6cb8f9 100644
--- a/mozilla/layout/tables/nsTableRowGroupFrame.cpp
+++ b/mozilla/layout/tables/nsTableRowGroupFrame.cpp
@@ -102,9 +102,9 @@ nsTableRowGroupFrame::~nsTableRowGroupFrame()
 }
 
 
-void nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
-                                 nsIRenderingContext& aRenderingContext,
-                                 const nsRect&        aDirtyRect)
+NS_METHOD nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
+                                      nsIRenderingContext& aRenderingContext,
+                                      const nsRect&        aDirtyRect)
 {
 
   // for debug...
@@ -114,6 +114,7 @@ void nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
   }
 
   PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
+  return NS_OK;
 }
 
 // aDirtyRect is in our coordinate system
@@ -127,7 +128,9 @@ void nsTableRowGroupFrame::PaintChildren(nsIPresContext&      aPresContext,
 {
   nsIFrame* kid = mFirstChild;
   while (nsnull != kid) {
-    nsIView *pView = kid->GetView();
+    nsIView *pView;
+     
+    kid->GetView(pView);
     if (nsnull == pView) {
       nsRect kidRect;
       kid->GetRect(kidRect);
@@ -146,7 +149,7 @@ void nsTableRowGroupFrame::PaintChildren(nsIPresContext&      aPresContext,
     }
     else
       NS_RELEASE(pView);
-    kid = kid->GetNextSibling();
+    kid->GetNextSibling(kid);
   }
 }
 
@@ -257,8 +260,12 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext*      aPresCon
     nsIFrame::ReflowStatus  status;
 
     // Get top margin for this kid
-    nsIContent* kid = kidFrame->GetContent();
-    nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
+    nsIContent* kid;
+     
+    kidFrame->GetContent(kid);
+    nsIStyleContext* kidSC;
+     
+    kidFrame->GetStyleContext(aPresContext, kidSC);
     nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
     nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
     nscoord bottomMargin = kidMol->margin.bottom;
@@ -331,16 +338,21 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext*      aPresCon
     if (frNotComplete == status) {
       // XXX It's good to assume that we might still have room
       // even if the child didn't complete (floaters will want this)
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
 			PRBool lastContentIsComplete = mLastContentIsComplete;
       if (nsnull == kidNextInFlow) {
         // No the child isn't complete, and it doesn't have a next in flow so
         // create a continuing frame. This hooks the child into the flow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
 
         // Insert the frame. We'll reflow it next pass through the loop
-        nsIFrame* nextSib = kidFrame->GetNextSibling();
+        nsIFrame* nextSib;
+         
+        kidFrame->GetNextSibling(nextSib);
         continuingFrame->SetNextSibling(nextSib);
         kidFrame->SetNextSibling(continuingFrame);
         if (nsnull == nextSib) {
@@ -352,7 +364,9 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext*      aPresCon
       }
       // We've used up all of our available space so push the remaining
       // children to the next-in-flow
-      nsIFrame* nextSibling = kidFrame->GetNextSibling();
+      nsIFrame* nextSibling;
+       
+      kidFrame->GetNextSibling(nextSibling);
       if (nsnull != nextSibling) {
         PushChildren(nextSibling, kidFrame, lastContentIsComplete);
         SetLastContentOffset(prevKidFrame);
@@ -362,15 +376,23 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext*      aPresCon
     }
 
     // Get the next child
-    kidFrame = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(kidFrame);
 
   }
 
   // Update the child count
   mChildCount = childCount;
 
+#ifdef NS_DEBUG
   NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
-	NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
+
+  nsIFrame* lastChild;
+  PRInt32   lastIndexInParent;
+
+  LastChild(lastChild);
+  lastChild->GetIndexInParent(lastIndexInParent);
+	NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
+#endif
 
 #ifdef NS_DEBUG
   VerifyLastIsComplete();
@@ -436,7 +458,9 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
 #ifdef NS_DEBUG
   PRInt32        kidIndex = NextChildOffset();
 #endif
-  nsIFrame*      prevKidFrame = LastChild();
+  nsIFrame*      prevKidFrame;
+   
+  LastChild(prevKidFrame);
 
   // This will hold the prevKidFrame's mLastContentIsComplete
   // status. If we have to push the frame that follows prevKidFrame
@@ -465,7 +489,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
         kidFrame = nextInFlow->mFirstChild;
       } else {
         // We've pulled up all the children, so move to the next-in-flow.
-        nextInFlow = (nsTableRowGroupFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
         continue;
       }
     }
@@ -473,8 +497,12 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
     // See if the child fits in the available space. If it fits or
     // it's splittable then reflow it. The reason we can't just move
     // it is that we still need ascent/descent information
-    if ((kidFrame->GetHeight() > aState.availSize.height) &&
-        !kidFrame->IsSplittable()) {
+    nsSize  kidFrameSize;
+    PRBool  kidIsSplittable;
+
+    kidFrame->GetSize(kidFrameSize);
+    kidFrame->IsSplittable(kidIsSplittable);
+    if ((kidFrameSize.height > aState.availSize.height) && !kidIsSplittable) {
       result = PR_FALSE;
       mLastContentIsComplete = prevLastContentIsComplete;
       break;
@@ -499,7 +527,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
     PlaceChild(aPresContext, aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
 
     // Remove the frame from its current parent
-    nextInFlow->mFirstChild = kidFrame->GetNextSibling();
+    kidFrame->GetNextSibling(nextInFlow->mFirstChild);
     nextInFlow->mChildCount--;
     // Update the next-in-flows first content offset
     if (nsnull != nextInFlow->mFirstChild) {
@@ -508,7 +536,10 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
 
     // Link the frame into our list of children
     kidFrame->SetGeometricParent(this);
-    if (nextInFlow == kidFrame->GetContentParent()) {
+    nsIFrame* kidContentParent;
+
+    kidFrame->GetContentParent(kidContentParent);
+    if (nextInFlow == kidContentParent) {
       kidFrame->SetContentParent(this);
     }
     if (nsnull == prevKidFrame) {
@@ -528,13 +559,16 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
     mLastContentIsComplete = PRBool(status == frComplete);
     if (frNotComplete == status) {
       // No the child isn't complete
-      nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+      nsIFrame* kidNextInFlow;
+       
+      kidFrame->GetNextInFlow(kidNextInFlow);
       if (nsnull == kidNextInFlow) {
         // The child doesn't have a next-in-flow so create a
         // continuing frame. The creation appends it to the flow and
         // prepares it for reflow.
-        nsIFrame* continuingFrame =
-          kidFrame->CreateContinuingFrame(aPresContext, this);
+        nsIFrame* continuingFrame;
+         
+        kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
         NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
 
         // Add the continuing frame to our sibling list and then push
@@ -562,7 +596,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
 
   // Update our last content offset
   if (nsnull != prevKidFrame) {
-    NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
     SetLastContentOffset(prevKidFrame);
   }
 
@@ -582,7 +616,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext*      aPresContext,
       // the next-in-flows must be empty. Do a sanity check
       while (nsnull != nextInFlow) {
         NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
-        nextInFlow = (nsTableRowGroupFrame*)nextInFlow->GetNextInFlow();
+        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
       }
 #endif
     }
@@ -643,7 +677,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
     mFirstContentOffset = prev->NextChildOffset();
     if (!prev->mLastContentIsComplete) {
       // Our prev-in-flow's last child is not complete
-      kidPrevInFlow = prev->LastChild();
+      prev->LastChild(kidPrevInFlow);
     }
   }
 
@@ -653,7 +687,9 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   nsSize    kidMaxElementSize;
   nsSize*   pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
   PRInt32   kidIndex = NextChildOffset();
-  nsIFrame* prevKidFrame = LastChild();  // XXX remember this...
+  nsIFrame* prevKidFrame;
+   
+  LastChild(prevKidFrame);  // XXX remember this...
 
   for (;;) {
     // Get the next content object
@@ -688,7 +724,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
       NS_RELEASE(kidDel);
       kidFrame->SetStyleContext(kidStyleContext);
     } else {
-      kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
+      kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
     }
 		NS_RELEASE(kid);
     NS_RELEASE(kidStyleContext);
@@ -738,7 +774,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   }
 
   // Update the content mapping
-  NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
+  NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
   SetLastContentOffset(prevKidFrame);
 #ifdef NS_DEBUG
   PRInt32 len = LengthOf(mFirstChild);
@@ -755,11 +791,12 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext*      aPresContext,
   * This method stacks rows vertically according to HTML 4.0 rules.
   * Rows are responsible for layout of their children.
   */
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
                                     nsReflowMetrics& aDesiredSize,
                                     const nsSize&    aMaxSize,
-                                    nsSize*          aMaxElementSize)
+                                    nsSize*          aMaxElementSize,
+                                    ReflowStatus&    aStatus)
 {
   if (gsDebug1==PR_TRUE)
     printf("nsTableRowGroupFrame::ResizeReflow - aMaxSize = %d, %d\n",
@@ -774,8 +811,9 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
     aMaxElementSize->height = 0;
   }
 
-  PRBool        reflowMappedOK = PR_TRUE;
-  ReflowStatus  status = frComplete;
+  PRBool reflowMappedOK = PR_TRUE;
+
+  aStatus = frComplete;
 
   // Check for an overflow list
   MoveOverflowToChildList();
@@ -788,7 +826,7 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
   if (nsnull != mFirstChild) {
     reflowMappedOK = ReflowMappedChildren(aPresContext, state, aMaxElementSize);
     if (PR_FALSE == reflowMappedOK) {
-      status = frNotComplete;
+      aStatus = frNotComplete;
     }
   }
 
@@ -798,24 +836,24 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
     if (state.availSize.height <= 0) {
       // No space left. Don't try to pull-up children or reflow unmapped
       if (NextChildOffset() < mContent->ChildCount()) {
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     } else if (NextChildOffset() < mContent->ChildCount()) {
       // Try and pull-up some children from a next-in-flow
       if (PullUpChildren(aPresContext, state, aMaxElementSize)) {
         // If we still have unmapped children then create some new frames
         if (NextChildOffset() < mContent->ChildCount()) {
-          status = ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
+          aStatus = ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
         }
       } else {
         // We were unable to pull-up all the existing frames from the
         // next in flow
-        status = frNotComplete;
+        aStatus = frNotComplete;
       }
     }
   }
 
-  if (frComplete == status) {
+  if (frComplete == aStatus) {
     // Don't forget to add in the bottom margin from our last child.
     // Only add it in if there's room for it.
     nscoord margin = state.prevMaxPosBottomMargin -
@@ -832,31 +870,32 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext*  aPresContext,
   aDesiredSize.height = state.y;
 
 #ifdef NS_DEBUG
-  PostReflowCheck(status);
+  PostReflowCheck(aStatus);
 #endif
 
   if (gsDebug1==PR_TRUE) 
   {
     if (nsnull!=aMaxElementSize)
       printf("nsTableRowGroupFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=%d,%d\n",
-              status==frComplete?"Complete":"Not Complete",
+              aStatus==frComplete?"Complete":"Not Complete",
               aDesiredSize.width, aDesiredSize.height,
               aMaxElementSize->width, aMaxElementSize->height);
     else
       printf("nsTableRowGroupFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=NSNULL\n", 
-             status==frComplete?"Complete":"Not Complete",
+             aStatus==frComplete?"Complete":"Not Complete",
              aDesiredSize.width, aDesiredSize.height);
   }
 
-  return status;
+  return NS_OK;
 
 }
 
-nsIFrame::ReflowStatus
+NS_METHOD
 nsTableRowGroupFrame::IncrementalReflow(nsIPresContext*  aPresContext,
                                         nsReflowMetrics& aDesiredSize,
                                         const nsSize&    aMaxSize,
-                                        nsReflowCommand& aReflowCommand)
+                                        nsReflowCommand& aReflowCommand,
+                                        ReflowStatus&    aStatus)
 {
   if (gsDebug1==PR_TRUE) printf("nsTableRowGroupFrame::IncrementalReflow\n");
 
@@ -864,16 +903,19 @@ nsTableRowGroupFrame::IncrementalReflow(nsIPresContext*  aPresContext,
   aDesiredSize.width = aMaxSize.width;
   aDesiredSize.height = aMaxSize.height;
 
-  return frComplete;
+  aStatus = frComplete;
+  return NS_OK;
 }
 
-nsIFrame* nsTableRowGroupFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
-                                                      nsIFrame*       aParent)
+NS_METHOD nsTableRowGroupFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
+                                                      nsIFrame*       aParent,
+                                                      nsIFrame*&      aContinuingFrame)
 {
   nsTableRowGroupFrame* cf = new nsTableRowGroupFrame(mContent, mIndexInParent, aParent);
   PrepareContinuingFrame(aPresContext, aParent, cf);
   if (PR_TRUE==gsDebug1) printf("nsTableRowGroupFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
-  return cf;
+  aContinuingFrame = cf;
+  return NS_OK;
 }
 
 /* ----- static methods ----- */
diff --git a/mozilla/layout/tables/nsTableRowGroupFrame.h b/mozilla/layout/tables/nsTableRowGroupFrame.h
index 6b04e1238ef..1a1045aef22 100644
--- a/mozilla/layout/tables/nsTableRowGroupFrame.h
+++ b/mozilla/layout/tables/nsTableRowGroupFrame.h
@@ -53,9 +53,9 @@ public:
                            nsIFrame*   aParent);
 
   /** @see nsIFrame::Paint */
-  virtual void  Paint(nsIPresContext& aPresContext,
-                      nsIRenderingContext& aRenderingContext,
-                      const nsRect& aDirtyRect);
+  NS_IMETHOD Paint(nsIPresContext& aPresContext,
+                   nsIRenderingContext& aRenderingContext,
+                   const nsRect& aDirtyRect);
 
   /** ask all children to paint themselves, without clipping (for cells with rowspan>1)
     * @see nsIFrame::Paint 
@@ -73,19 +73,22 @@ public:
     *
     * @see nsIFrame::ResizeReflow
     */
-  ReflowStatus  ResizeReflow(nsIPresContext* aPresContext,
-                             nsReflowMetrics& aDesiredSize,
-                             const nsSize&   aMaxSize,
-                             nsSize*         aMaxElementSize);
+  NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
+                          nsReflowMetrics& aDesiredSize,
+                          const nsSize&   aMaxSize,
+                          nsSize*         aMaxElementSize,
+                          ReflowStatus&   aStatus);
   /** @see nsIFrame::IncrementalReflow */
-  ReflowStatus  IncrementalReflow(nsIPresContext*  aPresContext,
-                                  nsReflowMetrics& aDesiredSize,
-                                  const nsSize&    aMaxSize,
-                                  nsReflowCommand& aReflowCommand);
+  NS_IMETHOD IncrementalReflow(nsIPresContext*  aPresContext,
+                               nsReflowMetrics& aDesiredSize,
+                               const nsSize&    aMaxSize,
+                               nsReflowCommand& aReflowCommand,
+                               ReflowStatus&    aStatus);
 
   /** @see nsContainerFrame::CreateContinuingFrame */
-  virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
-                                          nsIFrame*       aParent);
+  NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
+                                   nsIFrame*       aParent,
+                                   nsIFrame*&      aContinuingFrame);
 
 protected:
 
diff --git a/mozilla/view/src/nsView.cpp b/mozilla/view/src/nsView.cpp
index f9afc48e65b..aa99e0e1abf 100644
--- a/mozilla/view/src/nsView.cpp
+++ b/mozilla/view/src/nsView.cpp
@@ -365,7 +365,7 @@ nsEventStatus nsView :: HandleEvent(nsGUIEvent *event, PRBool aCheckParent, PRBo
     event->point.x += xoff;
     event->point.y += yoff;
 
-    retval = mFrame->HandleEvent(*cx, event);
+    mFrame->HandleEvent(*cx, event, retval);
 
     event->point.x -= xoff;
     event->point.y -= yoff;