Changeset 165890 in webkit


Ignore:
Timestamp:
Mar 19, 2014 5:38:51 AM (10 years ago)
Author:
mihnea@adobe.com
Message:

[CSSRegions] Compute region ranges for children of inline blocks
https://bugs.webkit.org/show_bug.cgi?id=130392

Reviewed by Andrei Bucur.

Source/WebCore:

Extend the region ranges computation for children of inline blocks.
When we cannot retrieve the region range for a box using cached information,
either from region range map or from the region cached on the RootInlineBox,
try to find the top most unsplittable box up to the flow thread boundary.
If we find such unsplittable box and the box has a region range, then return
this range.

Before this patch, method getRegionRangeForBox did not return true/false
if it was able to retrieve the range and the caller checked the returned
region values. I modified the method to return true if we were able to compute
the range.

Tests: fast/regions/inline-block-inline-children-flowed-in-regions.html

fast/regions/inline-blocks-dyn-enlarged-regions.html
fast/regions/inline-blocks-dyn-shrunk-regions.html
fast/regions/inline-blocks-in-two-regions.html

  • inspector/InspectorOverlay.cpp:

(WebCore::buildObjectForRendererFragments):

  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::updateRegionRangeForBoxChild):

  • rendering/RenderBlockFlow.cpp:

(WebCore::RenderBlockFlow::hasNextPage):

  • rendering/RenderBox.cpp:

(WebCore::RenderBox::clampToStartAndEndRegions):
(WebCore::RenderBox::borderBoxRectInRegion):
(WebCore::RenderBox::computeRectForRepaint):
(WebCore::RenderBox::layoutOverflowRectForPropagation):

  • rendering/RenderBoxModelObject.cpp:

(WebCore::RenderBoxModelObject::mapAbsoluteToLocalPoint):

  • rendering/RenderFlowThread.cpp:

(WebCore::RenderFlowThread::regionForCompositedLayer):
(WebCore::RenderFlowThread::adjustedPositionRelativeToOffsetParent):
(WebCore::RenderFlowThread::removeRenderBoxRegionInfo):
(WebCore::RenderFlowThread::logicalWidthChangedInRegionsForBlock):
(WebCore::RenderFlowThread::getRegionRangeForBoxFromCachedInfo):
(WebCore::RenderFlowThread::getRegionRangeForBox):
(WebCore::RenderFlowThread::objectShouldPaintInFlowRegion):
(WebCore::RenderFlowThread::objectInFlowRegion):
(WebCore::RenderFlowThread::addRegionsVisualEffectOverflow):
(WebCore::RenderFlowThread::addRegionsVisualOverflowFromTheme):
(WebCore::RenderFlowThread::addRegionsOverflowFromChild):
(WebCore::RenderFlowThread::addRegionsLayoutOverflow):
(WebCore::RenderFlowThread::addRegionsVisualOverflow):
(WebCore::RenderFlowThread::clearRegionsOverflow):

  • rendering/RenderFlowThread.h:
  • rendering/RenderNamedFlowThread.cpp:

(WebCore::RenderNamedFlowThread::fragmentFromAbsolutePointAndBox):

  • rendering/RenderObject.cpp:

(WebCore::RenderObject::locateFlowThreadContainingBlock):
Make sure we return the right render flow thread in the case of
region-based multicolumn inside named flows.

  • rendering/RenderRegion.cpp:

(WebCore::RenderRegion::rectFlowPortionForBox):

LayoutTests:

  • fast/regions/inline-block-inline-children-flowed-in-regions-expected.html: Added.
  • fast/regions/inline-block-inline-children-flowed-in-regions.html: Added.
  • fast/regions/inline-blocks-dyn-enlarged-regions-expected.html: Added.
  • fast/regions/inline-blocks-dyn-enlarged-regions.html: Added.
  • fast/regions/inline-blocks-dyn-shrunk-regions-expected.html: Added.
  • fast/regions/inline-blocks-dyn-shrunk-regions.html: Added.
  • fast/regions/inline-blocks-in-two-regions-expected.html: Added.
  • fast/regions/inline-blocks-in-two-regions.html: Added.
