Changeset 138858 in webkit


Ignore:
Timestamp:
Jan 4, 2013 3:15:40 PM (11 years ago)
Author:
timothy_horton@apple.com
Message:

[wk2] Remove non-visible tiles from the layer tree
​https://bugs.webkit.org/show_bug.cgi?id=106061
<rdar://problem/12761821>

Reviewed by Simon Fraser.

Unparenting tiles which aren't currently on-screen can allow underlying
frameworks to manage the layer's backing stores more effectively than we can.

In addition, add a setting (AggressiveTileRetentionEnabled) which keeps more
tiles around (we don't remove tiles in cohorts, nor when the TileCache moves
out of the window), which is off by default.

  • WebCore.exp.in: Export Settings::setAggressiveTileRetentionEnabled.
  • page/Settings.cpp:

(WebCore::Settings::Settings): Initialize m_aggressiveTileRetentionEnabled to false.
(WebCore::Settings::setAggressiveTileRetentionEnabled): Added.

  • page/Settings.h:

(WebCore::Settings::aggressiveTileRetentionEnabled): Added.

  • platform/graphics/TiledBacking.h: Add setter/getter to hand aggressivelyRetainsTiles through to TiledBackings.
  • platform/graphics/ca/mac/TileCache.h:

(TileCache): Turn TileValidationPolicy into TileValidationPolicyFlags, and add
a flag for unparenting all tiles.
Implement aggressivelyRetainsTiles setter/getter.

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

(WebCore::TileCache::TileCache): Initialize m_aggressivelyRetainsTiles to false.
(WebCore::TileCache::setIsInWindow): Revalidate tiles immediately if the TileCache has just entered the window.
(WebCore::TileCache::tileRevalidationTimerFired):
This is called if coverage rect, tile cache layer bounds, or visibility changes. We will revalidate tiles:

  • Removing all tiles from the layer tree for background tile caches.
  • Not pruning old tiles if the aggressiveTileRetentionEnabled setting is on.

(WebCore::TileCache::revalidateTiles):
Adopt TileValidationPolicyFlags instead of the old enum, and use separate flags for foreground/background caches.
Unparent tiles when they move out of the tile coverage rect.
Only schedule the tile cohort removal timer if we're not aggressively keeping tiles around.
Ensure that tiles are re-added to the TileCache layer tree if they already exist.
Unparent all tiles if TileValidationPolicyFlags says to (from tileRevalidationTimerFired's background flags).
Only add new tiles to the TileCache's layer tree if we're currently in the window.
Don't prune secondary tiles if the visible rect changes; this will already occur because when the visibleRect
changes, we arrive via tileRevalidationTimerFired, which asks for PruneSecondaryTiles anyway (except if we're
aggressively retaining tiles). This prevents tiles from being deleted unexpectedly during rubber-banding or when zoomed (this part of the patch is thanks to Simon).
(WebCore::TileCache::ensureTilesForRect):
Don't ensure any tiles if the TileCache is offscreen.
Ensure that tiles are re-added to the TileCache layer tree if they already exist.
(WebCore::TileCache::drawTileMapContents):
Draw a thick purple border around tiles that have been unparented.

Add a setting to enable aggressive retention of TileCache tiles. If enabled,
TileCache will generally try to keep around all tiles. This setting is off by default.

  • Shared/WebPreferencesStore.h:
  • UIProcess/API/C/WKPreferences.cpp:

(WKPreferencesSetAggressiveTileRetentionEnabled):
(WKPreferencesGetAggressiveTileRetentionEnabled):

  • UIProcess/API/C/WKPreferencesPrivate.h:
  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::updatePreferences):

  • WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:

(WebKit::TiledCoreAnimationDrawingArea::updatePreferences): Forward the setting to the TiledBacking.

