Source/core/rendering/RenderFlowThread.cpp - Issue 134473008: Remove CSS regions support, keeping a bare minimum to support "region-based" multicol.

Unified Diff: Source/core/rendering/RenderFlowThread.cpp

Issue 134473008: Remove CSS regions support, keeping a bare minimum to support "region-based" multicol. (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master

Patch Set: Rebase master Created 6 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: Source/core/rendering/RenderFlowThread.cpp

diff --git a/Source/core/rendering/RenderFlowThread.cpp b/Source/core/rendering/RenderFlowThread.cpp

index 8bd2ada476a163c9b66751ef643f5eb377543740..a42e8b64901413ab7980467f13287970554b219f 100644

--- a/Source/core/rendering/RenderFlowThread.cpp

+++ b/Source/core/rendering/RenderFlowThread.cpp

@@ -37,7 +37,6 @@

#include "core/rendering/HitTestResult.h"

#include "core/rendering/LayoutRectRecorder.h"

#include "core/rendering/PaintInfo.h"

-#include "core/rendering/RenderBoxRegionInfo.h"

#include "core/rendering/RenderInline.h"

#include "core/rendering/RenderLayer.h"

#include "core/rendering/RenderRegion.h"

@@ -50,16 +49,9 @@ namespace WebCore {

RenderFlowThread::RenderFlowThread()

: RenderBlockFlow(0)

, m_previousRegionCount(0)

- , m_autoLogicalHeightRegionsCount(0)

, m_regionsInvalidated(false)

- , m_regionsHaveUniformLogicalWidth(true)

, m_regionsHaveUniformLogicalHeight(true)

- , m_hasRegionsWithStyling(false)

- , m_dispatchRegionLayoutUpdateEvent(false)

- , m_dispatchRegionOversetChangeEvent(false)

, m_pageLogicalSizeChanged(false)

- , m_inConstrainedLayoutPhase(false)

- , m_needsTwoPhasesLayout(false)

{

setFlowThreadState(InsideOutOfFlowThread);

}

@@ -80,21 +72,6 @@ PassRefPtr<RenderStyle> RenderFlowThread::createFlowThreadStyle(RenderStyle* par

return newStyle.release();

}

-void RenderFlowThread::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)

- RenderBlock::styleDidChange(diff, oldStyle);

- if (oldStyle && oldStyle->writingMode() != style()->writingMode())

- invalidateRegions();

-void RenderFlowThread::removeFlowChildInfo(RenderObject* child)

- if (child->isBox())

- removeRenderBoxRegionInfo(toRenderBox(child));

- clearRenderObjectCustomStyle(child);

void RenderFlowThread::addRegionToThread(RenderRegion* renderRegion)

{

ASSERT(renderRegion);

@@ -116,8 +93,6 @@ void RenderFlowThread::invalidateRegions()

}

m_regionRangeMap.clear();

- m_breakBeforeToRegionMap.clear();

- m_breakAfterToRegionMap.clear();

setNeedsLayout();

m_regionsInvalidated = true;

@@ -148,7 +123,6 @@ void RenderFlowThread::validateRegions()

{

if (m_regionsInvalidated) {

m_regionsInvalidated = false;

- m_regionsHaveUniformLogicalWidth = true;

m_regionsHaveUniformLogicalHeight = true;

if (hasRegions()) {

@@ -158,27 +132,12 @@ void RenderFlowThread::validateRegions()

for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

RenderRegion* region = *iter;

- ASSERT(!region->needsLayout() || region->isRenderRegionSet());

- region->deleteAllRenderBoxRegionInfo();

- // In the normal layout phase we need to initialize the computedAutoHeight for auto-height regions.

- // See initializeRegionsComputedAutoHeight for the explanation.

- // Also, if we have auto-height regions we can't assume m_regionsHaveUniformLogicalHeight to be true in the first phase

- // because the auto-height regions don't have their height computed yet.

- if (!inConstrainedLayoutPhase() && region->hasAutoLogicalHeight()) {

- region->setComputedAutoHeight(region->maxPageLogicalHeight());

- m_regionsHaveUniformLogicalHeight = false;

- }

LayoutUnit regionLogicalWidth = region->pageLogicalWidth();

LayoutUnit regionLogicalHeight = region->pageLogicalHeight();

if (!firstRegionVisited) {

firstRegionVisited = true;

} else {

- if (m_regionsHaveUniformLogicalWidth && previousRegionLogicalWidth != regionLogicalWidth)

- m_regionsHaveUniformLogicalWidth = false;

if (m_regionsHaveUniformLogicalHeight && previousRegionLogicalHeight != regionLogicalHeight)

m_regionsHaveUniformLogicalHeight = false;

}

@@ -197,17 +156,8 @@ void RenderFlowThread::layout()

LayoutRectRecorder recorder(*this);

m_pageLogicalSizeChanged = m_regionsInvalidated && everHadLayout();

- // In case this is the second pass of the normal phase we need to update the auto-height regions to their initial value.

- // If the region chain was invalidated this will happen anyway.

- if (!m_regionsInvalidated && !inConstrainedLayoutPhase())

- initializeRegionsComputedAutoHeight();

validateRegions();

- // This is the first phase of the layout and because we have auto-height regions we'll need a second

- // pass to update the flow with the computed auto-height regions.

- m_needsTwoPhasesLayout = !inConstrainedLayoutPhase() && hasAutoLogicalHeightRegions();

CurrentRenderFlowThreadMaintainer currentFlowThreadSetter(this);

RenderBlockFlow::layout();

@@ -215,33 +165,11 @@ void RenderFlowThread::layout()

if (lastRegion())

lastRegion()->expandToEncompassFlowThreadContentsIfNeeded();

- if (shouldDispatchRegionLayoutUpdateEvent())

- dispatchRegionLayoutUpdateEvent();

- if (shouldDispatchRegionOversetChangeEvent())

- dispatchRegionOversetChangeEvent();

}

void RenderFlowThread::updateLogicalWidth()

{

- LayoutUnit logicalWidth = initialLogicalWidth();

- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

- RenderRegion* region = *iter;

- ASSERT(!region->needsLayout() || region->isRenderRegionSet());

- logicalWidth = max(region->pageLogicalWidth(), logicalWidth);

- }

- setLogicalWidth(logicalWidth);

- // If the regions have non-uniform logical widths, then insert inset information for the RenderFlowThread.

- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

- RenderRegion* region = *iter;

- LayoutUnit regionLogicalWidth = region->pageLogicalWidth();

- if (regionLogicalWidth != logicalWidth) {

- LayoutUnit logicalLeft = style()->direction() == LTR ? LayoutUnit() : logicalWidth - regionLogicalWidth;

- region->setRenderBoxRegionInfo(this, logicalLeft, regionLogicalWidth, false);

- }

+ setLogicalWidth(initialLogicalWidth());

}

void RenderFlowThread::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const

@@ -251,8 +179,6 @@ void RenderFlowThread::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop, L

for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

RenderRegion* region = *iter;

- ASSERT(!region->needsLayout() || region->isRenderRegionSet());

computedValues.m_extent += region->logicalHeightOfAllFlowThreadContent();

}

@@ -265,56 +191,6 @@ LayoutRect RenderFlowThread::computeRegionClippingRect(const LayoutPoint& offset

return regionClippingRect;

}

-void RenderFlowThread::paintFlowThreadPortionInRegion(PaintInfo& paintInfo, RenderRegion* region, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const LayoutPoint& paintOffset) const

- GraphicsContext* context = paintInfo.context;

- if (!context)

- return;

- // RenderFlowThread should start painting its content in a position that is offset

- // from the region rect's current position. The amount of offset is equal to the location of

- // the flow thread portion in the flow thread's local coordinates.

- // Note that we have to pixel snap the location at which we're going to paint, since this is necessary

- // to minimize the amount of incorrect snapping that would otherwise occur.

- // If we tried to paint by applying a non-integral translation, then all the

- // layout code that attempted to pixel snap would be incorrect.

- IntPoint adjustedPaintOffset;

- LayoutPoint portionLocation;

- if (style()->isFlippedBlocksWritingMode()) {

- LayoutRect flippedFlowThreadPortionRect(flowThreadPortionRect);

- flipForWritingMode(flippedFlowThreadPortionRect);

- portionLocation = flippedFlowThreadPortionRect.location();

- } else {

- portionLocation = flowThreadPortionRect.location();

- }

- adjustedPaintOffset = roundedIntPoint(paintOffset - portionLocation);

- // The clipping rect for the region is set up by assuming the flowThreadPortionRect is going to paint offset from adjustedPaintOffset.

- // Remember that we pixel snapped and moved the paintOffset and stored the snapped result in adjustedPaintOffset. Now we add back in

- // the flowThreadPortionRect's location to get the spot where we expect the portion to actually paint. This can be non-integral and

- // that's ok. We then pixel snap the resulting clipping rect to account for snapping that will occur when the flow thread paints.

- IntRect regionClippingRect = pixelSnappedIntRect(computeRegionClippingRect(adjustedPaintOffset + portionLocation, flowThreadPortionRect, flowThreadPortionOverflowRect));

- PaintInfo info(paintInfo);

- info.rect.intersect(regionClippingRect);

- if (!info.rect.isEmpty()) {

- context->save();

- context->clip(regionClippingRect);

- context->translate(adjustedPaintOffset.x(), adjustedPaintOffset.y());

- info.rect.moveBy(-adjustedPaintOffset);

- if (info.phase == PaintPhaseTextClip)

- info.paintBehavior = PaintBehaviorForceBlackText;

- layer()->paint(context, info.rect, info.paintBehavior, 0, region, PaintLayerTemporaryClipRects);

- context->restore();

- }

bool RenderFlowThread::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)

