Changeset 156291 in webkit


Ignore:
Timestamp:
Sep 23, 2013, 1:43:17 PM (12 years ago)
Author:
Simon Fraser
Message:

Rapidly loading pages can result in !needsLayout() assertions in FrameView::paintContents() and RenderView::paint()
​https://bugs.webkit.org/show_bug.cgi?id=121725
<rdar://problem/13982161> ASSERT(!needsLayout()) in WebCore::RenderView::paint (121196)

Reviewed by Dean Jackson.

Layout has to be up-to-date before we paint, and when composited we rely on a
CFRunLoopObserver owned by LayerFlushScheduler to enforce this. The contract is
that changes to GraphicsLayers accumulate in those layers, and are all pushed to
CALayers only inside of flushCompositingState(). CALayers must not be touched
directly outside of flushCompositingState(), since this may trigger a CA commit
and resultant painting without us having updated layout.

In addition, we rely on the CA commits only happening after our runloop observer
has fired in order for LayerFlushScheduler's suspend/resume to work (these are used
for freezing the layer tree during page transitions).

However, TileController was violating this contract. It called revalidateTiles()
at random times, and on a timer. This would result in CA commits happening when
layer flushing was suspended at the LayerFlushScheduler level, and thus before
we'd had a chance to do layout.

Fix by only ever revalidatingTiles inside of flushCompositingState(). Calls
that used to result in revalidateTiles() at other times now just set a bit
on GraphicsLayerCA to indicate that revalidation is required, and this triggers
a later flush like any other GraphicsLayerCA change.

There is one exception to the revalidate-inside-flush rule: when purging
files for background tabs on a timer, we are only dealing with an unparented
layer tree, so CALayer manipulation is safe at any time.

Very timing dependent, so hard to test.

  • platform/graphics/TiledBacking.h: Expose revalidateTiles()
  • platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp: Remove

platformCALayerDidCreateTiles() override.

  • platform/graphics/ca/GraphicsLayerCA.h: Keep track of m_isCommittingChanges

so we can assert. Add TilingAreaChanged flag.

  • platform/graphics/ca/GraphicsLayerCA.cpp:

(WebCore::GraphicsLayerCA::GraphicsLayerCA):
(WebCore::GraphicsLayerCA::recursiveCommitChanges): noteSublayersChanged() is
used inside of a commit in some cases to trigger a parent layer to update
children after the children have been processed. To avoid trying to pointlessly
schedule the flusher inside a flush, and for strong assertions, use a new flag
that indicates that flushing is not required in this situation.
Set the m_isCommittingChanges flag around committing state.
(WebCore::GraphicsLayerCA::platformCALayerSetNeedsToRevalidateTiles): We used
to use platformCALayerDidCreateTiles() to ensure that we would flush after adding
new tiles to avoid garbage flashes. Now that we only ever create tiles inside
a flush, this is no longer necessary.
The new platformCALayerSetNeedsToRevalidateTiles() function just sets the
TilingAreaChanged flag and triggers a flush.
(WebCore::GraphicsLayerCA::commitLayerChangesBeforeSublayers): After updating
visible rect, we look for the TilingAreaChanged flag to tell us whether to
revalidate TiledBacking tiles.
(WebCore::GraphicsLayerCA::ensureStructuralLayer): Use DontScheduleFlush when
telling a parent layer that it needs to reconsider sublayers.
(WebCore::GraphicsLayerCA::updateTiles): The caller of revalidateTiles().
(WebCore::GraphicsLayerCA::updateContentsRects): DontScheduleFlush again.
(WebCore::GraphicsLayerCA::noteSublayersChanged): Pass scheduleFlush along.
(WebCore::GraphicsLayerCA::noteLayerPropertyChanged): Handle scheduleFlush.

  • platform/graphics/ca/PlatformCALayerClient.h:

(WebCore::PlatformCALayerClient::platformCALayerSetNeedsToRevalidateTiles): Added
so that TileController can call back out to GraphicsLayerCA.
(WebCore::PlatformCALayerClient::isCommittingChanges):

  • platform/graphics/ca/mac/TileController.h: Need to keep track of secondary