Location:
trunk/Source
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r138855 r138858  
     12013-01-04  Tim Horton  <timothy_horton@apple.com>
     2
     3        [wk2] Remove non-visible tiles from the layer tree
     4        https://bugs.webkit.org/show_bug.cgi?id=106061
     5        <rdar://problem/12761821>
     6
     7        Reviewed by Simon Fraser.
     8
     9        Unparenting tiles which aren't currently on-screen can allow underlying
     10        frameworks to manage the layer's backing stores more effectively than we can.
     11
     12        In addition, add a setting (AggressiveTileRetentionEnabled) which keeps more
     13        tiles around (we don't remove tiles in cohorts, nor when the TileCache moves
     14        out of the window), which is off by default.
     15
     16        * WebCore.exp.in: Export Settings::setAggressiveTileRetentionEnabled.
     17        * page/Settings.cpp:
     18        (WebCore::Settings::Settings): Initialize m_aggressiveTileRetentionEnabled to false.
     19        (WebCore::Settings::setAggressiveTileRetentionEnabled): Added.
     20        * page/Settings.h:
     21        (WebCore::Settings::aggressiveTileRetentionEnabled): Added.
     22        * platform/graphics/TiledBacking.h: Add setter/getter to hand aggressivelyRetainsTiles through to TiledBackings.
     23        * platform/graphics/ca/mac/TileCache.h:
     24        (TileCache): Turn TileValidationPolicy into TileValidationPolicyFlags, and add
     25        a flag for unparenting all tiles.
     26        Implement aggressivelyRetainsTiles setter/getter.
     27        * platform/graphics/ca/mac/TileCache.mm:
     28        (WebCore::TileCache::TileCache): Initialize m_aggressivelyRetainsTiles to false.
     29        (WebCore::TileCache::setIsInWindow): Revalidate tiles immediately if the TileCache has just entered the window.
     30        (WebCore::TileCache::tileRevalidationTimerFired):
     31        This is called if coverage rect, tile cache layer bounds, or visibility changes. We will revalidate tiles:
     32            - Removing all tiles from the layer tree for background tile caches.
     33            - Not pruning old tiles if the aggressiveTileRetentionEnabled setting is on.
     34        (WebCore::TileCache::revalidateTiles):
     35        Adopt TileValidationPolicyFlags instead of the old enum, and use separate flags for foreground/background caches.
     36        Unparent tiles when they move out of the tile coverage rect.
     37        Only schedule the tile cohort removal timer if we're not aggressively keeping tiles around.
     38        Ensure that tiles are re-added to the TileCache layer tree if they already exist.
     39        Unparent all tiles if TileValidationPolicyFlags says to (from tileRevalidationTimerFired's background flags).
     40        Only add new tiles to the TileCache's layer tree if we're currently in the window.
     41        Don't prune secondary tiles if the visible rect changes; this will already occur because when the visibleRect
     42        changes, we arrive via tileRevalidationTimerFired, which asks for PruneSecondaryTiles anyway (except if we're
     43        aggressively retaining tiles). This prevents tiles from being deleted unexpectedly during rubber-banding or when zoomed (this part of the patch is thanks to Simon).
     44        (WebCore::TileCache::ensureTilesForRect):
     45        Don't ensure any tiles if the TileCache is offscreen.
     46        Ensure that tiles are re-added to the TileCache layer tree if they already exist.
     47        (WebCore::TileCache::drawTileMapContents):
     48        Draw a thick purple border around tiles that have been unparented.
     49
    1502013-01-04  Adam Barth  <abarth@webkit.org>
    251

  • trunk/Source/WebCore/WebCore.exp.in

    r138632 r138858  
    986986__ZN7WebCore8Settings32setNeedsAdobeFrameReloadingQuirkEb
    987987__ZN7WebCore8Settings32setScreenFontSubstitutionEnabledEb
     988__ZN7WebCore8Settings33setAggressiveTileRetentionEnabledEb
    988989__ZN7WebCore8Settings37setScrollingPerformanceLoggingEnabledEb
    989990__ZN7WebCore8Settings45setShouldRespectPriorityInCSSAttributeSettersEb

  • trunk/Source/WebCore/page/Settings.cpp

    r137185 r138858  
    187187#endif
    188188    , m_scrollingPerformanceLoggingEnabled(false)
     189    , m_aggressiveTileRetentionEnabled(false)
    189190    , m_setImageLoadingSettingsTimer(this, &Settings::imageLoadingSettingsTimerFired)
    190191{
    … …  
    642643        m_page->mainFrame()->view()->setScrollingPerformanceLoggingEnabled(enabled);
    643644}
     645   
     646void Settings::setAggressiveTileRetentionEnabled(bool enabled)
     647{
     648    m_aggressiveTileRetentionEnabled = enabled;
     649}
    644650
    645651void Settings::setMockScrollbarsEnabled(bool flag)

  • trunk/Source/WebCore/page/Settings.h

    r137185 r138858  
    293293        void setScrollingPerformanceLoggingEnabled(bool);
    294294        bool scrollingPerformanceLoggingEnabled() { return m_scrollingPerformanceLoggingEnabled; }
     295       
     296        void setAggressiveTileRetentionEnabled(bool);
     297        bool aggressiveTileRetentionEnabled() { return m_aggressiveTileRetentionEnabled; }
    295298
    296299#if USE(JSC)
    … …  
    367370#endif
    368371        bool m_scrollingPerformanceLoggingEnabled : 1;
     372        bool m_aggressiveTileRetentionEnabled : 1;
    369373
    370374        Timer<Settings> m_setImageLoadingSettingsTimer;

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

    r137387 r138858  
    7171    virtual bool scrollingPerformanceLoggingEnabled() const = 0;
    7272   
     73    virtual void setAggressivelyRetainsTiles(bool) = 0;
     74    virtual bool aggressivelyRetainsTiles() const = 0;
     75
    7376    // Exposed for testing
    7477    virtual IntRect tileCoverageRect() const = 0;

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

    r137387 r138858  
    11/*
    2  * Copyright (C) 2011 Apple Inc. All rights reserved.
     2 * Copyright (C) 2011, 2012, 2013 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    116116    virtual void setScrollingPerformanceLoggingEnabled(bool flag) OVERRIDE { m_scrollingPerformanceLoggingEnabled = flag; }
    117117    virtual bool scrollingPerformanceLoggingEnabled() const OVERRIDE { return m_scrollingPerformanceLoggingEnabled; }
     118    virtual void setAggressivelyRetainsTiles(bool flag) OVERRIDE { m_aggressivelyRetainsTiles = flag; }
     119    virtual bool aggressivelyRetainsTiles() const OVERRIDE { return m_aggressivelyRetainsTiles; }
    118120    virtual IntRect tileCoverageRect() const OVERRIDE;
    119121    virtual CALayer *tiledScrollingIndicatorLayer() OVERRIDE;
    … …  
    134136    void cohortRemovalTimerFired(Timer<TileCache>*);
    135137   
    136     enum TileValidationPolicy {
    137         KeepSecondaryTiles,
    138         PruneSecondaryTiles
    139     };
    140     void revalidateTiles(TileValidationPolicy = KeepSecondaryTiles);
     138    typedef unsigned TileValidationPolicyFlags;
     139
     140    void revalidateTiles(TileValidationPolicyFlags foregroundValidationPolicy = 0, TileValidationPolicyFlags backgroundValidationPolicy = 0);
    141141    void ensureTilesForRect(const IntRect&);
    142142    void updateTileCoverageMap();
    … …  
    192192    bool m_isInWindow;
    193193    bool m_scrollingPerformanceLoggingEnabled;
     194    bool m_aggressivelyRetainsTiles;
    194195    bool m_acceleratesDrawing;
    195196    bool m_tilesAreOpaque;

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

    r138177 r138858  
    11/*
    2  * Copyright (C) 2011 Apple Inc. All rights reserved.
     2 * Copyright (C) 2011, 2012, 2013 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    8181
    8282namespace WebCore {
     83   
     84enum TileValidationPolicyFlag {
     85    PruneSecondaryTiles = 1 << 0,
     86    UnparentAllTiles = 1 << 1
     87};
    8388
    8489static const int defaultTileCacheWidth = 512;
    … …  
    101106    , m_isInWindow(false)
    102107    , m_scrollingPerformanceLoggingEnabled(false)
     108    , m_aggressivelyRetainsTiles(false)
    103109    , m_acceleratesDrawing(false)
    104110    , m_tilesAreOpaque(false)
    … …  
    243249    [m_tileContainerLayer.get() setTransform:CATransform3DMakeScale(1 / m_scale, 1 / m_scale, 1)];
    244250
    245     revalidateTiles(PruneSecondaryTiles);
     251    revalidateTiles(PruneSecondaryTiles, PruneSecondaryTiles);
    246252
    247253    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {
    … …  
    311317    m_isInWindow = isInWindow;
    312318
    313     if (!m_isInWindow) {
    314         const double tileRevalidationTimeout = 4;
    315         scheduleTileRevalidation(tileRevalidationTimeout);
    316     }
     319    const double tileRevalidationTimeout = 4;
     320    scheduleTileRevalidation(m_isInWindow ? 0 : tileRevalidationTimeout);
    317321}
    318322
    … …  
    441445void TileCache::tileRevalidationTimerFired(Timer<TileCache>*)
    442446{
    443     revalidateTiles(PruneSecondaryTiles);
     447    TileValidationPolicyFlags foregroundValidationPolicy = m_aggressivelyRetainsTiles ? 0 : PruneSecondaryTiles;
     448    TileValidationPolicyFlags backgroundValidationPolicy = foregroundValidationPolicy | UnparentAllTiles;
     449
     450    revalidateTiles(foregroundValidationPolicy, backgroundValidationPolicy);
    444451}
    445452
    … …  
    532539}
    533540
    534 void TileCache::revalidateTiles(TileValidationPolicy validationPolicy)
     541void TileCache::revalidateTiles(TileValidationPolicyFlags foregroundValidationPolicy, TileValidationPolicyFlags backgroundValidationPolicy)
    535542{
    536543    // If the underlying PlatformLayer has been destroyed, but the WebTileCacheLayer hasn't
    … …  
    542549    if (m_visibleRect.isEmpty() || bounds().isEmpty())
    543550        return;
    544 
    545     // If the visible rect size changed, drop secondary tiles to avoid lots of repainting.
    546     // FIXME: when scaled, this changes due to rounding. We should use FloatRects or something.
    547     // Also changes on rubber banding.
    548     if (m_visibleRectAtLastRevalidate.size() != m_visibleRect.size())
    549         validationPolicy = PruneSecondaryTiles;
     551   
     552    TileValidationPolicyFlags validationPolicy = m_isInWindow ? foregroundValidationPolicy : backgroundValidationPolicy;
    550553   
    551554    IntRect tileCoverageRect = computeTileCoverageRect(m_visibleRectAtLastRevalidate);
    … …  
    584587                    tileInfo.cohort = currCohort;
    585588                    ++tilesInCohort;
     589                    [tileInfo.layer.get() removeFromSuperlayer];
    586590                }
    587591            }
    … …  
    591595            startedNewCohort(currCohort);
    592596
    593         scheduleCohortRemoval();
     597        if (!m_aggressivelyRetainsTiles)
     598            scheduleCohortRemoval();
    594599    }
    595600
    … …  
    602607    // Ensure primary tile coverage tiles.
    603608    m_primaryTileCoverageRect = IntRect();
    604    
     609
    605610    for (int y = topLeft.y(); y <= bottomRight.y(); ++y) {
    606611        for (int x = topLeft.x(); x <= bottomRight.x(); ++x) {
    … …  
    613618            if (!tileInfo.layer) {
    614619                tileInfo.layer = createTileLayer(tileRect);
    615                 [m_tileContainerLayer.get() addSublayer:tileInfo.layer.get()];
     620                if (m_isInWindow)
     621                    [m_tileContainerLayer.get() addSublayer:tileInfo.layer.get()];
    616622            } else {
     623                if (m_isInWindow && ![tileInfo.layer.get() superlayer])
     624                    [m_tileContainerLayer.get() addSublayer:tileInfo.layer.get()];
     625
    617626                // We already have a layer for this tile. Ensure that its size is correct.
    618627                FloatSize tileLayerSize([tileInfo.layer.get() frame].size);
    … …  
    629638    }
    630639
    631     if (validationPolicy == PruneSecondaryTiles) {
     640    if (validationPolicy & PruneSecondaryTiles) {
    632641        removeAllSecondaryTiles();
    633642        m_cohortList.clear();
    634643    }
     644
     645    if (validationPolicy & UnparentAllTiles) {
     646        for (TileMap::iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it)
     647            [it->value.layer.get() removeFromSuperlayer];
     648    }
    635649   
    636650    if (m_tiledScrollingIndicatorLayer)
    … …  
    670684{
    671685    const double cohortRemovalTimerSeconds = 1;
    672    
     686
    673687    // Start the timer, or reschedule the timer from now if it's already active.
    674688    if (!m_cohortRemovalTimer.isActive())
    … …  
    685699    double cohortLifeTimeSeconds = 2;
    686700    double timeThreshold = monotonicallyIncreasingTime() - cohortLifeTimeSeconds;
    687    
     701
    688702    while (!m_cohortList.isEmpty() && m_cohortList.first().creationTime < timeThreshold) {
    689703        TileCohortInfo firstCohort = m_cohortList.takeFirst();
    … …  
    697711void TileCache::ensureTilesForRect(const IntRect& rect)
    698712{
     713    if (!m_isInWindow)
     714        return;
     715
    699716    PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);
    700717    if (!platformLayer)
    … …  
    726743                [m_tileContainerLayer.get() addSublayer:tileInfo.layer.get()];
    727744            } else {
     745                if (![tileInfo.layer.get() superlayer])
     746                    [m_tileContainerLayer.get() addSublayer:tileInfo.layer.get()];
     747
    728748                // We already have a layer for this tile. Ensure that its size is correct.
    729749                CGSize tileLayerSize = [tileInfo.layer.get() frame].size;
    … …  
    934954
    935955    CGFloat scaleFactor = layerBounds.size.width / bounds().width();
    936    
    937     CGContextSetRGBStrokeColor(context, 0, 0, 0, 1);
    938956
    939957    CGFloat contextScale = scaleFactor / scale();
    940958    CGContextScaleCTM(context, contextScale, contextScale);
    941 
    942     CGContextSetLineWidth(context, 0.5 / contextScale);
    943959   
    944960    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {
    945961        const TileInfo& tileInfo = it->value;
    946962        WebTileLayer* tileLayer = tileInfo.layer.get();
    947        
     963
    948964        CGFloat red = 1;
    949965        CGFloat green = 1;
    … …  
    954970            blue = 0;
    955971        }
    956        
     972
    957973        TileCohort newestCohort = newestTileCohort();
    958974        TileCohort oldestCohort = oldestTileCohort();
    959        
    960         if (tileInfo.cohort != VisibleTileCohort && newestCohort > oldestCohort) {
     975
     976        if (!m_aggressivelyRetainsTiles && tileInfo.cohort != VisibleTileCohort && newestCohort > oldestCohort) {
    961977            float cohortProportion = static_cast<float>((newestCohort - tileInfo.cohort)) / (newestCohort - oldestCohort);
    962978            CGContextSetRGBFillColor(context, red, green, blue, 1 - cohortProportion);
    … …  
    964980            CGContextSetRGBFillColor(context, red, green, blue, 1);
    965981
     982        if ([tileLayer superlayer]) {
     983            CGContextSetLineWidth(context, 0.5 / contextScale);
     984            CGContextSetRGBStrokeColor(context, 0, 0, 0, 1);
     985        } else {
     986            CGContextSetLineWidth(context, 1 / contextScale);
     987            CGContextSetRGBStrokeColor(context, 0.2, 0.1, 0.9, 1);
     988        }
     989
    966990        CGRect frame = [tileLayer frame];
    967991        CGContextFillRect(context, frame);

  • trunk/Source/WebKit2/ChangeLog

    r138845 r138858  
     12013-01-04  Tim Horton  <timothy_horton@apple.com>
     2
     3        [wk2] Remove non-visible tiles from the layer tree
     4        https://bugs.webkit.org/show_bug.cgi?id=106061
     5        <rdar://problem/12761821>
     6
     7        Reviewed by Simon Fraser.
     8
     9        Add a setting to enable aggressive retention of TileCache tiles. If enabled,
     10        TileCache will generally try to keep around all tiles. This setting is off by default.
     11
     12        * Shared/WebPreferencesStore.h:
     13        * UIProcess/API/C/WKPreferences.cpp:
     14        (WKPreferencesSetAggressiveTileRetentionEnabled):
     15        (WKPreferencesGetAggressiveTileRetentionEnabled):
     16        * UIProcess/API/C/WKPreferencesPrivate.h:
     17        * WebProcess/WebPage/WebPage.cpp:
     18        (WebKit::WebPage::updatePreferences):
     19        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:
     20        (WebKit::TiledCoreAnimationDrawingArea::updatePreferences): Forward the setting to the TiledBacking.
     21
    1222013-01-04  Sam Weinig  <sam@webkit.org>
    223

  • trunk/Source/WebKit2/Shared/WebPreferencesStore.h

    r136594 r138858  
    143143    macro(UsesEncodingDetector, usesEncodingDetector, Bool, bool, false) \
    144144    macro(TextAutosizingEnabled, textAutosizingEnabled, Bool, bool, false) \
     145    macro(AggressiveTileRetentionEnabled, aggressiveTileRetentionEnabled, Bool, bool, false) \
    145146    \
    146147

  • trunk/Source/WebKit2/UIProcess/API/C/WKPreferences.cpp

    r136594 r138858  
    995995}
    996996
     997void WKPreferencesSetAggressiveTileRetentionEnabled(WKPreferencesRef preferencesRef, bool enabled)
     998{
     999    toImpl(preferencesRef)->setAggressiveTileRetentionEnabled(enabled);
     1000}
     1001
     1002bool WKPreferencesGetAggressiveTileRetentionEnabled(WKPreferencesRef preferencesRef)
     1003{
     1004    return toImpl(preferencesRef)->aggressiveTileRetentionEnabled();
     1005}

  • trunk/Source/WebKit2/UIProcess/API/C/WKPreferencesPrivate.h

    r136594 r138858  
    236236WK_EXPORT bool WKPreferencesGetPDFPluginEnabled(WKPreferencesRef preferences);
    237237
     238// Defaults to false
     239WK_EXPORT void WKPreferencesSetAggressiveTileRetentionEnabled(WKPreferencesRef preferences, bool enabled);
     240WK_EXPORT bool WKPreferencesGetAggressiveTileRetentionEnabled(WKPreferencesRef preferences);
     241
    238242WK_EXPORT void WKPreferencesResetTestRunnerOverrides(WKPreferencesRef preferencesRef);
    239243

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r138791 r138858  
    23252325    settings->setShowRepaintCounter(store.getBoolValueForKey(WebPreferencesKey::compositingRepaintCountersVisibleKey()));
    23262326    settings->setShowTiledScrollingIndicator(store.getBoolValueForKey(WebPreferencesKey::tiledScrollingIndicatorVisibleKey()));
     2327    settings->setAggressiveTileRetentionEnabled(store.getBoolValueForKey(WebPreferencesKey::aggressiveTileRetentionEnabledKey()));
    23272328    settings->setCSSCustomFilterEnabled(store.getBoolValueForKey(WebPreferencesKey::cssCustomFilterEnabledKey()));
    23282329    RuntimeEnabledFeatures::setCSSRegionsEnabled(store.getBoolValueForKey(WebPreferencesKey::cssRegionsEnabledKey()));

  • trunk/Source/WebKit2/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm

    r136594 r138858  
    210210    ScrollingThread::dispatch(bind(&ScrollingTree::setScrollingPerformanceLoggingEnabled, m_webPage->corePage()->scrollingCoordinator()->scrollingTree(), scrollingPerformanceLoggingEnabled));
    211211
     212    if (TiledBacking* tiledBacking = mainFrameTiledBacking())
     213        tiledBacking->setAggressivelyRetainsTiles(m_webPage->corePage()->settings()->aggressiveTileRetentionEnabled());
     214
    212215    // Soon we want pages with fixed positioned elements to be able to be scrolled by the ScrollingCoordinator.
    213216    // As a part of that work, we have to composite fixed position elements, and we have to allow those
    … …  
    447450    if (m_pageOverlayLayer)
    448451        [m_rootLayer.get() addSublayer:m_pageOverlayLayer->platformLayer()];
     452
     453    if (TiledBacking* tiledBacking = mainFrameTiledBacking())
     454        tiledBacking->setAggressivelyRetainsTiles(m_webPage->corePage()->settings()->aggressiveTileRetentionEnabled());
    449455
    450456    updateDebugInfoLayer(m_webPage->corePage()->settings()->showTiledScrollingIndicator());
Note: See TracChangeset for help on using the changeset viewer.