Changeset 164988 in webkit


Ignore:
Timestamp:
Mar 3, 2014 9:16:06 AM (10 years ago)
Author:
abucur@adobe.com
Message:

[CSS Regions] Overset computation is incorrect in some cases
​https://bugs.webkit.org/show_bug.cgi?id=129032

Reviewed by Mihnea Ovidenie.

Source/WebCore:

This patch reworks the way overset is computed for regions and named flows.

  1. Regions overflow no longer trigger an overset changed event. This is because

the overflow of a box is contained within the region range of the box. The content
edge should be considered the logical bottom position of the content inside the
flow thread.

  1. The regions events logic was moved from RenderFlowThread to RenderNamedFlowThread

and from RenderRegion to RenderNamedFlowFragment (including the regionOverset property).

  1. The overset value of the named flow is no longer stored in the named flow. It is

extracted from the overset of the last region in the chain.

  1. The regions overset is not computed every time the flow thread is laid out which

should improve performance for flows with many regions. With the patch, each region
computes the overset value during its layout when the flow thread is in the overflow
or the final layout phase.

  1. The overset changed event is dispatched only at the end of the layout of the named flows,

after all the region overset changes have been considered. This means that the overset
event can't be dispatched in the middle of the auto-height processing algorithm that
requires multiple layout passes for the flow threads.

However, the region layout update event dispatch timing was not changed, it is dispatched
every time the flow thread has a layout. This preserves the current behavior of the event.

Tests: The old tests were modified to take into account the change.

  • dom/Element.cpp:

(WebCore::Element::webkitRegionOverset):

  • dom/WebKitNamedFlow.cpp:

(WebCore::WebKitNamedFlow::overset):

  • inspector/InspectorCSSAgent.cpp:

(WebCore::InspectorCSSAgent::buildArrayForRegions):

  • rendering/FlowThreadController.cpp:

(WebCore::FlowThreadController::updateFlowThreadsIntoMeasureContentPhase):

  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::computeOverflow):

  • rendering/RenderFlowThread.cpp:

(WebCore::RenderFlowThread::RenderFlowThread):
(WebCore::RenderFlowThread::layout):

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

(WebCore::RenderNamedFlowFragment::layoutBlock):
(WebCore::RenderNamedFlowFragment::setRegionOversetState):
(WebCore::RenderNamedFlowFragment::regionOversetState):
(WebCore::RenderNamedFlowFragment::updateOversetState):

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

(WebCore::RenderNamedFlowThread::RenderNamedFlowThread):
(WebCore::RenderNamedFlowThread::computeOverflow):
(WebCore::RenderNamedFlowThread::layout):
(WebCore::RenderNamedFlowThread::dispatchNamedFlowEvents):
(WebCore::RenderNamedFlowThread::dispatchRegionLayoutUpdateEventIfNeeded):
(WebCore::RenderNamedFlowThread::dispatchRegionOversetChangeEventIfNeeded):

  • rendering/RenderNamedFlowThread.h:

There's a new field called m_flowContentBottom that tracks the content bottom of the flow thread
after layout. This value is used to compute the overset value of the regions because it's not
affected by relative positioning or visual overflow such as shadows.

  • rendering/RenderRegion.cpp:
  • rendering/RenderRegion.h:

LayoutTests:

Adjust the tests to cope with the overset changes.

  • fast/regions/cssom/element-region-overset-state-expected.txt:
  • fast/regions/cssom/element-region-overset-state-vertical-rl-expected.txt:
  • fast/regions/cssom/element-region-overset-state-vertical-rl.html:
  • fast/regions/cssom/element-region-overset-state.html:

