*** FOR PROTOTYPE PURPOSES ONLY! NOT INTENDED FOR COMMIT! ***

Source/core/rendering/RenderBlockFlow.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003-2013 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ skipping 23 matching lines @@
  */
 
 #ifndef RenderBlockFlow_h
 #define RenderBlockFlow_h
 
 #include "core/rendering/FloatingObjects.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/line/TrailingObjects.h"
 #include "core/rendering/style/RenderStyleConstants.h"
 
+// This define globally controls whether we use recursion or not for layout. The
+// default is recursion and all layout tests pass with this patch and this default.
+// Right now, if you switch to non-recursion I still have ~500 failures, but the
+// vast majority of tests that exercise this code are passing.
+#define NON_RECURSIVE 0
+
 namespace WebCore {
 
 class MarginInfo;
+class LayoutStateMaintainer;
 class LineBreaker;
 class LineWidth;
 class RenderNamedFlowFragment;
+class SubtreeLayoutScope;
 
 class RenderBlockFlow : public RenderBlock {
 public:
     explicit RenderBlockFlow(ContainerNode*);
     virtual ~RenderBlockFlow();
 
     static RenderBlockFlow* createAnonymous(Document*);
     RenderBlockFlow* createAnonymousBlockFlow() const;
 
     virtual bool isRenderBlockFlow() const OVERRIDE FINAL { return true; }
 
+#if NON_RECURSIVE
+    virtual bool isNonRecursiveLayout() const OVERRIDE { return true; }
+#else
+    virtual bool isNonRecursiveLayout() const OVERRIDE { return false; }
+#endif
     virtual void layoutBlock(bool relayoutChildren) OVERRIDE;
+    virtual void preLayoutBlock(bool relayoutChildren, bool traverseChildren) OVERRIDE;
+    virtual bool postLayoutBlock() OVERRIDE;
 
     virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false) OVERRIDE;
     virtual void deleteLineBoxTree() OVERRIDE FINAL;
 
     // Versions that can compute line offsets with the region and page offset passed in. Used for speed to avoid having to
     // compute the region all over again when you already know it.
     LayoutUnit availableLogicalWidthForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
     {
         return max<LayoutUnit>(0, logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
             - logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight));
@@ skipping 176 matching lines @@
         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
     }
     LayoutUnit logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0) const
     {
         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
     }
 
     virtual void insertedIntoTree() OVERRIDE;
     virtual void willBeDestroyed() OVERRIDE;
 private:
-    bool layoutBlockFlow(bool relayoutChildren, LayoutUnit& pageLogicalHeight, SubtreeLayoutScope&);
-    void layoutBlockChildren(bool relayoutChildren, LayoutUnit& maxFloatLogicalBottom, SubtreeLayoutScope&, LayoutUnit beforeEdge, LayoutUnit afterEdge);
+    void preLayoutBlockFlow(bool traverseChildren);
+    bool postLayoutBlockFlow();
+    bool preLayoutBlockChild(RenderBox* child, bool& skipChildren);
+    void postLayoutBlockChild(RenderBox* child);
 
-    void layoutBlockChild(RenderBox* child, MarginInfo&, LayoutUnit& previousFloatLogicalBottom, LayoutUnit& maxFloatLogicalBottom);
+    void layoutBlockChildren(LayoutUnit beforeEdge, LayoutUnit afterEdge, bool traverseChildren);
+
     void adjustPositionedBlock(RenderBox* child, const MarginInfo&);
     void adjustFloatingBlock(const MarginInfo&);
 
     LayoutPoint flipFloatForWritingModeForChild(const FloatingObject*, const LayoutPoint&) const;
 
     LayoutUnit xPositionForFloatIncludingMargin(const FloatingObject* child) const
     {
         if (isHorizontalWritingMode())
             return child->x() + child->renderer()->marginLeft();
 
@@ skipping 242 matching lines @@
     bool checkPaginationAndFloatsAtEndLine(LineLayoutState&);
     bool matchedEndLine(LineLayoutState&, const InlineBidiResolver&, const InlineIterator& endLineStart, const BidiStatus& endLineStatus);
     void deleteEllipsisLineBoxes();
     void checkLinesForTextOverflow();
     // Positions new floats and also adjust all floats encountered on the line if any of them
     // have to move to the next page/column.
     bool positionNewFloatOnLine(FloatingObject* newFloat, FloatingObject* lastFloatFromPreviousLine, LineInfo&, LineWidth&);
 
 
 // END METHODS DEFINED IN RenderBlockLineLayout
+private:
+    // Here we have the state that was previously held on the stack and now needs
+    // to be held somewhere else.  I've put the state as member variables of this
+    // class, but most likely we'd need to put them in LayoutState or something
+    // very similar.  Each subclass will have its own needs so perhaps we'll need
+    // LayoutState inner class that each RenderObject can subclass and override
+    // or something.
+    // FIXME: Figure out the best way to manage this state for this class and the
+    // other various subclasses that switch to non-recursive layout.
 
+    // Used by (pre/post)layoutBlockFlow and friends
+    SubtreeLayoutScope* m_layoutScope;
+    LayoutStateMaintainer* m_statePusher;
+    bool m_hasSpecifiedPageLogicalHeight;
+    bool m_checkForRepaint;
+    bool m_relayoutChildren;
+    LayoutRect m_oldBounds;
+    LayoutRect m_oldOutlineBox;
+    LayoutUnit m_pageLogicalHeight;
+    LayoutUnit m_heightBeforeLayout;
+    LayoutUnit m_previousFloatLogicalBottom;
+    LayoutUnit m_maxFloatLogicalBottom;
+    RenderBox* m_lastNormalFlowChild;
+    MarginInfo* m_marginInfo;
+
+    // Used by (pre/post) layoutBlockChild and friends
+    RenderObject* m_childToExclude;
+    SubtreeLayoutScope* m_childLayoutScope;
+    LayoutUnit m_oldPosMarginBefore;
+    LayoutUnit m_oldNegMarginBefore;
+    LayoutUnit m_estimateWithoutPagination;
+    LayoutUnit m_logicalTopEstimate;
+    LayoutRect m_oldRect;
+    LayoutSize m_oldLayoutDelta;
+    bool m_childHadLayout;
+    bool m_childNeededLayout;

[esprehn, 2014/02/15 00:35:43]

This is huge, I don't think you can make RenderBlockFlow this large.

[atreat, 2014/02/18 16:03:57]

No, of course not.  That is why I said in the comment that this is for prototype
purposes and we'll need a better way to handle the state.  I could have put this
in LayoutState, but I did not want to complicate the prototype and I wanted to
discuss with you guys the best way to manage this state

My current thinking is to add an InternalLayoutState to LayoutState that each
class could override that would provide a place to hold this state.

 };
 
 DEFINE_RENDER_OBJECT_TYPE_CASTS(RenderBlockFlow, isRenderBlockFlow());
 
 } // namespace WebCore
 
 #endif // RenderBlockFlow_h