Location:
trunk
Files:
8 added
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r165889 r165890  
     12014-03-19  Mihnea Ovidenie  <mihnea@adobe.com>
     2
     3        [CSSRegions] Compute region ranges for children of inline blocks
     4        https://bugs.webkit.org/show_bug.cgi?id=130392
     5
     6        Reviewed by Andrei Bucur.
     7
     8        * fast/regions/inline-block-inline-children-flowed-in-regions-expected.html: Added.
     9        * fast/regions/inline-block-inline-children-flowed-in-regions.html: Added.
     10        * fast/regions/inline-blocks-dyn-enlarged-regions-expected.html: Added.
     11        * fast/regions/inline-blocks-dyn-enlarged-regions.html: Added.
     12        * fast/regions/inline-blocks-dyn-shrunk-regions-expected.html: Added.
     13        * fast/regions/inline-blocks-dyn-shrunk-regions.html: Added.
     14        * fast/regions/inline-blocks-in-two-regions-expected.html: Added.
     15        * fast/regions/inline-blocks-in-two-regions.html: Added.
     16
    1172014-03-19  Frédéric Wang  <fred.wang@free.fr>
    218
  • trunk/Source/WebCore/ChangeLog

    r165882 r165890  
     12014-03-19  Mihnea Ovidenie  <mihnea@adobe.com>
     2
     3        [CSSRegions] Compute region ranges for children of inline blocks
     4        https://bugs.webkit.org/show_bug.cgi?id=130392
     5
     6        Reviewed by Andrei Bucur.
     7
     8        Extend the region ranges computation for children of inline blocks.
     9        When we cannot retrieve the region range for a box using cached information,
     10        either from region range map or from the region cached on the RootInlineBox,
     11        try to find the top most unsplittable box up to the flow thread boundary.
     12        If we find such unsplittable box and the box has a region range, then return
     13        this range.
     14
     15        Before this patch, method getRegionRangeForBox did not return true/false
     16        if it was able to retrieve the range and the caller checked the returned
     17        region values. I modified the method to return true if we were able to compute
     18        the range.
     19
     20        Tests: fast/regions/inline-block-inline-children-flowed-in-regions.html
     21               fast/regions/inline-blocks-dyn-enlarged-regions.html
     22               fast/regions/inline-blocks-dyn-shrunk-regions.html
     23               fast/regions/inline-blocks-in-two-regions.html
     24
     25        * inspector/InspectorOverlay.cpp:
     26        (WebCore::buildObjectForRendererFragments):
     27        * rendering/RenderBlock.cpp:
     28        (WebCore::RenderBlock::updateRegionRangeForBoxChild):
     29        * rendering/RenderBlockFlow.cpp:
     30        (WebCore::RenderBlockFlow::hasNextPage):
     31        * rendering/RenderBox.cpp:
     32        (WebCore::RenderBox::clampToStartAndEndRegions):
     33        (WebCore::RenderBox::borderBoxRectInRegion):
     34        (WebCore::RenderBox::computeRectForRepaint):
     35        (WebCore::RenderBox::layoutOverflowRectForPropagation):
     36        * rendering/RenderBoxModelObject.cpp:
     37        (WebCore::RenderBoxModelObject::mapAbsoluteToLocalPoint):
     38        * rendering/RenderFlowThread.cpp:
     39        (WebCore::RenderFlowThread::regionForCompositedLayer):
     40        (WebCore::RenderFlowThread::adjustedPositionRelativeToOffsetParent):
     41        (WebCore::RenderFlowThread::removeRenderBoxRegionInfo):
     42        (WebCore::RenderFlowThread::logicalWidthChangedInRegionsForBlock):
     43        (WebCore::RenderFlowThread::getRegionRangeForBoxFromCachedInfo):
     44        (WebCore::RenderFlowThread::getRegionRangeForBox):
     45        (WebCore::RenderFlowThread::objectShouldPaintInFlowRegion):
     46        (WebCore::RenderFlowThread::objectInFlowRegion):
     47        (WebCore::RenderFlowThread::addRegionsVisualEffectOverflow):
     48        (WebCore::RenderFlowThread::addRegionsVisualOverflowFromTheme):
     49        (WebCore::RenderFlowThread::addRegionsOverflowFromChild):
     50        (WebCore::RenderFlowThread::addRegionsLayoutOverflow):
     51        (WebCore::RenderFlowThread::addRegionsVisualOverflow):
     52        (WebCore::RenderFlowThread::clearRegionsOverflow):
     53        * rendering/RenderFlowThread.h:
     54        * rendering/RenderNamedFlowThread.cpp:
     55        (WebCore::RenderNamedFlowThread::fragmentFromAbsolutePointAndBox):
     56        * rendering/RenderObject.cpp:
     57        (WebCore::RenderObject::locateFlowThreadContainingBlock):
     58        Make sure we return the right render flow thread in the case of
     59        region-based multicolumn inside named flows.
     60        * rendering/RenderRegion.cpp:
     61        (WebCore::RenderRegion::rectFlowPortionForBox):
     62
    1632014-03-19  Krzysztof Wolanski  <k.wolanski@samsung.com>
    264
  • trunk/Source/WebCore/inspector/InspectorOverlay.cpp

    r165676 r165890  
    517517        RenderRegion* startRegion = nullptr;
    518518        RenderRegion* endRegion = nullptr;
    519         containingFlowThread->getRegionRangeForBox(enclosingBox, startRegion, endRegion);
    520         if (!startRegion) {
     519        if (!containingFlowThread->getRegionRangeForBox(enclosingBox, startRegion, endRegion)) {
    521520            // The flow has no visible regions. The renderer is not visible on screen.
    522521            return nullptr;
    523522        }
     523
    524524        const RenderRegionList& regionList = containingFlowThread->renderRegionList();
    525525        for (RenderRegionList::const_iterator iter = regionList.find(startRegion); iter != regionList.end(); ++iter) {
  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r165873 r165890  
    51125112        return false;
    51135113
    5114     RenderRegion* startRegion = 0;
    5115     RenderRegion* endRegion = 0;
     5114    RenderRegion* startRegion = nullptr;
     5115    RenderRegion* endRegion = nullptr;
    51165116    flowThread->getRegionRangeForBox(&box, startRegion, endRegion);
    51175117
    51185118    computeRegionRangeForBoxChild(box);
    51195119
    5120     RenderRegion* newStartRegion = 0;
    5121     RenderRegion* newEndRegion = 0;
     5120    RenderRegion* newStartRegion = nullptr;
     5121    RenderRegion* newEndRegion = nullptr;
    51225122    flowThread->getRegionRangeForBox(&box, newStartRegion, newEndRegion);
    51235123
  • trunk/Source/WebCore/rendering/RenderBlockFlow.cpp

    r165873 r165890  
    16751675    if (!region)
    16761676        return false;
     1677
    16771678    if (region->isLastRegion())
    16781679        return region->isRenderRegionSet() || region->style().regionFragment() == BreakRegionFragment
    16791680            || (pageBoundaryRule == IncludePageBoundary && pageOffset == region->logicalTopForFlowThreadContent());
    16801681
    1681     RenderRegion* startRegion = 0;
    1682     RenderRegion* endRegion = 0;
     1682    RenderRegion* startRegion = nullptr;
     1683    RenderRegion* endRegion = nullptr;
    16831684    flowThread->getRegionRangeForBox(this, startRegion, endRegion);
    1684 
    1685     if (region == endRegion)
    1686         return false;
    1687     return true;
     1685    return region != endRegion;
    16881686}
    16891687
  • trunk/Source/WebCore/rendering/RenderBox.cpp

    r165599 r165890  
    132132    // last regions extended infinitely. Otherwise the lines are going to size according to the regions
    133133    // they overflow into, which makes no sense when this block doesn't exist in |region| at all.
    134     RenderRegion* startRegion = 0;
    135     RenderRegion* endRegion = 0;
    136     flowThread->getRegionRangeForBox(this, startRegion, endRegion);
    137 
    138     if (startRegion && region->logicalTopForFlowThreadContent() < startRegion->logicalTopForFlowThreadContent())
     134    RenderRegion* startRegion = nullptr;
     135    RenderRegion* endRegion = nullptr;
     136    if (!flowThread->getRegionRangeForBox(this, startRegion, endRegion))
     137        return region;
     138
     139    if (region->logicalTopForFlowThreadContent() < startRegion->logicalTopForFlowThreadContent())
    139140        return startRegion;
    140     if (endRegion && region->logicalTopForFlowThreadContent() > endRegion->logicalTopForFlowThreadContent())
     141    if (region->logicalTopForFlowThreadContent() > endRegion->logicalTopForFlowThreadContent())
    141142        return endRegion;
    142143
     
    165166        return borderBoxRect();
    166167
    167     RenderRegion* startRegion = 0;
    168     RenderRegion* endRegion = 0;
    169     flowThread->getRegionRangeForBox(this, startRegion, endRegion);
    170    
    171     // FIXME: In a perfect world this condition should never happen.
    172     if (!startRegion || !endRegion)
     168    RenderRegion* startRegion = nullptr;
     169    RenderRegion* endRegion = nullptr;
     170    if (!flowThread->getRegionRangeForBox(this, startRegion, endRegion)) {
     171        // FIXME: In a perfect world this condition should never happen.
    173172        return borderBoxRect();
    174 
     173    }
     174   
    175175    ASSERT(flowThread->regionInRange(region, startRegion, endRegion));
    176176
     
    21042104
    21052105    if (o->isRenderFlowThread()) {
    2106         RenderRegion* firstRegion = 0;
    2107         RenderRegion* lastRegion = 0;
    2108         toRenderFlowThread(o)->getRegionRangeForBox(this, firstRegion, lastRegion);
    2109         if (firstRegion)
     2106        RenderRegion* firstRegion = nullptr;
     2107        RenderRegion* lastRegion = nullptr;
     2108        if (toRenderFlowThread(o)->getRegionRangeForBox(this, firstRegion, lastRegion))
    21102109            rect.moveBy(firstRegion->flowThreadPortionRect().location());
    21112110    }
     
    45374536    if (namedFlowFragment) {
    45384537        if (RenderFlowThread* flowThread = namedFlowFragment->flowThread()) {
    4539             RenderRegion* startRegion = 0;
    4540             RenderRegion* endRegion = 0;
    4541             flowThread->getRegionRangeForBox(this, startRegion, endRegion);
    4542 
    4543             if (startRegion && endRegion)
     4538            RenderRegion* startRegion = nullptr;
     4539            RenderRegion* endRegion = nullptr;
     4540            if (flowThread->getRegionRangeForBox(this, startRegion, endRegion))
    45444541                overflowRect.unite(namedFlowFragment->visualOverflowRectForBox(this));
    45454542        }
  • trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp

    r165699 r165890  
    26332633    // not the FlowThread that is its container in the RenderObject tree.
    26342634    if (o->isRenderFlowThread() && isBox()) {
    2635         RenderRegion* startRegion;
    2636         RenderRegion* endRegion;
    2637         toRenderFlowThread(o)->getRegionRangeForBox(toRenderBox(this), startRegion, endRegion);
    2638         if (startRegion)
     2635        RenderRegion* startRegion = nullptr;
     2636        RenderRegion* endRegion = nullptr;
     2637        if (toRenderFlowThread(o)->getRegionRangeForBox(toRenderBox(this), startRegion, endRegion))
    26392638            o = startRegion;
    26402639    }
  • trunk/Source/WebCore/rendering/RenderFlowThread.cpp

    r165377 r165890  
    239239bool RenderFlowThread::hasCompositingRegionDescendant() const
    240240{
    241     for (auto& region : m_regionList)
     241    for (auto& region : m_regionList) {
    242242        if (toRenderNamedFlowFragment(region)->layerOwner().layer()->hasCompositingDescendant())
    243243            return true;
     244    }
    244245
    245246    return false;
     
    259260
    260261    if (childLayer.renderBox()) {
    261         RenderRegion* startRegion = 0;
    262         RenderRegion* endRegion = 0;
    263         getRegionRangeForBox(childLayer.renderBox(), startRegion, endRegion);
    264         // The video tag is such a box that doesn't have a region range because it's inline (by default).
    265         if (startRegion)
     262        RenderRegion* startRegion = nullptr;
     263        RenderRegion* endRegion = nullptr;
     264        if (getRegionRangeForBox(childLayer.renderBox(), startRegion, endRegion))
    266265            return toRenderNamedFlowFragment(startRegion);
    267266    }
     
    315314    RegionToLayerListMap regionToLayerListMap;
    316315
    317     RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList()};
    318     for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex)
    319         if (RenderLayerList* list = lists[listIndex])
     316    RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList() };
     317    for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex) {
     318        if (RenderLayerList* list = lists[listIndex]) {
    320319            for (size_t i = 0, listSize = list->size(); i < listSize; ++i)
    321320                updateLayerToRegionMappings(*list->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
     321        }
     322    }
    322323
    323324    if (needsLayerUpdate) {
     
    466467        while (objContainingBlock && !objContainingBlock->isRenderNamedFlowThread()) {
    467468            // Check if this object is in a different region.
    468             RenderRegion* parentStartRegion = 0;
    469             RenderRegion* parentEndRegion = 0;
    470             getRegionRangeForBox(objContainingBlock, parentStartRegion, parentEndRegion);
    471             if (parentStartRegion && parentStartRegion != startRegion) {
     469            RenderRegion* parentStartRegion = nullptr;
     470            RenderRegion* parentEndRegion = nullptr;
     471            if (getRegionRangeForBox(objContainingBlock, parentStartRegion, parentEndRegion) && parentStartRegion != startRegion) {
    472472                wasComputedRelativeToOtherRegion = true;
    473473                break;
     
    594594    }
    595595
    596     RenderRegion* startRegion;
    597     RenderRegion* endRegion;
     596    RenderRegion* startRegion = nullptr;
     597    RenderRegion* endRegion = nullptr;
    598598    getRegionRangeForBox(box, startRegion, endRegion);
    599599
     
    631631        return;
    632632
    633     RenderRegion* startRegion;
    634     RenderRegion* endRegion;
    635     getRegionRangeForBox(block, startRegion, endRegion);
    636 
    637633    // Not necessary for the flow thread, since we already computed the correct info for it.
    638634    // If the regions have changed invalidate the children.
     
    641637        return;
    642638    }
     639
     640    RenderRegion* startRegion = nullptr;
     641    RenderRegion* endRegion = nullptr;
     642    getRegionRangeForBox(block, startRegion, endRegion);
    643643
    644644    for (auto& region : m_regionList) {
     
    750750}
    751751
    752 void RenderFlowThread::getRegionRangeForBox(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
    753 {
    754     startRegion = endRegion = 0;
     752bool RenderFlowThread::getRegionRangeForBoxFromCachedInfo(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
     753{
     754    ASSERT(box);
     755    ASSERT(hasValidRegionInfo());
     756    ASSERT((startRegion == nullptr) && (endRegion == nullptr));
     757
    755758    auto it = m_regionRangeMap.find(box);
    756 
    757759    if (it != m_regionRangeMap.end()) {
    758760        const RenderRegionRange& range = it->value;
     
    760762        endRegion = range.endRegion();
    761763        ASSERT(m_regionList.contains(startRegion) && m_regionList.contains(endRegion));
    762         return;
     764        return true;
    763765    }
    764766
    765767    InlineElementBox* boxWrapper = box->inlineBoxWrapper();
    766     if (boxWrapper) {
    767         const RootInlineBox& boxWrapperRootInlineBox =  boxWrapper->root();
    768         startRegion = endRegion = boxWrapperRootInlineBox.containingRegion();
    769         return;
    770     }
     768    if (boxWrapper && boxWrapper->root().containingRegion()) {
     769        startRegion = endRegion = boxWrapper->root().containingRegion();
     770        ASSERT(m_regionList.contains(startRegion) && m_regionList.contains(endRegion));
     771        return true;
     772    }
     773
     774    return false;
     775}
     776
     777bool RenderFlowThread::getRegionRangeForBox(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
     778{
     779    ASSERT(box);
     780
     781    startRegion = endRegion = nullptr;
     782    if (!hasValidRegionInfo()) // We clear the ranges when we invalidate the regions.
     783        return false;
     784
     785    if (getRegionRangeForBoxFromCachedInfo(box, startRegion, endRegion))
     786        return true;
     787
     788    // Check if the box is contained in an unsplittable box.
     789    // If the unsplittable box has region range, then the start and end region for the box
     790    // should be equal with the region for the unsplittable box if any.
     791    RenderBox* topMostUnsplittable = nullptr;
     792    RenderBox* cb = const_cast<RenderBox*>(box);
     793    do {
     794        if (cb->isUnsplittableForPagination())
     795            topMostUnsplittable = cb;
     796        cb = cb->parent()->enclosingBox();
     797    } while (!cb->isRenderFlowThread());
     798
     799    if (topMostUnsplittable) {
     800        if (getRegionRangeForBoxFromCachedInfo(topMostUnsplittable, startRegion, endRegion)) {
     801            endRegion = startRegion;
     802            return true;
     803        }
     804    }
     805
     806    return false;
    771807}
    772808
     
    801837    if (flowThread != this)
    802838        return false;
     839
    803840    if (!m_regionList.contains(const_cast<RenderRegion*>(region)))
    804841        return false;
    805842   
    806843    RenderBox* enclosingBox = object->enclosingBox();
    807     RenderRegion* enclosingBoxStartRegion = 0;
    808     RenderRegion* enclosingBoxEndRegion = 0;
    809     getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion);
    810    
     844    RenderRegion* enclosingBoxStartRegion = nullptr;
     845    RenderRegion* enclosingBoxEndRegion = nullptr;
    811846    // If the box has no range, do not check regionInRange. Boxes inside inlines do not get ranges.
    812847    // Instead, the containing RootInlineBox will abort when trying to paint inside the wrong region.
    813     if (enclosingBoxStartRegion && enclosingBoxEndRegion && !regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))
     848    if (getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion)
     849        && !regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))
    814850        return false;
    815851   
     
    825861    if (flowThread != this)
    826862        return false;
     863
    827864    if (!m_regionList.contains(const_cast<RenderRegion*>(region)))
    828865        return false;
    829866
    830867    RenderBox* enclosingBox = object->enclosingBox();
    831     RenderRegion* enclosingBoxStartRegion = 0;
    832     RenderRegion* enclosingBoxEndRegion = 0;
    833     getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion);
     868    RenderRegion* enclosingBoxStartRegion = nullptr;
     869    RenderRegion* enclosingBoxEndRegion = nullptr;
     870    if (!getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion))
     871        return false;
     872
    834873    if (!regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))
    835874        return false;
     
    884923        return;
    885924
    886     for (auto regionIter = startRegion ? m_regionList.find(startRegion) : m_regionList.begin(),
    887         end = m_regionList.end(); regionIter != end; ++regionIter) {
     925    for (auto regionIter = startRegion ? m_regionList.find(startRegion) : m_regionList.begin(), end = m_regionList.end(); regionIter != end; ++regionIter) {
    888926        RenderRegion* region = *regionIter;
    889927        if (region->hasAutoLogicalHeight()) {
     
    11801218        return;
    11811219
    1182     if (RenderRegion* region = mapFromFlowToRegion(transformState))
     1220    if (RenderRegion* region = mapFromFlowToRegion(transformState)) {
    11831221        // FIXME: The cast below is probably not the best solution, we may need to find a better way.
    11841222        static_cast<const RenderObject*>(region)->mapLocalToContainer(region->containerForRepaint(), transformState, mode, wasFixed);
     1223    }
    11851224}
    11861225
     
    12421281void RenderFlowThread::addRegionsVisualEffectOverflow(const RenderBox* box)
    12431282{
    1244     RenderRegion* startRegion = 0;
    1245     RenderRegion* endRegion = 0;
    1246     getRegionRangeForBox(box, startRegion, endRegion);
     1283    RenderRegion* startRegion = nullptr;
     1284    RenderRegion* endRegion = nullptr;
     1285    if (!getRegionRangeForBox(box, startRegion, endRegion))
     1286        return;
    12471287
    12481288    for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
     
    12611301void RenderFlowThread::addRegionsVisualOverflowFromTheme(const RenderBlock* block)
    12621302{
    1263     RenderRegion* startRegion = 0;
    1264     RenderRegion* endRegion = 0;
    1265     getRegionRangeForBox(block, startRegion, endRegion);
     1303    RenderRegion* startRegion = nullptr;
     1304    RenderRegion* endRegion = nullptr;
     1305    if (!getRegionRangeForBox(block, startRegion, endRegion))
     1306        return;
    12661307
    12671308    for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
     
    12821323void RenderFlowThread::addRegionsOverflowFromChild(const RenderBox* box, const RenderBox* child, const LayoutSize& delta)
    12831324{
    1284     RenderRegion* startRegion = 0;
    1285     RenderRegion* endRegion = 0;
    1286     getRegionRangeForBox(child, startRegion, endRegion);
    1287 
    1288     RenderRegion* containerStartRegion = 0;
    1289     RenderRegion* containerEndRegion = 0;
    1290     getRegionRangeForBox(box, containerStartRegion, containerEndRegion);
     1325    RenderRegion* startRegion = nullptr;
     1326    RenderRegion* endRegion = nullptr;
     1327    if (!getRegionRangeForBox(child, startRegion, endRegion))
     1328        return;
     1329
     1330    RenderRegion* containerStartRegion = nullptr;
     1331    RenderRegion* containerEndRegion = nullptr;
     1332    if (!getRegionRangeForBox(box, containerStartRegion, containerEndRegion))
     1333        return;
    12911334
    12921335    for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
     
    13181361void RenderFlowThread::addRegionsLayoutOverflow(const RenderBox* box, const LayoutRect& layoutOverflow)
    13191362{
    1320     RenderRegion* startRegion = 0;
    1321     RenderRegion* endRegion = 0;
    1322     getRegionRangeForBox(box, startRegion, endRegion);
     1363    RenderRegion* startRegion = nullptr;
     1364    RenderRegion* endRegion = nullptr;
     1365    if (!getRegionRangeForBox(box, startRegion, endRegion))
     1366        return;
    13231367
    13241368    for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
     
    13351379void RenderFlowThread::addRegionsVisualOverflow(const RenderBox* box, const LayoutRect& visualOverflow)
    13361380{
    1337     RenderRegion* startRegion = 0;
    1338     RenderRegion* endRegion = 0;
    1339     getRegionRangeForBox(box, startRegion, endRegion);
     1381    RenderRegion* startRegion = nullptr;
     1382    RenderRegion* endRegion = nullptr;
     1383    if (!getRegionRangeForBox(box, startRegion, endRegion))
     1384        return;
    13401385   
    13411386    for (RenderRegionList::iterator iter = m_regionList.find(startRegion); iter != m_regionList.end(); ++iter) {
     
    13521397void RenderFlowThread::clearRegionsOverflow(const RenderBox* box)
    13531398{
    1354     RenderRegion* startRegion = 0;
    1355     RenderRegion* endRegion = 0;
    1356     getRegionRangeForBox(box, startRegion, endRegion);
     1399    RenderRegion* startRegion = nullptr;
     1400    RenderRegion* endRegion = nullptr;
     1401    if (!getRegionRangeForBox(box, startRegion, endRegion))
     1402        return;
    13571403
    13581404    for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
  • trunk/Source/WebCore/rendering/RenderFlowThread.h

    r165720 r165890  
    124124
    125125    void setRegionRangeForBox(const RenderBox*, RenderRegion*, RenderRegion*);
    126     void getRegionRangeForBox(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const;
     126    bool getRegionRangeForBox(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const;
    127127    bool hasRegionRangeForBox(const RenderBox* box) const { ASSERT(box); return m_regionRangeMap.contains(box); }
    128128
     
    246246    inline const RenderBox* currentActiveRenderBox() const;
    247247
     248    bool getRegionRangeForBoxFromCachedInfo(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const;
     249
    248250    RenderRegionList m_regionList;
    249251    unsigned short m_previousRegionCount;
  • trunk/Source/WebCore/rendering/RenderNamedFlowFragment.cpp

    r165542 r165890  
    284284        }
    285285
    286         if ((oldRegionRect.width() != pageLogicalWidth() || oldRegionRect.height() != pageLogicalHeight()) && !m_flowThread->inFinalLayoutPhase())
     286        if ((oldRegionRect.width() != pageLogicalWidth() || oldRegionRect.height() != pageLogicalHeight()) && !m_flowThread->inFinalLayoutPhase()) {
    287287            // This can happen even if we are in the inConstrainedLayoutPhase and it will trigger a pathological layout of the flow thread.
    288288            m_flowThread->invalidateRegions();
     289        }
    289290    }
    290291}
  • trunk/Source/WebCore/rendering/RenderNamedFlowThread.cpp

    r165676 r165890  
    370370    RenderRegion* startRegion = nullptr;
    371371    RenderRegion* endRegion = nullptr;
    372     getRegionRangeForBox(&flowedBox, startRegion, endRegion);
    373    
    374     if (!startRegion)
     372    if (!getRegionRangeForBox(&flowedBox, startRegion, endRegion))
    375373        return nullptr;
    376374   
  • trunk/Source/WebCore/rendering/RenderObject.cpp

    r165736 r165890  
    527527    // See if we have the thread cached because we're in the middle of layout.
    528528    RenderFlowThread* flowThread = view().flowThreadController().currentRenderFlowThread();
    529     if (flowThread)
     529    if (flowThread && (flowThreadState() == flowThread->flowThreadState()))
    530530        return flowThread;
    531531   
  • trunk/Source/WebCore/rendering/RenderRegion.cpp

    r165615 r165890  
    474474    LayoutRect mappedRect = m_flowThread->mapFromLocalToFlowThread(box, rect);
    475475
    476     RenderRegion* startRegion = 0;
    477     RenderRegion* endRegion = 0;
    478     m_flowThread->getRegionRangeForBox(box, startRegion, endRegion);
    479 
    480     if (startRegion && endRegion) {
     476    RenderRegion* startRegion = nullptr;
     477    RenderRegion* endRegion = nullptr;
     478    if (m_flowThread->getRegionRangeForBox(box, startRegion, endRegion)) {
    481479        if (flowThread()->isHorizontalWritingMode()) {
    482480            if (this != startRegion)
Note: See TracChangeset for help on using the changeset viewer.