This test has a new case that verifies region clamping is correctly taken into account.

  • fast/regions/cssom/webkit-named-flow-overset-expected.txt:
  • fast/regions/cssom/webkit-named-flow-overset.html:
Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r164967 r164988  
     12014-03-03  Andrei Bucur  <abucur@adobe.com>
     2
     3        [CSS Regions] Overset computation is incorrect in some cases
     4        https://bugs.webkit.org/show_bug.cgi?id=129032
     5
     6        Reviewed by Mihnea Ovidenie.
     7
     8        Adjust the tests to cope with the overset changes.
     9
     10        * fast/regions/cssom/element-region-overset-state-expected.txt:
     11        * fast/regions/cssom/element-region-overset-state-vertical-rl-expected.txt:
     12        * fast/regions/cssom/element-region-overset-state-vertical-rl.html:
     13        * fast/regions/cssom/element-region-overset-state.html:
     14        This test has a new case that verifies region clamping is correctly taken into account.
     15        * fast/regions/cssom/webkit-named-flow-overset-expected.txt:
     16        * fast/regions/cssom/webkit-named-flow-overset.html:
     17
    1182014-03-02  Timothy Hatcher  <timothy@apple.com>
    219

  • trunk/LayoutTests/fast/regions/cssom/element-region-overset-state-expected.txt

    r158668 r164988  
    1111PASS regionOverset('region_2') is "fit"
    1212PASS regionOverset('region_3') is "empty"
     13Generate layout overflow
     14PASS regionOverset('region_1') is "fit"
     15PASS regionOverset('region_2') is "fit"
     16PASS regionOverset('region_3') is "empty"
    1317Add more content
    1418PASS regionOverset('region_1') is "fit"
    … …  
    1822PASS regionOverset('region_1') is "fit"
    1923PASS regionOverset('region_2') is "fit"
    20 PASS regionOverset('region_3') is "overset"
     24PASS regionOverset('region_3') is "fit"
    2125Empty content
    2226PASS regionOverset('region_1') is "empty"

  • trunk/LayoutTests/fast/regions/cssom/element-region-overset-state-vertical-rl-expected.txt

    r158668 r164988  
    1818PASS regionOverset('region_1') is "fit"
    1919PASS regionOverset('region_2') is "fit"
    20 PASS regionOverset('region_3') is "overset"
     20PASS regionOverset('region_3') is "fit"
    2121Empty content
    2222PASS regionOverset('region_1') is "empty"

  • trunk/LayoutTests/fast/regions/cssom/element-region-overset-state-vertical-rl.html

    r158668 r164988  
    9393        shouldBeEqualToString("regionOverset('region_1')", "fit");
    9494        shouldBeEqualToString("regionOverset('region_2')", "fit");
    95         shouldBeEqualToString("regionOverset('region_3')", "overset");
     95        shouldBeEqualToString("regionOverset('region_3')", "fit");
    9696
    9797        debug("Empty content");

  • trunk/LayoutTests/fast/regions/cssom/element-region-overset-state.html

    r158668 r164988  
    5959    function addMoreContent() {
    6060        var c = document.getElementById("content");
     61        c.style.marginTop = 0;
    6162        c.style.height = 326;
     63        var a = document.getElementById("article");
     64        a.style.height = "auto";
     65    }
     66
     67    function generateLayoutOverflow() {
     68        var c = document.getElementById("content");
     69        c.style.marginTop = 400;
     70        c.style.height = 400;
     71        var a = document.getElementById("article");
     72        a.style.height = 150;
    6273    }
    6374
    … …  
    7081        flowContent("article");
    7182
     83        shouldBeEqualToString("regionOverset('region_1')", "fit");
     84        shouldBeEqualToString("regionOverset('region_2')", "fit");
     85        shouldBeEqualToString("regionOverset('region_3')", "empty");
     86
     87        debug("Generate layout overflow");
     88        generateLayoutOverflow();
    7289        shouldBeEqualToString("regionOverset('region_1')", "fit");
    7390        shouldBeEqualToString("regionOverset('region_2')", "fit");
    … …  
    86103        shouldBeEqualToString("regionOverset('region_1')", "fit");
    87104        shouldBeEqualToString("regionOverset('region_2')", "fit");
    88         shouldBeEqualToString("regionOverset('region_3')", "overset");
     105        shouldBeEqualToString("regionOverset('region_3')", "fit");
    89106
    90107        debug("Empty content");

  • trunk/LayoutTests/fast/regions/cssom/webkit-named-flow-overset-expected.txt

    r158668 r164988  
    88PASS namedFlow.overset is true
    99PASS namedFlow.overset is false
    10 PASS namedFlow.overset is true
    1110PASS namedFlow.overset is false
    12 PASS namedFlow.overset is true
     11PASS namedFlow.overset is false
     12PASS namedFlow.overset is false
    1313PASS namedFlow.overset is false
    1414PASS namedFlow.overset is true

  • trunk/LayoutTests/fast/regions/cssom/webkit-named-flow-overset.html

    r158668 r164988  
    6060    document.getElementById("article").style.webkitBoxShadow="0px 50px lime";
    6161
    62     // Overset should be true since the content does not fit in regions
    63     shouldBe("namedFlow.overset", "true");
     62    // Overset should be false even if the content shadow overflows the last region
     63    // since the visual overflow does not influence the overset property.
     64    shouldBe("namedFlow.overset", "false");
    6465
    6566    // Add the third region, overset should be false.
    … …  
    7576    region.className = "";
    7677
    77     // Overset should be true since the content does not fit the regions
    78     shouldBe("namedFlow.overset", "true");
     78    // Overset should be false even if the content shadow overflows the last region
     79    // since the visual overflow does not influence the overset property.
     80    shouldBe("namedFlow.overset", "false");
    7981
    8082    // Remove the content from the flow, overset should be false.

  • trunk/Source/WebCore/ChangeLog

    r164987 r164988  
     12014-03-03  Andrei Bucur  <abucur@adobe.com>
     2
     3        [CSS Regions] Overset computation is incorrect in some cases
     4        https://bugs.webkit.org/show_bug.cgi?id=129032
     5
     6        Reviewed by Mihnea Ovidenie.
     7
     8        This patch reworks the way overset is computed for regions and named flows.
     9
     10        1. Regions overflow no longer trigger an overset changed event. This is because
     11        the overflow of a box is contained within the region range of the box. The content
     12        edge should be considered the logical bottom position of the content inside the
     13        flow thread.
     14
     15        2. The regions events logic was moved from RenderFlowThread to RenderNamedFlowThread
     16        and from RenderRegion to RenderNamedFlowFragment (including the regionOverset property).
     17
     18        3. The overset value of the named flow is no longer stored in the named flow. It is
     19        extracted from the overset of the last region in the chain.
     20
     21        4. The regions overset is not computed every time the flow thread is laid out which
     22        should improve performance for flows with many regions. With the patch, each region
     23        computes the overset value during its layout when the flow thread is in the overflow
     24        or the final layout phase.
     25
     26        5. The overset changed event is dispatched only at the end of the layout of the named flows,
     27        after all the region overset changes have been considered. This means that the overset
     28        event can't be dispatched in the middle of the auto-height processing algorithm that
     29        requires multiple layout passes for the flow threads.
     30
     31        However, the region layout update event dispatch timing was not changed, it is dispatched
     32        every time the flow thread has a layout. This preserves the current behavior of the event.
     33
     34        Tests: The old tests were modified to take into account the change.
     35
     36        * dom/Element.cpp:
     37        (WebCore::Element::webkitRegionOverset):
     38        * dom/WebKitNamedFlow.cpp:
     39        (WebCore::WebKitNamedFlow::overset):
     40        * inspector/InspectorCSSAgent.cpp:
     41        (WebCore::InspectorCSSAgent::buildArrayForRegions):
     42        * rendering/FlowThreadController.cpp:
     43        (WebCore::FlowThreadController::updateFlowThreadsIntoMeasureContentPhase):
     44        * rendering/RenderBlock.cpp:
     45        (WebCore::RenderBlock::computeOverflow):
     46        * rendering/RenderFlowThread.cpp:
     47        (WebCore::RenderFlowThread::RenderFlowThread):
     48        (WebCore::RenderFlowThread::layout):
     49        * rendering/RenderFlowThread.h:
     50        * rendering/RenderNamedFlowFragment.cpp:
     51        (WebCore::RenderNamedFlowFragment::layoutBlock):
     52        (WebCore::RenderNamedFlowFragment::setRegionOversetState):
     53        (WebCore::RenderNamedFlowFragment::regionOversetState):
     54        (WebCore::RenderNamedFlowFragment::updateOversetState):
     55        * rendering/RenderNamedFlowFragment.h:
     56        * rendering/RenderNamedFlowThread.cpp:
     57        (WebCore::RenderNamedFlowThread::RenderNamedFlowThread):
     58        (WebCore::RenderNamedFlowThread::computeOverflow):
     59        (WebCore::RenderNamedFlowThread::layout):
     60        (WebCore::RenderNamedFlowThread::dispatchNamedFlowEvents):
     61        (WebCore::RenderNamedFlowThread::dispatchRegionLayoutUpdateEventIfNeeded):
     62        (WebCore::RenderNamedFlowThread::dispatchRegionOversetChangeEventIfNeeded):
     63        * rendering/RenderNamedFlowThread.h:
     64        There's a new field called m_flowContentBottom that tracks the content bottom of the flow thread
     65        after layout. This value is used to compute the overset value of the regions because it's not
     66        affected by relative positioning or visual overflow such as shadows.
     67        * rendering/RenderRegion.cpp:
     68        * rendering/RenderRegion.h:
     69
    1702014-03-03  Tomas Popela  <tpopela@redhat.com>
    271

  • trunk/Source/WebCore/dom/Element.cpp

    r164964 r164988  
    25712571        return undefinedState;
    25722572
    2573     switch (renderNamedFlowFragment()->regionOversetState()) {
     2573    switch (regionOversetState()) {
    25742574    case RegionFit: {
    25752575        DEFINE_STATIC_LOCAL(AtomicString, fitState, ("fit", AtomicString::ConstructFromLiteral));

  • trunk/Source/WebCore/dom/WebKitNamedFlow.cpp

    r162602 r164988  
    7070    // The renderer may be destroyed or created after the style update.
    7171    // Because this is called from JS, where the wrapper keeps a reference to the NamedFlow, no guard is necessary.
    72     return m_parentFlowThread ? m_parentFlowThread->overset() : true;
     72    if (!m_parentFlowThread || !m_parentFlowThread->hasRegions())
     73        return true;
     74
     75    const RenderNamedFlowFragment* namedFlowFragment = toRenderNamedFlowFragment(m_parentFlowThread->lastRegion());
     76    return namedFlowFragment->regionOversetState() == RegionOverset;
    7377}
    7478

  • trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp

    r164482 r164988  
    11971197        Inspector::TypeBuilder::CSS::Region::RegionOverset::Enum regionOverset;
    11981198
    1199         switch (toElement(regionList->item(i))->renderNamedFlowFragment()->regionOversetState()) {
     1199        switch (toElement(regionList->item(i))->regionOversetState()) {
    12001200        case RegionFit:
    12011201            regionOverset = Inspector::TypeBuilder::CSS::Region::RegionOverset::Fit;

  • trunk/Source/WebCore/rendering/FlowThreadController.cpp

    r164699 r164988  
    247247        ASSERT(flowRenderer->inFinalLayoutPhase());
    248248
     249        flowRenderer->dispatchNamedFlowEvents();
    249250        flowRenderer->setLayoutPhase(RenderFlowThread::LayoutPhaseMeasureContent);
    250251    }

  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r164837 r164988  
    15911591    // Add visual overflow from theme.
    15921592    addVisualOverflowFromTheme();
    1593 
    1594     if (isRenderNamedFlowThread())
    1595         toRenderNamedFlowThread(this)->computeOversetStateForRegions(oldClientAfterEdge);
    15961593}
    15971594

  • trunk/Source/WebCore/rendering/RenderFlowThread.cpp

    r164858 r164988  
    5959    , m_regionsHaveUniformLogicalWidth(true)
    6060    , m_regionsHaveUniformLogicalHeight(true)
    61     , m_dispatchRegionLayoutUpdateEvent(false)
    62     , m_dispatchRegionOversetChangeEvent(false)
    6361    , m_pageLogicalSizeChanged(false)
    6462    , m_layoutPhase(LayoutPhaseMeasureContent)
    … …  
    237235            layer()->compositor().setCompositingLayersNeedRebuild();
    238236    }
    239 
    240     if (shouldDispatchRegionLayoutUpdateEvent())
    241         dispatchRegionLayoutUpdateEvent();
    242    
    243     if (shouldDispatchRegionOversetChangeEvent())
    244         dispatchRegionOversetChangeEvent();
    245237}
    246238

  • trunk/Source/WebCore/rendering/RenderFlowThread.h

    r164858 r164988  
    210210private:
    211211    virtual bool isRenderFlowThread() const override final { return true; }
    212     virtual void layout() override final;
    213212
    214213    // Always create a RenderLayer for the RenderFlowThread so that we
    … …  
    220219
    221220    virtual const char* renderName() const = 0;
     221    virtual void layout() override;
    222222
    223223    // Overridden by columns/pages to set up an initial logical width of the page width even when
    … …  
    235235    void updateLayerToRegionMappings(RenderLayer&, LayerToRegionMap&, RegionToLayerListMap&, bool& needsLayerUpdate);
    236236    void updateRegionForRenderLayer(RenderLayer*, LayerToRegionMap&, RegionToLayerListMap&, bool& needsLayerUpdate);
    237 
    238     void setDispatchRegionLayoutUpdateEvent(bool value) { m_dispatchRegionLayoutUpdateEvent = value; }
    239     bool shouldDispatchRegionLayoutUpdateEvent() { return m_dispatchRegionLayoutUpdateEvent; }
    240    
    241     void setDispatchRegionOversetChangeEvent(bool value) { m_dispatchRegionOversetChangeEvent = value; }
    242     bool shouldDispatchRegionOversetChangeEvent() const { return m_dispatchRegionOversetChangeEvent; }
    243    
    244     // Override if the flow thread implementation supports dispatching events when the flow layout is updated (e.g. for named flows)
    245     virtual void dispatchRegionLayoutUpdateEvent() { m_dispatchRegionLayoutUpdateEvent = false; }
    246     virtual void dispatchRegionOversetChangeEvent() { m_dispatchRegionOversetChangeEvent = false; }
    247237
    248238    void initializeRegionsComputedAutoHeight(RenderRegion* = 0);
    … …  
    340330    bool m_regionsHaveUniformLogicalWidth : 1;
    341331    bool m_regionsHaveUniformLogicalHeight : 1;
    342     bool m_dispatchRegionLayoutUpdateEvent : 1;
    343     bool m_dispatchRegionOversetChangeEvent : 1;
    344332    bool m_pageLogicalSizeChanged : 1;
    345333    unsigned m_layoutPhase : 2;

  • trunk/Source/WebCore/rendering/RenderNamedFlowFragment.cpp

    r164482 r164988  
    258258            oldRegionRect = oldRegionRect.transposedRect();
    259259
    260         if (m_flowThread->inOverflowLayoutPhase() || m_flowThread->inFinalLayoutPhase())
     260        if (m_flowThread->inOverflowLayoutPhase() || m_flowThread->inFinalLayoutPhase()) {
    261261            computeOverflowFromFlowThread();
     262            updateOversetState();
     263        }
    262264
    263265        if (hasAutoLogicalHeight() && m_flowThread->inMeasureContentLayoutPhase()) {
    … …  
    271273            m_flowThread->invalidateRegions();
    272274    }
     275}
     276
     277void RenderNamedFlowFragment::setRegionOversetState(RegionOversetState state)
     278{
     279    ASSERT(generatingElement());
     280
     281    generatingElement()->setRegionOversetState(state);
     282}
     283
     284RegionOversetState RenderNamedFlowFragment::regionOversetState() const
     285{
     286    ASSERT(generatingElement());
     287
     288    if (!isValid())
     289        return RegionUndefined;
     290
     291    return generatingElement()->regionOversetState();
     292}
     293
     294void RenderNamedFlowFragment::updateOversetState()
     295{
     296    ASSERT(isValid());
     297
     298    RenderNamedFlowThread* flowThread = namedFlowThread();
     299    ASSERT(flowThread && (flowThread->inOverflowLayoutPhase() || flowThread->inFinalLayoutPhase()));
     300
     301    LayoutUnit flowContentBottom = flowThread->flowContentBottom();
     302    bool isHorizontalWritingMode = flowThread->isHorizontalWritingMode();
     303
     304    LayoutUnit flowMin = flowContentBottom - (isHorizontalWritingMode ? flowThreadPortionRect().y() : flowThreadPortionRect().x());
     305    LayoutUnit flowMax = flowContentBottom - (isHorizontalWritingMode ? flowThreadPortionRect().maxY() : flowThreadPortionRect().maxX());
     306
     307    RegionOversetState previousState = regionOversetState();
     308    RegionOversetState state = RegionFit;
     309    if (flowMin <= 0)
     310        state = RegionEmpty;
     311    if (flowMax > 0 && isLastRegion())
     312        state = RegionOverset;
     313   
     314    setRegionOversetState(state);
     315
     316    // Determine whether the NamedFlow object should dispatch a regionLayoutUpdate event
     317    if (previousState != state
     318        || state == RegionFit
     319        || state == RegionOverset)
     320        flowThread->setDispatchRegionLayoutUpdateEvent(true);
     321   
     322    if (previousState != state)
     323        flowThread->setDispatchRegionOversetChangeEvent(true);
    273324}
    274325

  • trunk/Source/WebCore/rendering/RenderNamedFlowFragment.h

    r164482 r164988  
    105105    bool hasComputedAutoHeight() const { return m_hasComputedAutoHeight; }
    106106
     107    RegionOversetState regionOversetState() const;
     108
    107109    virtual void attachRegion() override;
    108110    virtual void detachRegion() override;
    … …  
    127129
    128130    bool shouldHaveAutoLogicalHeight() const;
     131
     132    void updateOversetState();
     133    void setRegionOversetState(RegionOversetState);
    129134
    130135    virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0) override;

  • trunk/Source/WebCore/rendering/RenderNamedFlowThread.cpp

    r164837 r164988  
    4848RenderNamedFlowThread::RenderNamedFlowThread(Document& document, PassRef<RenderStyle> style, PassRef<WebKitNamedFlow> namedFlow)
    4949    : RenderFlowThread(document, std::move(style))
    50     , m_overset(true)
    5150    , m_hasRegionsWithStyling(false)
     51    , m_dispatchRegionLayoutUpdateEvent(false)
     52    , m_dispatchRegionOversetChangeEvent(false)
    5253    , m_namedFlow(std::move(namedFlow))
    5354    , m_regionLayoutUpdateEventTimer(this, &RenderNamedFlowThread::regionLayoutUpdateEventTimerFired)
    … …  
    355356}
    356357
    357 void RenderNamedFlowThread::computeOversetStateForRegions(LayoutUnit oldClientAfterEdge)
    358 {
    359     LayoutUnit height = oldClientAfterEdge;
    360 
    361     // FIXME: the visual overflow of middle region (if it is the last one to contain any content in a render flow thread)
    362     // might not be taken into account because the render flow thread height is greater that that regions height + its visual overflow
    363     // because of how computeLogicalHeight is implemented for RenderNamedFlowThread (as a sum of all regions height).
    364     // This means that the middle region will be marked as fit (even if it has visual overflow flowing into the next region)
    365     if (hasRenderOverflow()
    366         && ( (isHorizontalWritingMode() && visualOverflowRect().maxY() > clientBoxRect().maxY())
    367             || (!isHorizontalWritingMode() && visualOverflowRect().maxX() > clientBoxRect().maxX())))
    368         height = isHorizontalWritingMode() ? visualOverflowRect().maxY() : visualOverflowRect().maxX();
    369 
    370     RenderNamedFlowFragment* lastFragment = toRenderNamedFlowFragment(lastRegion());
    371     for (auto& namedFlowFragment : m_regionList) {
    372         LayoutUnit flowMin = height - (isHorizontalWritingMode() ? namedFlowFragment->flowThreadPortionRect().y() : namedFlowFragment->flowThreadPortionRect().x());
    373         LayoutUnit flowMax = height - (isHorizontalWritingMode() ? namedFlowFragment->flowThreadPortionRect().maxY() : namedFlowFragment->flowThreadPortionRect().maxX());
    374         RegionOversetState previousState = namedFlowFragment->regionOversetState();
    375         RegionOversetState state = RegionFit;
    376         if (flowMin <= 0)
    377             state = RegionEmpty;
    378         if (flowMax > 0 && namedFlowFragment == lastFragment)
    379             state = RegionOverset;
    380         namedFlowFragment->setRegionOversetState(state);
    381         // determine whether the NamedFlow object should dispatch a regionLayoutUpdate event
    382         // FIXME: currently it cannot determine whether a region whose regionOverset state remained either "fit" or "overset" has actually
    383         // changed, so it just assumes that the NamedFlow should dispatch the event
    384         if (previousState != state
    385             || state == RegionFit
    386             || state == RegionOverset)
    387             setDispatchRegionLayoutUpdateEvent(true);
    388        
    389         if (previousState != state)
    390             setDispatchRegionOversetChangeEvent(true);
    391     }
    392    
     358void RenderNamedFlowThread::computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats)
     359{
     360    RenderFlowThread::computeOverflow(oldClientAfterEdge, recomputeFloats);
     361
     362    m_flowContentBottom = oldClientAfterEdge;
     363}
     364
     365void RenderNamedFlowThread::layout()
     366{
     367    RenderFlowThread::layout();
     368
    393369    // If the number of regions has changed since we last computed the overset property, schedule the regionOversetChange event.
    394370    if (previousRegionCountChanged()) {
    … …  
    397373    }
    398374
    399     // With the regions overflow state computed we can also set the overset flag for the named flow.
    400     // If there are no valid regions in the chain, overset is true.
    401     m_overset = lastFragment ? lastFragment->regionOversetState() == RegionOverset : true;
     375    dispatchRegionLayoutUpdateEventIfNeeded();
     376}
     377
     378void RenderNamedFlowThread::dispatchNamedFlowEvents()
     379{
     380    ASSERT(inFinalLayoutPhase());
     381
     382    dispatchRegionOversetChangeEventIfNeeded();
    402383}
    403384
    … …  
    530511}
    531512
    532 void RenderNamedFlowThread::dispatchRegionLayoutUpdateEvent()
    533 {
    534     RenderFlowThread::dispatchRegionLayoutUpdateEvent();
     513void RenderNamedFlowThread::dispatchRegionLayoutUpdateEventIfNeeded()
     514{
     515    if (!m_dispatchRegionLayoutUpdateEvent)
     516        return;
     517
     518    m_dispatchRegionLayoutUpdateEvent = false;
    535519    InspectorInstrumentation::didUpdateRegionLayout(&document(), &namedFlow());
    536520
    … …  
    539523}
    540524
    541 void RenderNamedFlowThread::dispatchRegionOversetChangeEvent()
    542 {
    543     RenderFlowThread::dispatchRegionOversetChangeEvent();
     525void RenderNamedFlowThread::dispatchRegionOversetChangeEventIfNeeded()
     526{
     527    if (!m_dispatchRegionOversetChangeEvent)
     528        return;
     529
     530    m_dispatchRegionOversetChangeEvent = false;
    544531    InspectorInstrumentation::didChangeRegionOverset(&document(), &namedFlow());
    545532   

  • trunk/Source/WebCore/rendering/RenderNamedFlowThread.h

    r164837 r164988  
    7171    LayoutRect decorationsClipRectForBoxInNamedFlowFragment(const RenderBox&, RenderNamedFlowFragment&) const;
    7272
    73     bool overset() const { return m_overset; }
    74     void computeOversetStateForRegions(LayoutUnit oldClientAfterEdge);
    75 
    7673    void registerNamedFlowContentElement(Element&);
    7774    void unregisterNamedFlowContentElement(Element&);
    … …  
    9289    virtual void removeFlowChildInfo(RenderObject*) override final;
    9390
     91    LayoutUnit flowContentBottom() const { return m_flowContentBottom; }
     92    void dispatchNamedFlowEvents();
     93
     94    void setDispatchRegionLayoutUpdateEvent(bool value) { m_dispatchRegionLayoutUpdateEvent = value; }
     95    void setDispatchRegionOversetChangeEvent(bool value) { m_dispatchRegionOversetChangeEvent = value; }
     96
    9497protected:
    9598    void setMarkForDestruction();
    … …  
    100103    virtual bool isRenderNamedFlowThread() const override { return true; }
    101104    virtual bool isChildAllowed(const RenderObject&, const RenderStyle&) const override;
     105    virtual void computeOverflow(LayoutUnit, bool = false) override;
     106    virtual void layout() override final;
    102107
    103     virtual void dispatchRegionLayoutUpdateEvent() override;
    104     virtual void dispatchRegionOversetChangeEvent() override;
     108    void dispatchRegionLayoutUpdateEventIfNeeded();
     109    void dispatchRegionOversetChangeEventIfNeeded();
    105110
    106111    bool dependsOn(RenderNamedFlowThread* otherRenderFlowThread) const;
    … …  
    138143    RenderRegionList m_invalidRegionList;
    139144
    140     bool m_overset : 1;
    141145    bool m_hasRegionsWithStyling : 1;
     146    bool m_dispatchRegionLayoutUpdateEvent : 1;
     147    bool m_dispatchRegionOversetChangeEvent : 1;
    142148
    143149    // The DOM Object that represents a named flow.
    … …  
    146152    Timer<RenderNamedFlowThread> m_regionLayoutUpdateEventTimer;
    147153    Timer<RenderNamedFlowThread> m_regionOversetChangeEventTimer;
     154
     155    LayoutUnit m_flowContentBottom;
    148156};
    149157

  • trunk/Source/WebCore/rendering/RenderRegion.cpp

    r164594 r164988  
    182182}
    183183
    184 RegionOversetState RenderRegion::regionOversetState() const
    185 {
    186     ASSERT(generatingElement());
    187 
    188     if (!isValid())
    189         return RegionUndefined;
    190 
    191     return generatingElement()->regionOversetState();
    192 }
    193 
    194 void RenderRegion::setRegionOversetState(RegionOversetState state)
    195 {
    196     ASSERT(generatingElement());
    197 
    198     generatingElement()->setRegionOversetState(state);
    199 }
    200 
    201184LayoutUnit RenderRegion::pageLogicalTopForOffset(LayoutUnit /* offset */) const
    202185{

  • trunk/Source/WebCore/rendering/RenderRegion.h

    r164594 r164988  
    7979    bool isLastRegion() const;
    8080    bool shouldClipFlowThreadContent() const;
    81 
    82     RegionOversetState regionOversetState() const;
    83     void setRegionOversetState(RegionOversetState);
    8481
    8582    // These methods represent the width and height of a "page" and for a RenderRegion they are just the
Note: See TracChangeset for help on using the changeset viewer.