coverage rects in m_secondaryTileCoverageRects.

  • platform/graphics/ca/mac/TileController.mm:

(WebCore::TileController::tileCacheLayerBoundsChanged): Just trigger a tile revalidate,
which will happen later in this same commit.
(WebCore::TileController::setScale): This is called inside the commit. Does an extra
revalidate, which is needed to prune tiles. This could be optimized in future.
(WebCore::TileController::setVisibleRect): Assert that we're inside a commit,
and trigger a revalidate.
(WebCore::TileController::setExposedRect): Trigger a revalidate.
(WebCore::TileController::setClipsToExposedRect): Ditto.
(WebCore::TileController::prepopulateRect): Save the rect and trigger a revalidate.
(WebCore::TileController::setIsInWindow): If we're in the window, trigger a revalidate
otherwise schedule the timer.
(WebCore::TileController::revalidateTiles): Wrapper for the real revalidateTiles().
(WebCore::TileController::tileRevalidationTimerFired): If we're in the window,
schedule a revalidate. Otherwise our layer tree is disconnected, and it's OK to call revalidateTiles().
(WebCore::TileController::setNeedsRevalidateTiles): Call through the client to GraphicsLayerCA
which will schedule a layer tree flush.
(WebCore::TileController::revalidateTiles):
(WebCore::TileController::ensureTilesForRect): Move code from prepopulateRect
into here; ensureTilesForRect() for each secondary rect, then clear the rects.
No need to call platformCALayerDidCreateTiles() at the end.

  • platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp: Remove

platformCALayerDidCreateTiles() override.

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::scheduleLayerFlush): This should only be
called when we're not inside a flush, otherwise it will fail to schedule
another one.