{

if (hitTestAction == HitTestBlockBackground)

@@ -322,35 +198,6 @@ bool RenderFlowThread::nodeAtPoint(const HitTestRequest& request, HitTestResult&

return RenderBlockFlow::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);

}

-bool RenderFlowThread::hitTestFlowThreadPortionInRegion(RenderRegion* region, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset) const

- LayoutRect regionClippingRect = computeRegionClippingRect(accumulatedOffset, flowThreadPortionRect, flowThreadPortionOverflowRect);

- if (!regionClippingRect.contains(locationInContainer.point()))

- return false;

- LayoutSize renderFlowThreadOffset;

- if (style()->isFlippedBlocksWritingMode()) {

- LayoutRect flippedFlowThreadPortionRect(flowThreadPortionRect);

- flipForWritingMode(flippedFlowThreadPortionRect);

- renderFlowThreadOffset = accumulatedOffset - flippedFlowThreadPortionRect.location();

- } else {

- renderFlowThreadOffset = accumulatedOffset - flowThreadPortionRect.location();

- }

- // Always ignore clipping, since the RenderFlowThread has nothing to do with the bounds of the FrameView.

- HitTestRequest newRequest(request.type() | HitTestRequest::IgnoreClipping | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent);

- // Make a new temporary HitTestLocation in the new region.

