Add support for printing multicol containers, and enable it.

third_party/WebKit/Source/core/layout/LayoutMultiColumnFlowThread.cpp

 /*
  * Copyright (C) 2012 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 10 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/layout/LayoutMultiColumnFlowThread.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
+#include "core/layout/LayoutView.h"
 #include "core/layout/MultiColumnFragmentainerGroup.h"
+#include "core/layout/ViewFragmentationContext.h"
 
 namespace blink {
 
 LayoutMultiColumnFlowThread::LayoutMultiColumnFlowThread()
     : m_lastSetWorkedOn(nullptr)
     , m_columnCount(1)
     , m_columnHeightAvailable(0)
     , m_inBalancingPass(false)
     , m_needsColumnHeightsRecalculation(false)
     , m_progressionIsInline(true)
@@ skipping 306 matching lines @@
 
 void LayoutMultiColumnFlowThread::layoutColumns(SubtreeLayoutScope& layoutScope)
 {
     // Since we ended up here, it means that the multicol container (our parent) needed
     // layout. Since contents of the multicol container are diverted to the flow thread, the flow
     // thread needs layout as well.
     layoutScope.setChildNeedsLayout(this);
 
     m_needsColumnHeightsRecalculation = false;
 
-    m_blockOffsetInEnclosingFlowThread = enclosingFlowThread() ? multiColumnBlockFlow()->offsetFromLogicalTopOfFirstPage() : LayoutUnit();
+    m_blockOffsetInEnclosingFragmentationContext = enclosingFragmentationContext() ? multiColumnBlockFlow()->offsetFromLogicalTopOfFirstPage() : LayoutUnit();
 
     for (LayoutBox* columnBox = firstMultiColumnBox(); columnBox; columnBox = columnBox->nextSiblingMultiColumnBox()) {
         if (!columnBox->isLayoutMultiColumnSet()) {
             ASSERT(columnBox->isLayoutMultiColumnSpannerPlaceholder()); // no other type is expected.
             m_needsColumnHeightsRecalculation = true;
             continue;
         }
         LayoutMultiColumnSet* columnSet = toLayoutMultiColumnSet(columnBox);
         layoutScope.setChildNeedsLayout(columnSet);
         if (!m_inBalancingPass) {
@@ skipping 63 matching lines @@
     return true;
 }
 
 LayoutMultiColumnFlowThread* LayoutMultiColumnFlowThread::enclosingFlowThread() const
 {
     if (multiColumnBlockFlow()->isInsideFlowThread())
         return toLayoutMultiColumnFlowThread(locateFlowThreadContainingBlockOf(*multiColumnBlockFlow()));
     return nullptr;
 }
 
+FragmentationContext* LayoutMultiColumnFlowThread::enclosingFragmentationContext() const
+{
+    if (LayoutMultiColumnFlowThread* enclosingFlowThread = this->enclosingFlowThread())
+        return enclosingFlowThread;
+    return view()->fragmentationContext();
+}
+
 void LayoutMultiColumnFlowThread::appendNewFragmentainerGroupIfNeeded(LayoutUnit offsetInFlowThread)
 {
     if (!isPageLogicalHeightKnown()) {
         // If we have no clue about the height of the multicol container, bail. This situation
         // occurs initially when an auto-height multicol container is nested inside another
         // auto-height multicol container. We need at least an estimated height of the outer
         // multicol container before we can check what an inner fragmentainer group has room for.
         // Its height is indefinite for now.
         return;
     }
     LayoutMultiColumnSet* columnSet = columnSetAtBlockOffset(offsetInFlowThread);
     if (columnSet->isInitialHeightCalculated()) {
         // We only insert additional fragmentainer groups in the initial layout pass. We only want
         // to balance columns in the last fragmentainer group (if we need to balance at all), so we
         // want that last fragmentainer group to be the same one in all layout passes that follow.
         return;
     }
 
     if (!columnSet->hasFragmentainerGroupForColumnAt(offsetInFlowThread)) {
-        LayoutMultiColumnFlowThread* enclosingFlowThread = this->enclosingFlowThread();
-        if (!enclosingFlowThread)
+        FragmentationContext* enclosingFragmentationContext = this->enclosingFragmentationContext();
+        if (!enclosingFragmentationContext)
             return; // Not nested. We'll never need more rows than the one we already have then.
 
         // We have run out of columns here, so we add another row to hold more columns. When we add
         // a new row, it implicitly means that we're inserting another column in our enclosing
         // multicol container. That in turn may mean that we've run out of columns there too.
         const MultiColumnFragmentainerGroup& newRow = columnSet->appendNewFragmentainerGroup();
-        enclosingFlowThread->appendNewFragmentainerGroupIfNeeded(newRow.blockOffsetInEnclosingFlowThread());
+        if (LayoutMultiColumnFlowThread* enclosingFlowThread = enclosingFragmentationContext->associatedFlowThread())
+            enclosingFlowThread->appendNewFragmentainerGroupIfNeeded(newRow.blockOffsetInEnclosingFragmentationContext());
     }
 }
 
+bool LayoutMultiColumnFlowThread::isFragmentainerLogicalHeightKnown()
+{
+    return isPageLogicalHeightKnown();
+}
+
+LayoutUnit LayoutMultiColumnFlowThread::fragmentainerLogicalHeightAt(LayoutUnit blockOffset)
+{
+    return pageLogicalHeightForOffset(blockOffset);
+}
+
+LayoutUnit LayoutMultiColumnFlowThread::remainingLogicalHeightAt(LayoutUnit blockOffset)
+{
+    return pageRemainingLogicalHeightForOffset(blockOffset, AssociateWithLatterPage);
+}
+
 void LayoutMultiColumnFlowThread::calculateColumnCountAndWidth(LayoutUnit& width, unsigned& count) const
 {
     LayoutBlock* columnBlock = multiColumnBlockFlow();
     const ComputedStyle* columnStyle = columnBlock->style();
     LayoutUnit availableWidth = columnBlock->contentLogicalWidth();
     LayoutUnit columnGap = columnBlock->columnGap();
     LayoutUnit computedColumnWidth = max<LayoutUnit>(1, LayoutUnit(columnStyle->columnWidth()));
     unsigned computedColumnCount = max<int>(1, columnStyle->columnCount());
 
     ASSERT(!columnStyle->hasAutoColumnCount() || !columnStyle->hasAutoColumnWidth());
@@ skipping 425 matching lines @@
 }
 
 void LayoutMultiColumnFlowThread::contentWasLaidOut(LayoutUnit logicalTopInFlowThreadAfterPagination)
 {
     // Check if we need another fragmentainer group. If we've run out of columns in the last
     // fragmentainer group (column row), we need to insert another fragmentainer group to hold more
     // columns.
 
     // First figure out if there's any chance that we're nested at all. If we can be sure that
     // we're not, bail early. This code is run very often, and since locating a containing flow
-    // thread has some cost (depending on tree depth), avoid calling enclosingFlowThread() right
-    // away. This test may give some false positives (hence the "mayBe"), if we're in an
-    // out-of-flow subtree and have an outer multicol container that doesn't affect us, but that's
-    // okay. We'll discover that further down the road when trying to locate our enclosing flow
-    // thread for real.
-    bool mayBeNested = multiColumnBlockFlow()->isInsideFlowThread();
+    // thread has some cost (depending on tree depth), avoid calling
+    // enclosingFragmentationContext() right away. This test may give some false positives (hence
+    // the "mayBe"), if we're in an out-of-flow subtree and have an outer multicol container that
+    // doesn't affect us, but that's okay. We'll discover that further down the road when trying to
+    // locate our enclosing flow thread for real.
+    bool mayBeNested = multiColumnBlockFlow()->isInsideFlowThread() || view()->fragmentationContext();
     if (!mayBeNested)
         return;
     appendNewFragmentainerGroupIfNeeded(logicalTopInFlowThreadAfterPagination);
 }
 
 }