Location:
trunk/Source/WebCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r156289 r156291  
     12013-09-23  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Rapidly loading pages can result in !needsLayout() assertions in FrameView::paintContents() and RenderView::paint()
     4        https://bugs.webkit.org/show_bug.cgi?id=121725
     5        <rdar://problem/13982161> ASSERT(!needsLayout()) in WebCore::RenderView::paint (121196)
     6
     7        Reviewed by Dean Jackson.
     8       
     9        Layout has to be up-to-date before we paint, and when composited we rely on a
     10        CFRunLoopObserver owned by LayerFlushScheduler to enforce this. The contract is
     11        that changes to GraphicsLayers accumulate in those layers, and are all pushed to
     12        CALayers only inside of flushCompositingState(). CALayers must not be touched
     13        directly outside of flushCompositingState(), since this may trigger a CA commit
     14        and resultant painting without us having updated layout.
     15       
     16        In addition, we rely on the CA commits only happening after our runloop observer
     17        has fired in order for LayerFlushScheduler's suspend/resume to work (these are used
     18        for freezing the layer tree during page transitions).
     19       
     20        However, TileController was violating this contract. It called revalidateTiles()
     21        at random times, and on a timer. This would result in CA commits happening when
     22        layer flushing was suspended at the LayerFlushScheduler level, and thus before
     23        we'd had a chance to do layout.
     24       
     25        Fix by only ever revalidatingTiles inside of flushCompositingState(). Calls
     26        that used to result in revalidateTiles() at other times now just set a bit
     27        on GraphicsLayerCA to indicate that revalidation is required, and this triggers
     28        a later flush like any other GraphicsLayerCA change.
     29       
     30        There is one exception to the revalidate-inside-flush rule: when purging
     31        files for background tabs on a timer, we are only dealing with an unparented
     32        layer tree, so CALayer manipulation is safe at any time.
     33
     34        Very timing dependent, so hard to test.
     35
     36        * platform/graphics/TiledBacking.h: Expose revalidateTiles()
     37        * platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp: Remove
     38        platformCALayerDidCreateTiles() override.
     39        * platform/graphics/ca/GraphicsLayerCA.h: Keep track of m_isCommittingChanges
     40        so we can assert. Add TilingAreaChanged flag.
     41        * platform/graphics/ca/GraphicsLayerCA.cpp:
     42        (WebCore::GraphicsLayerCA::GraphicsLayerCA):
     43        (WebCore::GraphicsLayerCA::recursiveCommitChanges): noteSublayersChanged() is
     44        used inside of a commit in some cases to trigger a parent layer to update
     45        children after the children have been processed. To avoid trying to pointlessly
     46        schedule the flusher inside a flush, and for strong assertions, use a new flag
     47        that indicates that flushing is not required in this situation.
     48        Set the m_isCommittingChanges flag around committing state.
     49        (WebCore::GraphicsLayerCA::platformCALayerSetNeedsToRevalidateTiles): We used
     50        to use platformCALayerDidCreateTiles() to ensure that we would flush after adding
     51        new tiles to avoid garbage flashes. Now that we only ever create tiles inside
     52        a flush, this is no longer necessary.
     53        The new platformCALayerSetNeedsToRevalidateTiles() function just sets the
     54        TilingAreaChanged flag and triggers a flush.
     55        (WebCore::GraphicsLayerCA::commitLayerChangesBeforeSublayers): After updating
     56        visible rect, we look for the TilingAreaChanged flag to tell us whether to
     57        revalidate TiledBacking tiles.
     58        (WebCore::GraphicsLayerCA::ensureStructuralLayer): Use DontScheduleFlush when
     59        telling a parent layer that it needs to reconsider sublayers.
     60        (WebCore::GraphicsLayerCA::updateTiles): The caller of revalidateTiles().
     61        (WebCore::GraphicsLayerCA::updateContentsRects): DontScheduleFlush again.
     62        (WebCore::GraphicsLayerCA::noteSublayersChanged): Pass scheduleFlush along.
     63        (WebCore::GraphicsLayerCA::noteLayerPropertyChanged): Handle scheduleFlush.
     64        * platform/graphics/ca/PlatformCALayerClient.h:
     65        (WebCore::PlatformCALayerClient::platformCALayerSetNeedsToRevalidateTiles): Added
     66        so that TileController can call back out to GraphicsLayerCA.
     67        (WebCore::PlatformCALayerClient::isCommittingChanges):
     68        * platform/graphics/ca/mac/TileController.h: Need to keep track of secondary
     69        coverage rects in m_secondaryTileCoverageRects.
     70        * platform/graphics/ca/mac/TileController.mm:
     71        (WebCore::TileController::tileCacheLayerBoundsChanged): Just trigger a tile revalidate,
     72        which will happen later in this same commit.
     73        (WebCore::TileController::setScale): This is called inside the commit. Does an extra
     74        revalidate, which is needed to prune tiles. This could be optimized in future.
     75        (WebCore::TileController::setVisibleRect): Assert that we're inside a commit,
     76        and trigger a revalidate.
     77        (WebCore::TileController::setExposedRect): Trigger a revalidate.
     78        (WebCore::TileController::setClipsToExposedRect): Ditto.
     79        (WebCore::TileController::prepopulateRect): Save the rect and trigger a revalidate.
     80        (WebCore::TileController::setIsInWindow): If we're in the window, trigger a revalidate
     81        otherwise schedule the timer.
     82        (WebCore::TileController::revalidateTiles): Wrapper for the real revalidateTiles().
     83        (WebCore::TileController::tileRevalidationTimerFired): If we're in the window,
     84        schedule a revalidate. Otherwise our layer tree is disconnected, and it's OK to call revalidateTiles().
     85        (WebCore::TileController::setNeedsRevalidateTiles): Call through the client to GraphicsLayerCA
     86        which will schedule a layer tree flush.
     87        (WebCore::TileController::revalidateTiles):
     88        (WebCore::TileController::ensureTilesForRect): Move code from prepopulateRect
     89        into here; ensureTilesForRect() for each secondary rect, then clear the rects.
     90        No need to call platformCALayerDidCreateTiles() at the end.
     91        * platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp: Remove
     92        platformCALayerDidCreateTiles() override.
     93        * rendering/RenderLayerCompositor.cpp:
     94        (WebCore::RenderLayerCompositor::scheduleLayerFlush): This should only be
     95        called when we're not inside a flush, otherwise it will fail to schedule
     96        another one.
     97
    1982013-09-23  Sam Weinig  <sam@webkit.org>
    299

  • trunk/Source/WebCore/platform/graphics/TiledBacking.h

    r147058 r156291  
    7171    virtual IntSize tileSize() const = 0;
    7272
     73    virtual void revalidateTiles() = 0;
    7374    virtual void forceRepaint() = 0;
    7475

  • trunk/Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp

    r155127 r156291  
    194194    virtual bool platformCALayerDrawsContent() const { return false; }
    195195    virtual void platformCALayerLayerDidDisplay(PlatformLayer*) { }
    196     virtual void platformCALayerDidCreateTiles(const Vector<FloatRect>&) { }
    197196    virtual float platformCALayerDeviceScaleFactor() { return 1; }
    198197

  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

    r155998 r156291  
    4545#include <limits.h>
    4646#include <wtf/CurrentTime.h>
     47#include <wtf/TemporaryChange.h>
    4748#include <wtf/text/WTFString.h>
    4849
    … …  
    288289    , m_rootRelativeScaleFactor(1)
    289290    , m_uncommittedChanges(0)
     291    , m_isCommittingChanges(false)
    290292{
    291293    PlatformCALayer::LayerType layerType = PlatformCALayer::LayerTypeWebLayer;
    … …  
    11041106        m_visibleTileWashLayer->setBorderWidth(8);
    11051107        m_visibleTileWashLayer->setBackgroundColor(washFillColor);
    1106         noteSublayersChanged();
     1108        noteSublayersChanged(DontScheduleFlush);
    11071109    }
    11081110
    … …  
    11241126   
    11251127    TransformationMatrix transformFromRoot = rootRelativeTransformForScaling;
    1126     commitLayerChangesBeforeSublayers(childCommitState, pageScaleFactor, baseRelativePosition, oldVisibleRect, &transformFromRoot);
     1128    {
     1129        TemporaryChange<bool> committingChangesChange(m_isCommittingChanges, true);
     1130        commitLayerChangesBeforeSublayers(childCommitState, pageScaleFactor, baseRelativePosition, oldVisibleRect, &transformFromRoot);
     1131    }
    11271132
    11281133    if (isRunningTransformAnimation()) {
    … …  
    11501155        static_cast<GraphicsLayerCA*>(m_maskLayer)->commitLayerChangesAfterSublayers(childCommitState);
    11511156
    1152     commitLayerChangesAfterSublayers(childCommitState);
     1157    {
     1158        TemporaryChange<bool> committingChangesChange(m_isCommittingChanges, true);
     1159        commitLayerChangesAfterSublayers(childCommitState);
     1160    }
    11531161
    11541162    if (affectedByTransformAnimation && client() && m_layer->layerType() == PlatformCALayer::LayerTypeTiledBackingLayer)
    … …  
    11741182}
    11751183
    1176 void GraphicsLayerCA::platformCALayerDidCreateTiles(const Vector<FloatRect>& dirtyRects)
    1177 {
    1178     ASSERT(m_layer->usesTiledBackingLayer());
    1179 
    1180     for (size_t i = 0; i < dirtyRects.size(); ++i)
    1181         setNeedsDisplayInRect(dirtyRects[i]);
    1182 
    1183     noteLayerPropertyChanged(TilesAdded);
     1184void GraphicsLayerCA::platformCALayerSetNeedsToRevalidateTiles()
     1185{
     1186    noteLayerPropertyChanged(TilingAreaChanged, m_isCommittingChanges ? DontScheduleFlush : ScheduleFlush);
    11841187}
    11851188
    … …  
    12731276    if (m_uncommittedChanges & VisibleRectChanged)
    12741277        updateVisibleRect(oldVisibleRect);
     1278   
     1279    if (m_uncommittedChanges & TilingAreaChanged) // Needs to happen after VisibleRectChanged, ContentsScaleChanged
     1280        updateTiles();
    12751281
    12761282    if (m_uncommittedChanges & DirtyRectsChanged)
    … …  
    16211627    // We've changed the layer that our parent added to its sublayer list, so tell it to update
    16221628    // sublayers again in its commitLayerChangesAfterSublayers().
    1623     static_cast<GraphicsLayerCA*>(parent())->noteSublayersChanged();
     1629    static_cast<GraphicsLayerCA*>(parent())->noteSublayersChanged(DontScheduleFlush);
    16241630
    16251631    // Set properties of m_layer to their default values, since these are expressed on on the structural layer.
    … …  
    17561762}
    17571763
     1764void GraphicsLayerCA::updateTiles()
     1765{
     1766    if (!m_layer->usesTiledBackingLayer())
     1767        return;
     1768
     1769    tiledBacking()->revalidateTiles();
     1770}
     1771
    17581772void GraphicsLayerCA::updateBackgroundColor()
    17591773{
    … …  
    18821896   
    18831897    if (gainedOrLostClippingLayer)
    1884         noteSublayersChanged();
     1898        noteSublayersChanged(DontScheduleFlush);
    18851899
    18861900    m_contentsLayer->setPosition(contentOrigin);
    … …  
    32653279}
    32663280
    3267 void GraphicsLayerCA::noteSublayersChanged()
    3268 {
    3269     noteLayerPropertyChanged(ChildrenChanged);
     3281void GraphicsLayerCA::noteSublayersChanged(ScheduleFlushOrNot scheduleFlush)
     3282{
     3283    noteLayerPropertyChanged(ChildrenChanged, scheduleFlush);
    32703284    propagateLayerChangeToReplicas();
    32713285}
    … …  
    32773291}
    32783292
    3279 void GraphicsLayerCA::noteLayerPropertyChanged(LayerChangeFlags flags)
     3293void GraphicsLayerCA::noteLayerPropertyChanged(LayerChangeFlags flags, ScheduleFlushOrNot scheduleFlush)
    32803294{
    32813295    bool hadUncommittedChanges = !!m_uncommittedChanges;
    … …  
    32843298    m_uncommittedChanges |= flags;
    32853299
    3286     bool needsFlush = !hadUncommittedChanges || oldCanThrottleLayerFlush != canThrottleLayerFlush();
    3287     if (needsFlush && m_client)
    3288         m_client->notifyFlushRequired(this);
     3300    if (scheduleFlush == ScheduleFlush) {
     3301        bool needsFlush = !hadUncommittedChanges || oldCanThrottleLayerFlush != canThrottleLayerFlush();
     3302        if (needsFlush && m_client)
     3303            m_client->notifyFlushRequired(this);
     3304    }
    32893305}
    32903306

  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

    r155998 r156291  
    173173    virtual bool platformCALayerDrawsContent() const { return drawsContent(); }
    174174    virtual void platformCALayerLayerDidDisplay(PlatformLayer* layer) { return layerDidDisplay(layer); }
    175     virtual void platformCALayerDidCreateTiles(const Vector<FloatRect>& dirtyRects) OVERRIDE;
     175    virtual void platformCALayerSetNeedsToRevalidateTiles() OVERRIDE;
    176176    virtual float platformCALayerDeviceScaleFactor() OVERRIDE;
     177    virtual bool isCommittingChanges() const OVERRIDE { return m_isCommittingChanges; }
    177178
    178179    virtual double backingStoreMemoryEstimate() const;
    … …  
    356357    void updateDebugBorder();
    357358    void updateVisibleRect(const FloatRect& oldVisibleRect);
     359    void updateTiles();
    358360    void updateContentsScale(float pageScaleFactor);
    359361   
    … …  
    411413        VisibleRectChanged = 1 << 26,
    412414        FiltersChanged = 1 << 27,
    413         TilesAdded = 1 < 28,
    414         DebugIndicatorsChanged = 1 << 29
     415        TilingAreaChanged = 1 << 28,
     416        TilesAdded = 1 < 29,
     417        DebugIndicatorsChanged = 1 << 30
    415418    };
    416419    typedef unsigned LayerChangeFlags;
    417     void noteLayerPropertyChanged(LayerChangeFlags flags);
    418     void noteSublayersChanged();
     420    enum ScheduleFlushOrNot { ScheduleFlush, DontScheduleFlush };
     421    void noteLayerPropertyChanged(LayerChangeFlags, ScheduleFlushOrNot = ScheduleFlush);
     422    void noteSublayersChanged(ScheduleFlushOrNot = ScheduleFlush);
    419423    void noteChangesForScaleSensitiveProperties();
    420424
    … …  
    506510   
    507511    LayerChangeFlags m_uncommittedChanges;
     512    bool m_isCommittingChanges;
    508513};
    509514

  • trunk/Source/WebCore/platform/graphics/ca/PlatformCALayerClient.h

    r130676 r156291  
    6060    virtual void platformCALayerLayerDidDisplay(PlatformLayer*) = 0;
    6161
    62     virtual void platformCALayerDidCreateTiles(const Vector<FloatRect>& dirtyRects) = 0;
     62    virtual void platformCALayerSetNeedsToRevalidateTiles() { }
    6363    virtual float platformCALayerDeviceScaleFactor() = 0;
     64
     65    virtual bool isCommittingChanges() const { return false; }
    6466
    6567protected:

  • trunk/Source/WebCore/platform/graphics/ca/mac/TileController.h

    r154415 r156291  
    116116    virtual void setTileCoverage(TileCoverage) OVERRIDE;
    117117    virtual TileCoverage tileCoverage() const OVERRIDE { return m_tileCoverage; }
     118    virtual void revalidateTiles() OVERRIDE;
    118119    virtual void forceRepaint() OVERRIDE;
    119120    virtual IntSize tileSize() const OVERRIDE { return m_tileSize; }
    … …  
    146147    typedef unsigned TileValidationPolicyFlags;
    147148
    148     void revalidateTiles(TileValidationPolicyFlags foregroundValidationPolicy = 0, TileValidationPolicyFlags backgroundValidationPolicy = 0);
     149    void setNeedsRevalidateTiles();
     150    void revalidateTiles(TileValidationPolicyFlags foregroundValidationPolicy, TileValidationPolicyFlags backgroundValidationPolicy);
    149151    enum class CoverageType { PrimaryTiles, SecondaryTiles };
    150152
    … …  
    180182    FloatRect m_exposedRect; // The exposed area of containing platform views.
    181183    IntRect m_boundsAtLastRevalidate;
     184   
     185    Vector<FloatRect> m_secondaryTileCoverageRects;
    182186
    183187    typedef HashMap<TileIndex, TileInfo> TileMap;

  • trunk/Source/WebCore/platform/graphics/ca/mac/TileController.mm

    r154415 r156291  
    136136void TileController::tileCacheLayerBoundsChanged()
    137137{
    138     if (m_tiles.isEmpty()) {
    139         // We must revalidate immediately instead of using a timer when there are
    140         // no tiles to avoid a flash when transitioning from one page to another.
    141         revalidateTiles();
    142         return;
    143     }
    144 
    145     scheduleTileRevalidation(0);
     138    ASSERT(PlatformCALayer::platformCALayer(m_tileCacheLayer)->owner()->isCommittingChanges());
     139    setNeedsRevalidateTiles();
    146140}
    147141
    … …  
    233227{
    234228    PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);
     229    ASSERT(platformLayer->owner()->isCommittingChanges());
     230
    235231    float deviceScaleFactor = platformLayer->owner()->platformCALayerDeviceScaleFactor();
    236232
    … …  
    248244    [m_tileContainerLayer.get() setTransform:CATransform3DMakeScale(1 / m_scale, 1 / m_scale, 1)];
    249245
     246    // FIXME: we may revalidateTiles twice in this commit.
    250247    revalidateTiles(PruneSecondaryTiles, PruneSecondaryTiles);
    251248
    … …  
    260257        dirtyRects.append(scaledTileRect);
    261258    }
    262 
    263     platformLayer->owner()->platformCALayerDidCreateTiles(dirtyRects);
    264259}
    265260
    … …  
    292287void TileController::setVisibleRect(const FloatRect& visibleRect)
    293288{
     289    ASSERT(PlatformCALayer::platformCALayer(m_tileCacheLayer)->owner()->isCommittingChanges());
    294290    if (m_visibleRect == visibleRect)
    295291        return;
    296292
    297293    m_visibleRect = visibleRect;
    298     revalidateTiles();
     294    setNeedsRevalidateTiles();
    299295}
    300296
    … …  
    334330
    335331    m_exposedRect = exposedRect;
    336     revalidateTiles();
     332    setNeedsRevalidateTiles();
    337333}
    338334
    … …  
    346342    // Going from not clipping to clipping, we don't need to revalidate right away.
    347343    if (clipsToExposedRect)
    348         revalidateTiles();
     344        setNeedsRevalidateTiles();
    349345}
    350346
    … …  
    357353    if (m_primaryTileCoverageRect.contains(rectInTileCoords))
    358354        return;
    359 
    360     ensureTilesForRect(rect, CoverageType::SecondaryTiles);
    361 
    362     if (m_tiledScrollingIndicatorLayer)
    363         updateTileCoverageMap();
     355   
     356    m_secondaryTileCoverageRects.append(rect);
     357    setNeedsRevalidateTiles();
    364358}
    365359
    … …  
    372366
    373367    if (m_isInWindow)
    374         revalidateTiles();
     368        setNeedsRevalidateTiles();
    375369    else {
    376370        const double tileRevalidationTimeout = 4;
    … …  
    385379
    386380    m_tileCoverage = coverage;
    387     scheduleTileRevalidation(0);
     381    setNeedsRevalidateTiles();
     382}
     383
     384void TileController::revalidateTiles()
     385{
     386    ASSERT(PlatformCALayer::platformCALayer(m_tileCacheLayer)->owner()->isCommittingChanges());
     387    revalidateTiles(0, 0);
    388388}
    389389
    … …  
    511511void TileController::tileRevalidationTimerFired(Timer<TileController>*)
    512512{
     513    if (m_isInWindow) {
     514        setNeedsRevalidateTiles();
     515        return;
     516    }
     517
    513518    TileValidationPolicyFlags foregroundValidationPolicy = m_aggressivelyRetainsTiles ? 0 : PruneSecondaryTiles;
    514519    TileValidationPolicyFlags backgroundValidationPolicy = foregroundValidationPolicy | UnparentAllTiles;
    … …  
    603608        LayerPool::sharedPool()->addLayer(tileInfo.layer);
    604609    }
     610}
     611
     612void TileController::setNeedsRevalidateTiles()
     613{
     614    PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);
     615    platformLayer->owner()->platformCALayerSetNeedsToRevalidateTiles();
    605616}
    606617
    … …  
    672683            scheduleCohortRemoval();
    673684    }
    674    
     685
    675686    // Ensure primary tile coverage tiles.
    676687    m_primaryTileCoverageRect = ensureTilesForRect(tileCoverageRect, CoverageType::PrimaryTiles);
    … …  
    679690        removeAllSecondaryTiles();
    680691        m_cohortList.clear();
     692    } else {
     693        for (size_t i = 0; i < m_secondaryTileCoverageRects.size(); ++i)
     694            ensureTilesForRect(m_secondaryTileCoverageRects[i], CoverageType::SecondaryTiles);
     695        m_secondaryTileCoverageRects.clear();
    681696    }
    682697
    … …  
    834849    if (tilesInCohort)
    835850        startedNewCohort(currCohort);
    836 
    837     // This will ensure we flush compositing state and do layout in this run loop iteration.
    838     if (!dirtyRects.isEmpty())
    839         platformLayer->owner()->platformCALayerDidCreateTiles(dirtyRects);
    840851
    841852    return coverageRect;

  • trunk/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp

    r155130 r156291  
    109109    virtual bool platformCALayerDrawsContent() const { return false; }
    110110    virtual void platformCALayerLayerDidDisplay(PlatformLayer*) { }
    111     virtual void platformCALayerDidCreateTiles(const Vector<FloatRect>&) { }
    112111    virtual float platformCALayerDeviceScaleFactor() { return 1; }
    113112

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

    r156201 r156291  
    356356void RenderLayerCompositor::scheduleLayerFlush(bool canThrottle)
    357357{
     358    ASSERT(!m_flushingLayers);
     359
    358360    if (canThrottle && isThrottlingLayerFlushes()) {
    359361        m_hasPendingLayerFlush = true;
Note: See TracChangeset for help on using the changeset viewer.