- HitTestLocation newHitTestLocation(locationInContainer, -renderFlowThreadOffset, region);

- bool isPointInsideFlowThread = layer()->hitTest(newRequest, newHitTestLocation, result);

- // FIXME: Should we set result.m_localPoint back to the RenderRegion's coordinate space or leave it in the RenderFlowThread's coordinate

- // space? Right now it's staying in the RenderFlowThread's coordinate space, which may end up being ok. We will know more when we get around to

- // patching positionForPoint.

- return isPointInsideFlowThread;

bool RenderFlowThread::shouldRepaint(const LayoutRect& r) const

{

if (view()->document().printing() || r.isEmpty())

@@ -392,7 +239,7 @@ RenderRegion* RenderFlowThread::regionAtBlockOffset(LayoutUnit offset, bool exte

// 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() && (extendLastRegion || m_regionList.last()->isRenderRegionSet()))

+ if (!adapter.result() && !m_regionList.isEmpty())

return m_regionList.last();

return adapter.result();

@@ -430,9 +277,8 @@ LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const Rende

// FIXME: This needs to be adapted for different writing modes inside the flow thread.

RenderRegion* startRegion = regionAtBlockOffset(referencePoint.y());

if (startRegion) {

- RenderBoxModelObject* startRegionBox = startRegion->isRenderNamedFlowFragment() ? toRenderBoxModelObject(startRegion->parent()) : startRegion;

// Take into account the offset coordinates of the region.

- RenderObject* currObject = startRegionBox;

+ RenderObject* currObject = startRegion;

RenderObject* currOffsetParentRenderer;

Element* currOffsetParentElement;

while ((currOffsetParentElement = currObject->offsetParent()) && (currOffsetParentRenderer = currOffsetParentElement->renderer())) {

@@ -452,7 +298,7 @@ LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const Rende

// and is no longer valid) and recompute it using the region in which it flows as reference.

bool wasComputedRelativeToOtherRegion = false;

const RenderBlock* objContainingBlock = boxModelObject.containingBlock();

- while (objContainingBlock && !objContainingBlock->isRenderNamedFlowThread()) {

+ while (objContainingBlock) {

// Check if this object is in a different region.

RenderRegion* parentStartRegion = 0;

RenderRegion* parentEndRegion = 0;

@@ -465,12 +311,6 @@ LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const Rende

}

if (wasComputedRelativeToOtherRegion) {

- if (boxModelObject.isBox()) {

- // Use borderBoxRectInRegion to account for variations such as percentage margins.

- LayoutRect borderBoxRect = toRenderBox(&boxModelObject)->borderBoxRectInRegion(startRegion, RenderBox::DoNotCacheRenderBoxRegionInfo);

- referencePoint.move(borderBoxRect.location().x(), 0);

- }

// Get the logical top coordinate of the current object.

LayoutUnit top = 0;

if (boxModelObject.isRenderBlock()) {

@@ -489,7 +329,7 @@ LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const Rende

// and compute the object's top, relative to the region's top.

LayoutUnit regionLogicalTop = startRegion->pageLogicalTopForOffset(top);

LayoutUnit topRelativeToRegion = top - regionLogicalTop;

- referencePoint.setY(startRegionBox->offsetTop() + topRelativeToRegion);

+ referencePoint.setY(startRegion->offsetTop() + topRelativeToRegion);

// Since the top has been overriden, check if the

// relative/sticky positioning must be reconsidered.

@@ -501,7 +341,7 @@ LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const Rende

// Since we're looking for the offset relative to the body, we must also

// take into consideration the borders of the region.

- referencePoint.move(startRegionBox->borderLeft(), startRegionBox->borderTop());

+ referencePoint.move(startRegion->borderLeft(), startRegion->borderTop());

}

return referencePoint;

@@ -571,100 +411,6 @@ RenderRegion* RenderFlowThread::mapFromFlowToRegion(TransformState& transformSta

return renderRegion;

}

-void RenderFlowThread::removeRenderBoxRegionInfo(RenderBox* box)

- if (!hasRegions())

- return;

- // If the region chain was invalidated the next layout will clear the box information from all the regions.

- if (m_regionsInvalidated) {

- ASSERT(selfNeedsLayout());

- return;

- }

- RenderRegion* startRegion;

- RenderRegion* endRegion;

- getRegionRangeForBox(box, startRegion, endRegion);

- for (RenderRegionList::iterator iter = m_regionList.find(startRegion); iter != m_regionList.end(); ++iter) {

- RenderRegion* region = *iter;

- region->removeRenderBoxRegionInfo(box);

- if (region == endRegion)

- break;

- }

-#ifndef NDEBUG

- // We have to make sure we did not leave any RenderBoxRegionInfo attached.

- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

- RenderRegion* region = *iter;

- ASSERT(!region->renderBoxRegionInfo(box));

- }

-#endif

- m_regionRangeMap.remove(box);

-bool RenderFlowThread::logicalWidthChangedInRegionsForBlock(const RenderBlock* block)

- if (!hasRegions())

- return false;

- RenderRegion* startRegion;

- RenderRegion* endRegion;

- getRegionRangeForBox(block, startRegion, endRegion);

- // When the region chain is invalidated the box information is discarded so we must assume the width has changed.

- if (m_pageLogicalSizeChanged && !startRegion)

- return true;

- // Not necessary for the flow thread, since we already computed the correct info for it.

- if (block == this)

- return false;

- for (RenderRegionList::iterator iter = m_regionList.find(startRegion); iter != m_regionList.end(); ++iter) {

- RenderRegion* region = *iter;

- ASSERT(!region->needsLayout() || region->isRenderRegionSet());

- OwnPtr<RenderBoxRegionInfo> oldInfo = region->takeRenderBoxRegionInfo(block);

- if (!oldInfo)

- continue;

- LayoutUnit oldLogicalWidth = oldInfo->logicalWidth();

- RenderBoxRegionInfo* newInfo = block->renderBoxRegionInfo(region);

- if (!newInfo || newInfo->logicalWidth() != oldLogicalWidth)

- return true;

- if (region == endRegion)

- break;

- }

- return false;

-LayoutUnit RenderFlowThread::contentLogicalWidthOfFirstRegion() const

- RenderRegion* firstValidRegionInFlow = firstRegion();

- if (!firstValidRegionInFlow)

- return 0;

- return isHorizontalWritingMode() ? firstValidRegionInFlow->contentWidth() : firstValidRegionInFlow->contentHeight();

-LayoutUnit RenderFlowThread::contentLogicalHeightOfFirstRegion() const

- RenderRegion* firstValidRegionInFlow = firstRegion();

- if (!firstValidRegionInFlow)

- return 0;

- return isHorizontalWritingMode() ? firstValidRegionInFlow->contentHeight() : firstValidRegionInFlow->contentWidth();

-LayoutUnit RenderFlowThread::contentLogicalLeftOfFirstRegion() const

- RenderRegion* firstValidRegionInFlow = firstRegion();

- if (!firstValidRegionInFlow)

- return 0;

- return isHorizontalWritingMode() ? firstValidRegionInFlow->flowThreadPortionRect().x() : firstValidRegionInFlow->flowThreadPortionRect().y();

RenderRegion* RenderFlowThread::firstRegion() const

{

if (!hasValidRegionInfo())

@@ -679,32 +425,6 @@ RenderRegion* RenderFlowThread::lastRegion() const

return m_regionList.last();

}

-void RenderFlowThread::clearRenderObjectCustomStyle(const RenderObject* object,

- const RenderRegion* oldStartRegion, const RenderRegion* oldEndRegion,

- const RenderRegion* newStartRegion, const RenderRegion* newEndRegion)

- // Clear the styles for the object in the regions.

- // The styles are not cleared for the regions that are contained in both ranges.

- bool insideOldRegionRange = false;

- bool insideNewRegionRange = false;

- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

- RenderRegion* region = *iter;

- if (oldStartRegion == region)

- insideOldRegionRange = true;

- if (newStartRegion == region)

- insideNewRegionRange = true;

- if (!(insideOldRegionRange && insideNewRegionRange))

- region->clearObjectStyleInRegion(object);

- if (oldEndRegion == region)

- insideOldRegionRange = false;

- if (newEndRegion == region)

- insideNewRegionRange = false;

- }

void RenderFlowThread::setRegionRangeForBox(const RenderBox* box, LayoutUnit offsetFromLogicalTopOfFirstPage)

{

if (!hasRegions())

@@ -716,7 +436,6 @@ void RenderFlowThread::setRegionRangeForBox(const RenderBox* box, LayoutUnit off

RenderRegionRangeMap::iterator it = m_regionRangeMap.find(box);

if (it == m_regionRangeMap.end()) {

m_regionRangeMap.set(box, RenderRegionRange(startRegion, endRegion));

- clearRenderObjectCustomStyle(box);

return;

}

@@ -725,21 +444,6 @@ void RenderFlowThread::setRegionRangeForBox(const RenderBox* box, LayoutUnit off

if (range.startRegion() == startRegion && range.endRegion() == endRegion)

return;

- // Delete any info that we find before our new startRegion and after our new endRegion.

- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

- RenderRegion* region = *iter;

- if (region == startRegion) {

- iter = m_regionList.find(endRegion);

- continue;

- }

- region->removeRenderBoxRegionInfo(box);

- if (region == range.endRegion())

- break;

- }

- clearRenderObjectCustomStyle(box, range.startRegion(), range.endRegion(), startRegion, endRegion);

range.setRange(startRegion, endRegion);

}

@@ -779,126 +483,15 @@ bool RenderFlowThread::regionInRange(const RenderRegion* targetRegion, const Ren

return false;

}

-// Check if the content is flown into at least a region with region styling rules.

-void RenderFlowThread::checkRegionsWithStyling()

- bool hasRegionsWithStyling = false;

- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

- RenderRegion* region = *iter;

- if (region->hasCustomRegionStyle()) {

- hasRegionsWithStyling = true;

- break;

- }

- m_hasRegionsWithStyling = hasRegionsWithStyling;

-bool RenderFlowThread::objectInFlowRegion(const RenderObject* object, const RenderRegion* region) const

- ASSERT(object);

- ASSERT(region);

- RenderFlowThread* flowThread = object->flowThreadContainingBlock();

- if (flowThread != this)

- return false;

- if (!m_regionList.contains(const_cast<RenderRegion*>(region)))

- return false;

- RenderBox* enclosingBox = object->enclosingBox();

- RenderRegion* enclosingBoxStartRegion = 0;

- RenderRegion* enclosingBoxEndRegion = 0;

- getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion);

- if (!regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))

- return false;

- if (object->isBox())

- return true;

- LayoutRect objectABBRect = object->absoluteBoundingBoxRect(true);

- if (!objectABBRect.width())

- objectABBRect.setWidth(1);

- if (!objectABBRect.height())

- objectABBRect.setHeight(1);

- if (objectABBRect.intersects(region->absoluteBoundingBoxRect(true)))

- return true;

- if (region == lastRegion()) {

- // If the object does not intersect any of the enclosing box regions

- // then the object is in last region.

- for (RenderRegionList::const_iterator it = m_regionList.find(enclosingBoxStartRegion); it != m_regionList.end(); ++it) {

- const RenderRegion* currRegion = *it;

- if (currRegion == region)

- break;

- if (objectABBRect.intersects(currRegion->absoluteBoundingBoxRect(true)))

- return false;

- }

- return true;

- }

- return false;

-#ifndef NDEBUG

-bool RenderFlowThread::isAutoLogicalHeightRegionsCountConsistent() const

- unsigned autoLogicalHeightRegions = 0;

- for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

- const RenderRegion* region = *iter;

- if (region->hasAutoLogicalHeight())

- autoLogicalHeightRegions++;

- }

- return autoLogicalHeightRegions == m_autoLogicalHeightRegionsCount;

-#endif

-// During the normal layout phase of the named flow the regions are initialized with a height equal to their max-height.

-// This way unforced breaks are automatically placed when a region is full and the content height/position correctly estimated.

-// Also, the region where a forced break falls is exactly the region found at the forced break offset inside the flow content.

-void RenderFlowThread::initializeRegionsComputedAutoHeight(RenderRegion* startRegion)

+void RenderFlowThread::updateRegionsFlowThreadPortionRect()

{

- ASSERT(!inConstrainedLayoutPhase());

- if (!hasAutoLogicalHeightRegions())

- return;

- RenderRegionList::iterator regionIter = startRegion ? m_regionList.find(startRegion) : m_regionList.begin();

- for (; regionIter != m_regionList.end(); ++regionIter) {

- RenderRegion* region = *regionIter;

- if (region->hasAutoLogicalHeight())

- region->setComputedAutoHeight(region->maxPageLogicalHeight());

- }

-void RenderFlowThread::markAutoLogicalHeightRegionsForLayout()

- ASSERT(hasAutoLogicalHeightRegions());

- for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

- RenderRegion* region = *iter;

- if (!region->hasAutoLogicalHeight())

- continue;

- // FIXME: We need to find a way to avoid marking all the regions ancestors for layout

- // as we are already inside layout.

- region->setNeedsLayout();

- }

-void RenderFlowThread::updateRegionsFlowThreadPortionRect(const RenderRegion* lastRegionWithContent)

- ASSERT(!lastRegionWithContent || (!inConstrainedLayoutPhase() && hasAutoLogicalHeightRegions()));

LayoutUnit logicalHeight = 0;

- bool emptyRegionsSegment = false;

// FIXME: Optimize not to clear the interval all the time. This implies manually managing the tree nodes lifecycle.

m_regionIntervalTree.clear();

m_regionIntervalTree.initIfNeeded();

for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {

RenderRegion* region = *iter;

- // If we find an empty auto-height region, clear the computedAutoHeight value.

- if (emptyRegionsSegment && region->hasAutoLogicalHeight())

- region->clearComputedAutoHeight();

LayoutUnit regionLogicalWidth = region->pageLogicalWidth();

LayoutUnit regionLogicalHeight = std::min<LayoutUnit>(RenderFlowThread::maxLogicalHeight() - logicalHeight, region->logicalHeightOfAllFlowThreadContent());

@@ -909,104 +502,7 @@ void RenderFlowThread::updateRegionsFlowThreadPortionRect(const RenderRegion* la

m_regionIntervalTree.add(RegionIntervalTree::createInterval(logicalHeight, logicalHeight + regionLogicalHeight, region));

logicalHeight += regionLogicalHeight;

- // Once we find the last region with content the next regions are considered empty.

- if (lastRegionWithContent == region)

- emptyRegionsSegment = true;

}

- ASSERT(!lastRegionWithContent || emptyRegionsSegment);

-// Even if we require the break to occur at offsetBreakInFlowThread, because regions may have min/max-height values,

-// it is possible that the break will occur at a different offset than the original one required.

-// offsetBreakAdjustment measures the different between the requested break offset and the current break offset.

-bool RenderFlowThread::addForcedRegionBreak(LayoutUnit offsetBreakInFlowThread, RenderObject* breakChild, bool isBefore, LayoutUnit* offsetBreakAdjustment)

- // We take breaks into account for height computation for auto logical height regions

- // only in the layout phase in which we lay out the flows threads unconstrained

- // and we use the content breaks to determine the computedAutoHeight for

- // auto logical height regions.

- if (inConstrainedLayoutPhase())

- return false;

- // Breaks can come before or after some objects. We need to track these objects, so that if we get

- // multiple breaks for the same object (for example because of multiple layouts on the same object),

- // we need to invalidate every other region after the old one and start computing from fresh.

- RenderObjectToRegionMap& mapToUse = isBefore ? m_breakBeforeToRegionMap : m_breakAfterToRegionMap;

- RenderObjectToRegionMap::iterator iter = mapToUse.find(breakChild);

- if (iter != mapToUse.end()) {

- RenderRegionList::iterator regionIter = m_regionList.find(iter->value);

- ASSERT_WITH_SECURITY_IMPLICATION(regionIter != m_regionList.end());

- ASSERT((*regionIter)->hasAutoLogicalHeight());

- initializeRegionsComputedAutoHeight(*regionIter);

- // We need to update the regions flow thread portion rect because we are going to process

- // a break on these regions.

- updateRegionsFlowThreadPortionRect();

- }

- // Simulate a region break at offsetBreakInFlowThread. If it points inside an auto logical height region,

- // then it determines the region computed auto height.

- RenderRegion* region = regionAtBlockOffset(offsetBreakInFlowThread);

- if (!region)

- return false;

- bool lastBreakAfterContent = breakChild == this;

- bool hasComputedAutoHeight = false;

- LayoutUnit currentRegionOffsetInFlowThread = isHorizontalWritingMode() ? region->flowThreadPortionRect().y() : region->flowThreadPortionRect().x();

- LayoutUnit offsetBreakInCurrentRegion = offsetBreakInFlowThread - currentRegionOffsetInFlowThread;

- if (region->hasAutoLogicalHeight()) {

- // A forced break can appear only in an auto-height region that didn't have a forced break before.

- // This ASSERT is a good-enough heuristic to verify the above condition.

- ASSERT(region->maxPageLogicalHeight() == region->computedAutoHeight());

- mapToUse.set(breakChild, region);

- hasComputedAutoHeight = true;

- // Compute the region height pretending that the offsetBreakInCurrentRegion is the logicalHeight for the auto-height region.

- LayoutUnit regionComputedAutoHeight = region->constrainContentBoxLogicalHeightByMinMax(offsetBreakInCurrentRegion, -1);

- // The new height of this region needs to be smaller than the initial value, the max height. A forced break is the only way to change the initial

- // height of an auto-height region besides content ending.

- ASSERT(regionComputedAutoHeight <= region->maxPageLogicalHeight());

- region->setComputedAutoHeight(regionComputedAutoHeight);

- currentRegionOffsetInFlowThread += regionComputedAutoHeight;

- } else {

- currentRegionOffsetInFlowThread += isHorizontalWritingMode() ? region->flowThreadPortionRect().height() : region->flowThreadPortionRect().width();

- }

- // If the break was found inside an auto-height region its size changed so we need to recompute the flow thread portion rectangles.

- // Also, if this is the last break after the content we need to clear the computedAutoHeight value on the last empty regions.

- if (hasAutoLogicalHeightRegions() && lastBreakAfterContent)

- updateRegionsFlowThreadPortionRect(region);

- else if (hasComputedAutoHeight)

- updateRegionsFlowThreadPortionRect();

- if (offsetBreakAdjustment)

- *offsetBreakAdjustment = max<LayoutUnit>(0, currentRegionOffsetInFlowThread - offsetBreakInFlowThread);

- return hasComputedAutoHeight;

-void RenderFlowThread::incrementAutoLogicalHeightRegions()

- if (!m_autoLogicalHeightRegionsCount)

- view()->flowThreadController()->incrementFlowThreadsWithAutoLogicalHeightRegions();

- ++m_autoLogicalHeightRegionsCount;

-void RenderFlowThread::decrementAutoLogicalHeightRegions()

- ASSERT(m_autoLogicalHeightRegionsCount > 0);

- --m_autoLogicalHeightRegionsCount;

- if (!m_autoLogicalHeightRegionsCount)

- view()->flowThreadController()->decrementFlowThreadsWithAutoLogicalHeightRegions();

}

void RenderFlowThread::collectLayerFragments(LayerFragments& layerFragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect)

@@ -1167,7 +663,6 @@ CurrentRenderFlowThreadMaintainer::CurrentRenderFlowThreadMaintainer(RenderFlowT

return;

RenderView* view = m_renderFlowThread->view();

m_previousRenderFlowThread = view->flowThreadController()->currentRenderFlowThread();

- ASSERT(!m_previousRenderFlowThread || !renderFlowThread->isRenderNamedFlowThread());

view->flowThreadController()->setCurrentRenderFlowThread(m_renderFlowThread);

}

« no previous file with comments | « Source/core/rendering/RenderFlowThread.h ('k') | Source/core/rendering/RenderGrid.cpp » ('j') | no next file with comments »