[New Multicolumn] Support for paged overflow.

Source/core/rendering/RenderBlockFlow.cpp

 /*
  * 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
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 21 matching lines @@
 #include "core/rendering/RenderBlockFlow.h"
 
 #include "core/accessibility/AXObjectCache.h"
 #include "core/frame/FrameView.h"
 #include "core/rendering/FastTextAutosizer.h"
 #include "core/rendering/HitTestLocation.h"
 #include "core/rendering/LayoutRepainter.h"
 #include "core/rendering/RenderFlowThread.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderMultiColumnFlowThread.h"
+#include "core/rendering/RenderPagedFlowThread.h"
 #include "core/rendering/RenderText.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/line/LineWidth.h"
 #include "core/rendering/svg/SVGTextRunRenderingContext.h"
 #include "platform/text/BidiTextRun.h"
 
 using namespace std;
 
 namespace WebCore {
 
@@ skipping 1802 matching lines @@
                     }
                 }
             }
         }
 
         parentBlockFlow->markAllDescendantsWithFloatsForLayout();
         parentBlockFlow->markSiblingsWithFloatsForLayout();
     }
 
     if (diff.needsFullLayout() || !oldStyle)
-        createOrDestroyMultiColumnFlowThreadIfNeeded();
+        createOrDestroyMultiColumnFlowThreadIfNeeded(oldStyle);
 }
 
 void RenderBlockFlow::updateStaticInlinePositionForChild(RenderBox* child, LayoutUnit logicalTop)
 {
     if (child->style()->isOriginalDisplayInlineType())
         setStaticInlinePositionForChild(child, logicalTop, startAlignedOffsetForLine(logicalTop, false));
     else
         setStaticInlinePositionForChild(child, logicalTop, startOffsetForContent());
 }
 
@@ skipping 897 matching lines @@
     bool hasStrongDirectionality;
     run.setDirection(directionForRun(run, hasStrongDirectionality));
     return run;
 }
 
 RootInlineBox* RenderBlockFlow::createRootInlineBox()
 {
     return new RootInlineBox(*this);
 }
 
-void RenderBlockFlow::createOrDestroyMultiColumnFlowThreadIfNeeded()
+static inline bool isPagedOverflow(const RenderBlockFlow* renderer, const RenderStyle* style)
+{
+    return style->isOverflowPaged() && renderer->node() != renderer->document().viewportDefiningElement();

[rune, 2014/06/18 22:09:05]

"this" is always passed as renderer. Why not make this a class method?

+}
+
+void RenderBlockFlow::createOrDestroyMultiColumnFlowThreadIfNeeded(const RenderStyle* oldStyle)
 {
     if (!document().regionBasedColumnsEnabled())
         return;
 
-    bool needsFlowThread = style()->specifiesColumns();
-    if (needsFlowThread != static_cast<bool>(multiColumnFlowThread())) {
-        if (needsFlowThread) {
-            RenderMultiColumnFlowThread* flowThread = RenderMultiColumnFlowThread::createAnonymous(document(), style());
-            addChild(flowThread);
-            flowThread->populate();
-            RenderBlockFlowRareData& rareData = ensureRareData();
-            ASSERT(!rareData.m_multiColumnFlowThread);
-            rareData.m_multiColumnFlowThread = flowThread;
-        } else {
+    // Paged overflow trumps multicol in this implementation. Ideally, it should be possible to have
+    // both paged overflow and multicol on the same element, but then we need two flow
+    // threads. Anyway, this is nothing to worry about until we can actually nest multicol properly
+    // inside other fragmentation contexts.
+    bool shouldBePaged = isPagedOverflow(this, style());
+    bool shouldBeMulticol = !shouldBePaged && style()->specifiesColumns();
+

[rune, 2014/06/18 22:09:05]

We can get rid of this code duplication. Also we can have an enumerated type
instead of two booleans.

How about (modulo naming):

FlowThreadType { None, MultiColumn, Paged }

FlowThreadType flowThreadType(const RenderStyle* style) {
    if (isPagedOverflow(style))
        return Paged;
    if (style->specifiesColumns())
        return MultiColumn;
    return None;
}

and then  compare new/old FlowThreadType.

+    if (multiColumnFlowThread()) {
+        ASSERT(oldStyle);
+        bool wasPaged = isPagedOverflow(this, oldStyle);
+        bool wasMulticol = !wasPaged && oldStyle->specifiesColumns();
+        if (wasMulticol != shouldBeMulticol || wasPaged != shouldBePaged) {
+            // If we're no longer to be multicol/paged, destroy the flow thread. Also destroy it
+            // when switching between multicol and paged, since that affects the column set
+            // structure (multicol containers may have spanners, paged containers may not).
             multiColumnFlowThread()->evacuateAndDestroy();
             ASSERT(!multiColumnFlowThread());
         }
     }
+    if ((shouldBeMulticol || shouldBePaged) && !multiColumnFlowThread()) {
+        RenderMultiColumnFlowThread* flowThread;
+        if (shouldBePaged) {
+            // Paged overflow is currently done using the multicol implementation.
+            flowThread = RenderPagedFlowThread::createAnonymous(document(), style());
+        } else {
+            flowThread = RenderMultiColumnFlowThread::createAnonymous(document(), style());
+        }
+        addChild(flowThread);
+        flowThread->populate();
+        RenderBlockFlowRareData& rareData = ensureRareData();
+        ASSERT(!rareData.m_multiColumnFlowThread);
+        rareData.m_multiColumnFlowThread = flowThread;
+    }
 }
 
 RenderBlockFlow::RenderBlockFlowRareData& RenderBlockFlow::ensureRareData()
 {
     if (m_rareData)
         return *m_rareData;
 
     m_rareData = adoptPtr(new RenderBlockFlowRareData(this));
     return *m_rareData;
 }
 
 } // namespace WebCore