[New Multicolumn] Create RenderMultiColumnSet during renderer creation, not during layout.

Source/core/rendering/RenderFlowThread.cpp

 /*
  * Copyright (C) 2011 Adobe Systems Incorporated. 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.
@@ skipping 53 matching lines @@
     newStyle->setZIndex(0);
     newStyle->setLeft(Length(0, Fixed));
     newStyle->setTop(Length(0, Fixed));
     newStyle->setWidth(Length(100, Percent));
     newStyle->setHeight(Length(100, Percent));
     newStyle->font().update(nullptr);
 
     return newStyle.release();
 }
 
-void RenderFlowThread::addRegionToThread(RenderRegion* renderRegion)
-{
-    ASSERT(renderRegion);
-    m_regionList.add(renderRegion);
-    renderRegion->setIsValid(true);
-}
-
 void RenderFlowThread::removeRegionFromThread(RenderRegion* renderRegion)
 {
     ASSERT(renderRegion);
     m_regionList.remove(renderRegion);
 }
 
 void RenderFlowThread::invalidateRegions()
 {
     if (m_regionsInvalidated) {
         ASSERT(selfNeedsLayout());
@@ skipping 114 matching lines @@
     // Let each region figure out the proper enclosing flow thread.
     CurrentRenderFlowThreadDisabler disabler(view());
 
     for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
         RenderRegion* region = *iter;
 
         region->repaintFlowThreadContent(repaintRect);
     }
 }
 
-RenderRegion* RenderFlowThread::regionAtBlockOffset(LayoutUnit offset, bool extendLastRegion, RegionAutoGenerationPolicy autoGenerationPolicy)
+RenderRegion* RenderFlowThread::regionAtBlockOffset(LayoutUnit offset)
 {
     ASSERT(!m_regionsInvalidated);
 
-    if (autoGenerationPolicy == AllowRegionAutoGeneration)
-        autoGenerateRegionsToBlockOffset(offset);
-
     if (offset <= 0)
         return m_regionList.isEmpty() ? 0 : m_regionList.first();
 
     RegionSearchAdapter adapter(offset);
     m_regionIntervalTree.allOverlapsWithAdapter<RegionSearchAdapter>(adapter);
 
     // If no region was found, the offset is in the flow thread overflow.
-    // The last region will contain the offset if extendLastRegion is set or if the last region is a set.
     if (!adapter.result() && !m_regionList.isEmpty())
         return m_regionList.last();
 
     return adapter.result();
 }
 
 LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const RenderBoxModelObject& boxModelObject, const LayoutPoint& startPoint)
 {
     LayoutPoint referencePoint = startPoint;
 
@@ skipping 71 matching lines @@
 }
 
 LayoutUnit RenderFlowThread::pageLogicalTopForOffset(LayoutUnit offset)
 {
     RenderRegion* region = regionAtBlockOffset(offset);
     return region ? region->pageLogicalTopForOffset(offset) : LayoutUnit();
 }
 
 LayoutUnit RenderFlowThread::pageLogicalWidthForOffset(LayoutUnit offset)
 {
-    RenderRegion* region = regionAtBlockOffset(offset, true);
+    RenderRegion* region = regionAtBlockOffset(offset);
     return region ? region->pageLogicalWidth() : contentLogicalWidth();
 }
 
 LayoutUnit RenderFlowThread::pageLogicalHeightForOffset(LayoutUnit offset)
 {
     RenderRegion* region = regionAtBlockOffset(offset);
     if (!region)
         return 0;
 
     return region->pageLogicalHeight();
@@ skipping 23 matching lines @@
         return 0;
 
     LayoutRect boxRect = transformState.mappedQuad().enclosingBoundingBox();
     flipForWritingMode(boxRect);
 
     // FIXME: We need to refactor RenderObject::absoluteQuads to be able to split the quads across regions,
     // for now we just take the center of the mapped enclosing box and map it to a region.
     // Note: Using the center in order to avoid rounding errors.
 
     LayoutPoint center = boxRect.center();
-    RenderRegion* renderRegion = const_cast<RenderFlowThread*>(this)->regionAtBlockOffset(isHorizontalWritingMode() ? center.y() : center.x(), true, DisallowRegionAutoGeneration);
+    RenderRegion* renderRegion = const_cast<RenderFlowThread*>(this)->regionAtBlockOffset(isHorizontalWritingMode() ? center.y() : center.x());
     if (!renderRegion)
         return 0;
 
     LayoutRect flippedRegionRect(renderRegion->flowThreadPortionRect());
     flipForWritingMode(flippedRegionRect);
 
     transformState.move(renderRegion->contentBoxRect().location() - flippedRegionRect.location());
 
     return renderRegion;
 }
@@ skipping 11 matching lines @@
         return 0;
     return m_regionList.last();
 }
 
 void RenderFlowThread::setRegionRangeForBox(const RenderBox* box, LayoutUnit offsetFromLogicalTopOfFirstPage)
 {
     if (!hasRegions())
         return;
 
     // FIXME: Not right for differing writing-modes.
-    RenderRegion* startRegion = regionAtBlockOffset(offsetFromLogicalTopOfFirstPage, true);
-    RenderRegion* endRegion = regionAtBlockOffset(offsetFromLogicalTopOfFirstPage + box->logicalHeight(), true);
+    RenderRegion* startRegion = regionAtBlockOffset(offsetFromLogicalTopOfFirstPage);
+    RenderRegion* endRegion = regionAtBlockOffset(offsetFromLogicalTopOfFirstPage + box->logicalHeight());
     RenderRegionRangeMap::iterator it = m_regionRangeMap.find(box);
     if (it == m_regionRangeMap.end()) {
         m_regionRangeMap.set(box, RenderRegionRange(startRegion, endRegion));
         return;
     }
 
     // If nothing changed, just bail.
     RenderRegionRange& range = it->value;
     if (range.startRegion() == startRegion && range.endRegion() == endRegion)
         return;
@@ skipping 209 matching lines @@
 {
     if (!m_renderFlowThread)
         return;
     RenderView* view = m_renderFlowThread->view();
     ASSERT(view->flowThreadController()->currentRenderFlowThread() == m_renderFlowThread);
     view->flowThreadController()->setCurrentRenderFlowThread(m_previousRenderFlowThread);
 }
 
 
 } // namespace WebCore