Changeset 122658 in webkit


Ignore:
Timestamp:
Jul 13, 2012 8:05:06 PM (12 years ago)
Author:
commit-queue@webkit.org
Message:

[chromium] Add 'self-managed' option to CCPrioritizedTexture to enable render-surface and canvas use cases.
​https://bugs.webkit.org/show_bug.cgi?id=91177

Patch by Eric Penner <​epenner@google.com> on 2012-07-13
Reviewed by Adrienne Walker.

Source/WebCore:

This makes the render-surface memory use case generic as 'self-managed' textures,
as this use case is popping up in other places (eg. canvases). It's exactly the
same idea except we can have as many place-holders as we want at arbitrary
priorities.

This already tested by the render surface unit tests which now also use the
generic placeholder.

  • platform/graphics/chromium/cc/CCLayerTreeHost.cpp:

(WebCore::CCLayerTreeHost::CCLayerTreeHost):
(WebCore::CCLayerTreeHost::initializeLayerRenderer):
(WebCore::CCLayerTreeHost::updateLayers):
(WebCore::CCLayerTreeHost::setPrioritiesForSurfaces):
(WebCore):
(WebCore::CCLayerTreeHost::setPrioritiesForLayers):
(WebCore::CCLayerTreeHost::prioritizeTextures):
(WebCore::CCLayerTreeHost::calculateMemoryForRenderSurfaces):
(WebCore::CCLayerTreeHost::paintLayerContents):

  • platform/graphics/chromium/cc/CCLayerTreeHost.h:

(CCLayerTreeHost):

  • platform/graphics/chromium/cc/CCPrioritizedTexture.cpp:

(WebCore::CCPrioritizedTexture::CCPrioritizedTexture):
(WebCore::CCPrioritizedTexture::setToSelfManagedMemoryPlaceholder):

  • platform/graphics/chromium/cc/CCPrioritizedTexture.h:

(CCPrioritizedTexture):
(WebCore::CCPrioritizedTexture::setIsSelfManaged):
(WebCore::CCPrioritizedTexture::isSelfManaged):

  • platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp:

(WebCore::CCPrioritizedTextureManager::prioritizeTextures):
(WebCore::CCPrioritizedTextureManager::acquireBackingTextureIfNeeded):
(WebCore::CCPrioritizedTextureManager::destroyBacking):

  • platform/graphics/chromium/cc/CCPrioritizedTextureManager.h:

(CCPrioritizedTextureManager):
(WebCore::CCPrioritizedTextureManager::memoryForSelfManagedTextures):

Source/WebKit/chromium:

  • tests/CCPrioritizedTextureTest.cpp:

(WTF::TEST_F):

  • tests/TiledLayerChromiumTest.cpp:
Location:
trunk/Source
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r122656 r122658  
     12012-07-13  Eric Penner  <epenner@google.com>
     2
     3        [chromium] Add 'self-managed' option to CCPrioritizedTexture to enable render-surface and canvas use cases.
     4        https://bugs.webkit.org/show_bug.cgi?id=91177
     5
     6        Reviewed by Adrienne Walker.
     7
     8        This makes the render-surface memory use case generic as 'self-managed' textures,
     9        as this use case is popping up in other places (eg. canvases). It's exactly the
     10        same idea except we can have as many place-holders as we want at arbitrary
     11        priorities.
     12
     13        This already tested by the render surface unit tests which now also use the
     14        generic placeholder.
     15
     16        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
     17        (WebCore::CCLayerTreeHost::CCLayerTreeHost):
     18        (WebCore::CCLayerTreeHost::initializeLayerRenderer):
     19        (WebCore::CCLayerTreeHost::updateLayers):
     20        (WebCore::CCLayerTreeHost::setPrioritiesForSurfaces):
     21        (WebCore):
     22        (WebCore::CCLayerTreeHost::setPrioritiesForLayers):
     23        (WebCore::CCLayerTreeHost::prioritizeTextures):
     24        (WebCore::CCLayerTreeHost::calculateMemoryForRenderSurfaces):
     25        (WebCore::CCLayerTreeHost::paintLayerContents):
     26        * platform/graphics/chromium/cc/CCLayerTreeHost.h:
     27        (CCLayerTreeHost):
     28        * platform/graphics/chromium/cc/CCPrioritizedTexture.cpp:
     29        (WebCore::CCPrioritizedTexture::CCPrioritizedTexture):
     30        (WebCore::CCPrioritizedTexture::setToSelfManagedMemoryPlaceholder):
     31        * platform/graphics/chromium/cc/CCPrioritizedTexture.h:
     32        (CCPrioritizedTexture):
     33        (WebCore::CCPrioritizedTexture::setIsSelfManaged):
     34        (WebCore::CCPrioritizedTexture::isSelfManaged):
     35        * platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp:
     36        (WebCore::CCPrioritizedTextureManager::prioritizeTextures):
     37        (WebCore::CCPrioritizedTextureManager::acquireBackingTextureIfNeeded):
     38        (WebCore::CCPrioritizedTextureManager::destroyBacking):
     39        * platform/graphics/chromium/cc/CCPrioritizedTextureManager.h:
     40        (CCPrioritizedTextureManager):
     41        (WebCore::CCPrioritizedTextureManager::memoryForSelfManagedTextures):
     42
    1432012-07-13  Kent Tamura  <tkent@chromium.org>
    244

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp

    r122506 r122658  
    153153
    154154    m_contentsTextureManager = CCPrioritizedTextureManager::create(0, m_proxy->layerRendererCapabilities().maxTextureSize);
     155    m_surfaceMemoryPlaceholder = m_contentsTextureManager->createTexture(IntSize(), GraphicsContext3D::RGBA);
    155156
    156157    m_layerRendererInitialized = true;
    … …  
    490491    m_partialTextureUpdateRequests = 0;
    491492
    492     prioritizeTextures(updateList);
    493 
    494493    bool needMoreUpdates = paintLayerContents(updateList, updater);
    495494    if (m_triggerIdleUpdates && needMoreUpdates)
    … …  
    500499}
    501500
    502 void CCLayerTreeHost::prioritizeTextures(const LayerList& updateList)
     501void CCLayerTreeHost::setPrioritiesForSurfaces(size_t surfaceMemoryBytes)
     502{
     503    // Surfaces have a place holder for their memory since they are managed
     504    // independantly but should still be tracked and reduce other memory usage.
     505    m_surfaceMemoryPlaceholder->setTextureManager(m_contentsTextureManager.get());
     506    m_surfaceMemoryPlaceholder->setRequestPriority(CCPriorityCalculator::renderSurfacePriority());
     507    m_surfaceMemoryPlaceholder->setToSelfManagedMemoryPlaceholder(surfaceMemoryBytes);
     508}
     509
     510void CCLayerTreeHost::setPrioritiesForLayers(const LayerList& updateList)
    503511{
    504512    // Use BackToFront since it's cheap and this isn't order-dependent.
    505513    typedef CCLayerIterator<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, CCLayerIteratorActions::BackToFront> CCLayerIteratorType;
    506 
    507     m_contentsTextureManager->clearPriorities();
    508514
    509515    CCPriorityCalculator calculator;
    … …  
    519525        }
    520526    }
    521 
     527}
     528
     529void CCLayerTreeHost::prioritizeTextures(const LayerList& renderSurfaceLayerList, CCOverdrawMetrics& metrics)
     530{
     531    m_contentsTextureManager->clearPriorities();
     532
     533    size_t memoryForRenderSurfacesMetric = calculateMemoryForRenderSurfaces(renderSurfaceLayerList);
     534
     535    setPrioritiesForLayers(renderSurfaceLayerList);
     536    setPrioritiesForSurfaces(memoryForRenderSurfacesMetric);
     537
     538    metrics.didUseContentsTextureMemoryBytes(m_contentsTextureManager->memoryAboveCutoffBytes());
     539    metrics.didUseRenderSurfaceTextureMemoryBytes(memoryForRenderSurfacesMetric);
     540
     541    m_contentsTextureManager->prioritizeTextures();
     542}
     543
     544size_t CCLayerTreeHost::calculateMemoryForRenderSurfaces(const LayerList& updateList)
     545{
    522546    size_t readbackBytes = 0;
    523547    size_t maxBackgroundTextureBytes = 0;
    … …  
    540564            readbackBytes = CCTexture::memorySizeBytes(m_deviceViewportSize, GraphicsContext3D::RGBA);
    541565    }
    542     size_t renderSurfacesBytes = readbackBytes + maxBackgroundTextureBytes + contentsTextureBytes;
    543 
    544     m_contentsTextureManager->prioritizeTextures(renderSurfacesBytes);
     566    return readbackBytes + maxBackgroundTextureBytes + contentsTextureBytes;
    545567}
    546568
    … …  
    575597    CCOcclusionTracker occlusionTracker(IntRect(IntPoint(), deviceViewportSize()), recordMetricsForFrame);
    576598    occlusionTracker.setMinimumTrackingSize(m_settings.minimumOcclusionTrackingSize);
     599
     600    prioritizeTextures(renderSurfaceLayerList, occlusionTracker.overdrawMetrics());
    577601
    578602    CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
    … …  
    592616    }
    593617
    594     occlusionTracker.overdrawMetrics().didUseContentsTextureMemoryBytes(m_contentsTextureManager->memoryAboveCutoffBytes());
    595     occlusionTracker.overdrawMetrics().didUseRenderSurfaceTextureMemoryBytes(m_contentsTextureManager->memoryForRenderSurfacesBytes());
    596618    occlusionTracker.overdrawMetrics().recordMetrics(this);
    597619

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h

    r122506 r122658  
    286286    void updateLayers(LayerChromium*, CCTextureUpdater&);
    287287
    288     void prioritizeTextures(const LayerList& updateList);
     288    void prioritizeTextures(const LayerList&, CCOverdrawMetrics&);
     289    void setPrioritiesForSurfaces(size_t surfaceMemoryBytes);
     290    void setPrioritiesForLayers(const LayerList&);
     291    size_t calculateMemoryForRenderSurfaces(const LayerList& updateList);
    289292
    290293    void animateLayers(double monotonicTime);
    … …  
    310313    RefPtr<LayerChromium> m_rootLayer;
    311314    OwnPtr<CCPrioritizedTextureManager> m_contentsTextureManager;
     315    OwnPtr<CCPrioritizedTexture> m_surfaceMemoryPlaceholder;
    312316
    313317    CCLayerTreeSettings m_settings;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.cpp

    r122506 r122658  
    4343    , m_priority(CCPriorityCalculator::lowestPriority())
    4444    , m_isAbovePriorityCutoff(false)
     45    , m_isSelfManaged(false)
    4546    , m_backing(0)
    4647    , m_manager(0)
    … …  
    151152}
    152153
    153 
     154void CCPrioritizedTexture::setToSelfManagedMemoryPlaceholder(size_t bytes)
     155{
     156    setDimensions(IntSize(), GraphicsContext3D::RGBA);
     157    setIsSelfManaged(true);
     158    m_bytes = bytes;
     159}
    154160
    155161} // namespace WebCore

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTexture.h

    r122506 r122658  
    9494    unsigned textureId();
    9595
     96    // Self-managed textures are accounted for when prioritizing other textures,
     97    // but they are not allocated/recycled/deleted, so this needs to be done
     98    // externally. canAcquireBackingTexture() indicates if the texture would have
     99    // been allowed given its priority.
     100    void setIsSelfManaged(bool isSelfManaged) { m_isSelfManaged = isSelfManaged; }
     101    bool isSelfManaged() { return m_isSelfManaged; }
     102    void setToSelfManagedMemoryPlaceholder(size_t bytes);
     103
    96104private:
    97105    friend class CCPrioritizedTextureManager;
    … …  
    126134    size_t m_priority;
    127135    bool m_isAbovePriorityCutoff;
     136    bool m_isSelfManaged;
    128137
    129138    Backing* m_backing;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.cpp

    r122506 r122658  
    5656}
    5757
    58 void CCPrioritizedTextureManager::prioritizeTextures(size_t renderSurfacesMemoryBytes)
     58void CCPrioritizedTextureManager::prioritizeTextures()
    5959{
    6060    TRACE_EVENT0("cc", "CCPrioritizedTextureManager::prioritizeTextures");
    … …  
    8080    m_memoryAvailableBytes = m_maxMemoryLimitBytes;
    8181    m_priorityCutoff = CCPriorityCalculator::lowestPriority();
    82     bool reservedRenderSurfaces = false;
    8382    size_t memoryBytes = 0;
    8483    for (TextureVector::iterator it = sortedTextures.begin(); it != sortedTextures.end(); ++it) {
    … …  
    8685            break;
    8786
    88         // FIXME: We can make placeholder objects similar to textures to represent the render surface memory request.
    89         if (!reservedRenderSurfaces && CCPriorityCalculator::priorityIsLower((*it)->requestPriority(), CCPriorityCalculator::renderSurfacePriority())) {
    90             size_t newMemoryBytes = memoryBytes + renderSurfacesMemoryBytes;
     87        if ((*it)->isSelfManaged()) {
     88            // Account for self-managed memory immediately by reducing the memory
     89            // available (since it never gets acquired).
     90            size_t newMemoryBytes = memoryBytes + (*it)->bytes();
    9191            if (newMemoryBytes > m_memoryAvailableBytes) {
    9292                m_priorityCutoff = (*it)->requestPriority();
    … …  
    9494                break;
    9595            }
    96             m_memoryAvailableBytes -= renderSurfacesMemoryBytes;
    97             reservedRenderSurfaces = true;
     96            m_memoryAvailableBytes -= (*it)->bytes();
     97        } else {
     98            size_t newMemoryBytes = memoryBytes + (*it)->bytes();
     99            if (newMemoryBytes > m_memoryAvailableBytes) {
     100                m_priorityCutoff = (*it)->requestPriority();
     101                break;
     102            }
     103            memoryBytes = newMemoryBytes;
    98104        }
    99 
    100         size_t newMemoryBytes = memoryBytes + (*it)->bytes();
    101         if (newMemoryBytes > m_memoryAvailableBytes) {
    102             m_priorityCutoff = (*it)->requestPriority();
    103             break;
    104         }
    105 
    106         memoryBytes = newMemoryBytes;
    107105    }
    108106
    … …  
    114112        bool isAbovePriorityCutoff = CCPriorityCalculator::priorityIsHigher((*it)->requestPriority(), m_priorityCutoff);
    115113        (*it)->setAbovePriorityCutoff(isAbovePriorityCutoff);
    116         if (isAbovePriorityCutoff)
     114        if (isAbovePriorityCutoff && !(*it)->isSelfManaged())
    117115            m_memoryAboveCutoffBytes += (*it)->bytes();
    118116    }
    … …  
    173171void CCPrioritizedTextureManager::acquireBackingTextureIfNeeded(CCPrioritizedTexture* texture, TextureAllocator* allocator)
    174172{
     173    ASSERT(!texture->isSelfManaged());
    175174    ASSERT(texture->isAbovePriorityCutoff());
    176175    if (texture->backing() || !texture->isAbovePriorityCutoff())
    … …  
    308307    ASSERT(backing);
    309308    ASSERT(!backing->owner() || !backing->owner()->isAbovePriorityCutoff());
     309    ASSERT(!backing->owner() || !backing->owner()->isSelfManaged());
    310310    ASSERT(m_backings.find(backing) != m_backings.end());
    311311

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCPrioritizedTextureManager.h

    r122506 r122658  
    6464    size_t memoryUseBytes() const { return m_memoryUseBytes; }
    6565    size_t memoryAboveCutoffBytes() const { return m_memoryAboveCutoffBytes; }
    66     size_t memoryForRenderSurfacesBytes() const { return m_maxMemoryLimitBytes - m_memoryAvailableBytes; }
     66    size_t memoryForSelfManagedTextures() const { return m_maxMemoryLimitBytes - m_memoryAvailableBytes; }
    6767
    6868    void setMaxMemoryLimitBytes(size_t bytes) { m_maxMemoryLimitBytes = bytes; }
    6969    size_t maxMemoryLimitBytes() const { return m_maxMemoryLimitBytes; }
    7070
    71     void prioritizeTextures(size_t renderSurfacesMemoryBytes);
     71    void prioritizeTextures();
    7272    void clearPriorities();
    7373

  • trunk/Source/WebKit/chromium/ChangeLog

    r122654 r122658  
     12012-07-13  Eric Penner  <epenner@google.com>
     2
     3        [chromium] Add 'self-managed' option to CCPrioritizedTexture to enable render-surface and canvas use cases.
     4        https://bugs.webkit.org/show_bug.cgi?id=91177
     5
     6        Reviewed by Adrienne Walker.
     7
     8        * tests/CCPrioritizedTextureTest.cpp:
     9        (WTF::TEST_F):
     10        * tests/TiledLayerChromiumTest.cpp:
     11
    1122012-07-13  Brian Anderson  <brianderson@chromium.org>
    213

  • trunk/Source/WebKit/chromium/tests/CCPrioritizedTextureTest.cpp

    r122506 r122658  
    100100
    101101    // Only lower half should be available.
    102     textureManager->prioritizeTextures(0);
     102    textureManager->prioritizeTextures();
    103103    EXPECT_TRUE(validateTexture(textures[0], false));
    104104    EXPECT_TRUE(validateTexture(textures[7], false));
    … …  
    111111
    112112    // Only upper half should be available.
    113     textureManager->prioritizeTextures(0);
     113    textureManager->prioritizeTextures();
    114114    EXPECT_FALSE(validateTexture(textures[0], false));
    115115    EXPECT_FALSE(validateTexture(textures[7], false));
    … …  
    136136    // Set max limit to 8 textures
    137137    textureManager->setMaxMemoryLimitBytes(texturesMemorySize(8));
    138     textureManager->prioritizeTextures(0);
     138    textureManager->prioritizeTextures();
    139139    for (size_t i = 0; i < maxTextures; ++i)
    140140        validateTexture(textures[i], false);
    … …  
    146146    // Set max limit to 5 textures
    147147    textureManager->setMaxMemoryLimitBytes(texturesMemorySize(5));
    148     textureManager->prioritizeTextures(0);
     148    textureManager->prioritizeTextures();
    149149    for (size_t i = 0; i < maxTextures; ++i)
    150150        EXPECT_EQ(validateTexture(textures[i], false), i < 5);
    … …  
    156156    // Set max limit to 4 textures
    157157    textureManager->setMaxMemoryLimitBytes(texturesMemorySize(4));
    158     textureManager->prioritizeTextures(0);
     158    textureManager->prioritizeTextures();
    159159    for (size_t i = 0; i < maxTextures; ++i)
    160160        EXPECT_EQ(validateTexture(textures[i], false), i < 4);
    … …  
    182182    for (size_t i = 0; i < numTextures; ++i)
    183183        textures[i]->setRequestPriority(200 + i);
    184     textureManager->prioritizeTextures(0);
     184    textureManager->prioritizeTextures();
    185185
    186186    // Allocate textures which are currently high priority.
    … …  
    197197    for (size_t i = 0; i < numTextures; ++i)
    198198        moreTextures[i]->setRequestPriority(100 + i);
    199     textureManager->prioritizeTextures(0);
     199    textureManager->prioritizeTextures();
    200200
    201201    // Textures are now below cutoff.
    … …  
    243243    // Set max limit to 8 textures
    244244    textureManager->setMaxMemoryLimitBytes(texturesMemorySize(8));
    245     textureManager->prioritizeTextures(0);
     245    textureManager->prioritizeTextures();
    246246
    247247    // The two high priority textures should be available, others should not.
    … …  
    274274
    275275    texture->setRequestPriority(100);
    276     textureManager->prioritizeTextures(0);
     276    textureManager->prioritizeTextures();
    277277
    278278    EXPECT_TRUE(validateTexture(texture, false));
    … …  
    297297
    298298    texture->setRequestPriority(100);
    299     textureManagerOne->prioritizeTextures(0);
     299    textureManagerOne->prioritizeTextures();
    300300
    301301    EXPECT_TRUE(validateTexture(texture, false));
    … …  
    313313    texture->setTextureManager(textureManagerTwo.get());
    314314
    315     textureManagerTwo->prioritizeTextures(0);
     315    textureManagerTwo->prioritizeTextures();
    316316
    317317    EXPECT_TRUE(validateTexture(texture, false));
    … …  
    327327    OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
    328328
    329     // Half of the memory is taken by surfaces.
    330     const size_t renderSurfacesBytes = texturesMemorySize(4);
     329    // Half of the memory is taken by surfaces (with high priority place-holder)
     330    OwnPtr<CCPrioritizedTexture> renderSurfacePlaceHolder = textureManager->createTexture(m_textureSize, m_textureFormat);
     331    renderSurfacePlaceHolder->setToSelfManagedMemoryPlaceholder(texturesMemorySize(4));
     332    renderSurfacePlaceHolder->setRequestPriority(CCPriorityCalculator::renderSurfacePriority());
    331333
    332334    // Create textures to fill our memory limit.
    … …  
    341343
    342344    // Only lower half should be available.
    343     textureManager->prioritizeTextures(renderSurfacesBytes);
     345    textureManager->prioritizeTextures();
    344346    EXPECT_TRUE(validateTexture(textures[0], false));
    345347    EXPECT_TRUE(validateTexture(textures[3], false));
    … …  
    352354
    353355    // Only upper half should be available.
    354     textureManager->prioritizeTextures(renderSurfacesBytes);
     356    textureManager->prioritizeTextures();
    355357    EXPECT_FALSE(validateTexture(textures[0], false));
    356358    EXPECT_FALSE(validateTexture(textures[3], false));
    … …  
    359361
    360362    EXPECT_EQ(texturesMemorySize(4), textureManager->memoryAboveCutoffBytes());
    361     EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForRenderSurfacesBytes());
     363    EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForSelfManagedTextures());
    362364    EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
    363365
    … …  
    370372    OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
    371373
    372     // Half of the memory is taken by surfaces.
    373     const size_t renderSurfacesBytes = texturesMemorySize(4);
     374    // Half of the memory is taken by surfaces (with high priority place-holder)
     375    OwnPtr<CCPrioritizedTexture> renderSurfacePlaceHolder = textureManager->createTexture(m_textureSize, m_textureFormat);
     376    renderSurfacePlaceHolder->setToSelfManagedMemoryPlaceholder(texturesMemorySize(4));
     377    renderSurfacePlaceHolder->setRequestPriority(CCPriorityCalculator::renderSurfacePriority());
    374378
    375379    // Create textures to fill our memory limit.
    … …  
    384388
    385389    // The first four to be requested late will be available.
    386     textureManager->prioritizeTextures(renderSurfacesBytes);
     390    textureManager->prioritizeTextures();
    387391    for (unsigned i = 0; i < maxTextures; ++i)
    388392        EXPECT_FALSE(validateTexture(textures[i], false));
    … …  
    393397
    394398    EXPECT_EQ(texturesMemorySize(4), textureManager->memoryAboveCutoffBytes());
    395     EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForRenderSurfacesBytes());
     399    EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForSelfManagedTextures());
    396400    EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
    397401
    … …  
    404408    OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
    405409
    406     // Half of the memory is taken by surfaces.
    407     const size_t renderSurfacesBytes = texturesMemorySize(4);
     410    // Half of the memory is taken by surfaces (with high priority place-holder)
     411    OwnPtr<CCPrioritizedTexture> renderSurfacePlaceHolder = textureManager->createTexture(m_textureSize, m_textureFormat);
     412    renderSurfacePlaceHolder->setToSelfManagedMemoryPlaceholder(texturesMemorySize(4));
     413    renderSurfacePlaceHolder->setRequestPriority(CCPriorityCalculator::renderSurfacePriority());
    408414
    409415    // Create textures to fill our memory limit.
    … …  
    419425        textures[i]->setRequestPriority(CCPriorityCalculator::visiblePriority(false));
    420426
    421     textureManager->prioritizeTextures(renderSurfacesBytes);
     427    textureManager->prioritizeTextures();
    422428
    423429    // Unable to requestLate textures in the child surface.
    … …  
    430436
    431437    EXPECT_EQ(texturesMemorySize(6), textureManager->memoryAboveCutoffBytes());
    432     EXPECT_EQ(texturesMemorySize(2), textureManager->memoryForRenderSurfacesBytes());
     438    EXPECT_EQ(texturesMemorySize(2), textureManager->memoryForSelfManagedTextures());
    433439    EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
    434440

  • trunk/Source/WebKit/chromium/tests/TiledLayerChromiumTest.cpp

    r122373 r122658  
    106106
    107107    layer->setTexturePriorities(priorityCalculator);
    108     textureManager->prioritizeTextures(0);
     108    textureManager->prioritizeTextures();
    109109
    110110    layer->updateContentRect(updater, IntRect(0, 0, 100, 200), 0);
    … …  
    120120    // ....but then only update one of them.
    121121    layer->setTexturePriorities(priorityCalculator);
    122     textureManager->prioritizeTextures(0);
     122    textureManager->prioritizeTextures();
    123123    layer->updateContentRect(updater, IntRect(0, 0, 100, 100), 0);
    124124    layer->pushPropertiesTo(layerImpl.get());
    … …  
    145145
    146146    layer->setTexturePriorities(priorityCalculator);
    147     textureManager->prioritizeTextures(0);
     147    textureManager->prioritizeTextures();
    148148
    149149    layer->updateContentRect(updater, IntRect(0, 0, 100, 200), &occluded);
    … …  
    189189
    190190    layer->setTexturePriorities(priorityCalculator);
    191     textureManager->prioritizeTextures(0);
     191    textureManager->prioritizeTextures();
    192192
    193193    layer->updateContentRect(updater, IntRect(0, 0, 100, 200), 0);
    … …  
    212212    // This should recreate and update the deleted textures.
    213213    layer->setTexturePriorities(priorityCalculator);
    214     textureManager->prioritizeTextures(0);
     214    textureManager->prioritizeTextures();
    215215    layer->updateContentRect(updater, IntRect(0, 0, 100, 100), 0);
    216216    updateTextures();
    … …  
    240240
    241241    layer->setTexturePriorities(priorityCalculator);
    242     textureManager->prioritizeTextures(0);
     242    textureManager->prioritizeTextures();
    243243
    244244    layer->updateContentRect(updater, visibleRect, 0);
    … …  
    256256    for (int i = 0; i < 4; i++) {
    257257        layer->setTexturePriorities(priorityCalculator);
    258         textureManager->prioritizeTextures(0);
     258        textureManager->prioritizeTextures();
    259259
    260260        layer->updateContentRect(updater, visibleRect, 0);
    … …  
    308308    layer2->setTexturePriorities(priorityCalculator);
    309309    layer1->setTexturePriorities(priorityCalculator);
    310     textureManager->prioritizeTextures(0);
     310    textureManager->prioritizeTextures();
    311311    layer1->updateContentRect(updater, layerRect, 0);
    312312    layer2->updateContentRect(updater, IntRect(0, 0, 100, 100), 0);
    … …  
    326326    layer2->setTexturePriorities(priorityCalculator);
    327327    layer1->setTexturePriorities(priorityCalculator);
    328     textureManager->prioritizeTextures(0);
     328    textureManager->prioritizeTextures();
    329329    layer2->updateContentRect(updater, IntRect(0, 0, 100, 100), 0);
    330330
    … …  
    346346    layer2->setTexturePriorities(priorityCalculator);
    347347    layer1->setTexturePriorities(priorityCalculator);
    348     textureManager->prioritizeTextures(0);
     348    textureManager->prioritizeTextures();
    349349    layer2->updateContentRect(updater, layer2Rect, 0);
    350350    layer1->updateContentRect(updater, layerRect, 0);
    … …  
    379379
    380380    layer->setTexturePriorities(priorityCalculator);
    381     textureManager->prioritizeTextures(0);
     381    textureManager->prioritizeTextures();
    382382    layer->updateContentRect(updater, IntRect(0, 0, 100, 100), &occluded);
    383383    updateTextures();
    … …  
    404404
    405405    layer->setTexturePriorities(priorityCalculator);
    406     textureManager->prioritizeTextures(0);
     406    textureManager->prioritizeTextures();
    407407    layer->updateContentRect(updater, IntRect(0, 0, 100, 200), 0);
    408408    updateTextures();
    … …  
    433433    layer1->setTexturePriorities(priorityCalculator);
    434434    layer2->setTexturePriorities(priorityCalculator);
    435     textureManager->prioritizeTextures(0);
     435    textureManager->prioritizeTextures();
    436436
    437437    layer1->updateContentRect(updater, IntRect(0, 0, 100, 200), 0);
    … …  
    471471    layer1->setTexturePriorities(priorityCalculator);
    472472    layer2->setTexturePriorities(priorityCalculator);
    473     textureManager->prioritizeTextures(0);
     473    textureManager->prioritizeTextures();
    474474
    475475    // Invalidate a tile on layer2
    … …  
    509509
    510510    layer->setTexturePriorities(priorityCalculator);
    511     textureManager->prioritizeTextures(0);
     511    textureManager->prioritizeTextures();
    512512    layer->updateContentRect(updater, visibleRect, 0);
    513513
    … …  
    522522
    523523    layer->setTexturePriorities(priorityCalculator);
    524     textureManager->prioritizeTextures(0);
     524    textureManager->prioritizeTextures();
    525525    layer->updateContentRect(updater, visibleRect, 0);
    526526
    … …  
    549549
    550550        layer->setTexturePriorities(priorityCalculator);
    551         textureManager->prioritizeTextures(0);
     551        textureManager->prioritizeTextures();
    552552
    553553        // Empty layers don't paint or idle-paint.
    … …  
    587587        // Paint / idle-paint.
    588588        layer->setTexturePriorities(priorityCalculator);
    589         textureManager->prioritizeTextures(0);
     589        textureManager->prioritizeTextures();
    590590        layer->updateContentRect(updater, visibleRect, 0);
    591591
    … …  
    637637
    638638            layer->setTexturePriorities(priorityCalculator);
    639             textureManager->prioritizeTextures(0);
     639            textureManager->prioritizeTextures();
    640640
    641641            // If idlePaintRect gives back a non-empty result then we should paint it. Otherwise,
    … …  
    649649            for (int k = 0; k < 4; ++k) {
    650650                layer->setTexturePriorities(priorityCalculator);
    651                 textureManager->prioritizeTextures(0);
     651                textureManager->prioritizeTextures();
    652652
    653653                layer->updateContentRect(updater, visibleRect, 0);
    … …  
    662662            for (int k = 0; k < 4; ++k) {
    663663                layer->setTexturePriorities(priorityCalculator);
    664                 textureManager->prioritizeTextures(0);
     664                textureManager->prioritizeTextures();
    665665
    666666                layer->updateContentRect(updater, visibleRect, 0);
    … …  
    691691    layer->invalidateContentRect(IntRect(0, 0, 100, 200));
    692692    layer->setTexturePriorities(priorityCalculator);
    693     textureManager->prioritizeTextures(0);
     693    textureManager->prioritizeTextures();
    694694    layer->updateContentRect(updater, IntRect(0, 0, 100, 200), 0);
    695695    updater.update(ccContext.get(), &fakeAllocator, &fakeCopier, &fakeUploader, 1000);
    … …  
    741741
    742742    layer->setTexturePriorities(priorityCalculator);
    743     textureManager->prioritizeTextures(0);
     743    textureManager->prioritizeTextures();
    744744    layer->updateContentRect(updater, contentBounds, 0);
    745745    EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 300, 300 * 0.8), layer->updateRect());
    … …  
    748748    // After the tiles are updated once, another invalidate only needs to update the bounds of the layer.
    749749    layer->setTexturePriorities(priorityCalculator);
    750     textureManager->prioritizeTextures(0);
     750    textureManager->prioritizeTextures();
    751751    layer->invalidateContentRect(contentBounds);
    752752    layer->updateContentRect(updater, contentBounds, 0);
    … …  
    758758    layer->invalidateContentRect(partialDamage);
    759759    layer->setTexturePriorities(priorityCalculator);
    760     textureManager->prioritizeTextures(0);
     760    textureManager->prioritizeTextures();
    761761    layer->updateContentRect(updater, contentBounds, 0);
    762762    EXPECT_FLOAT_RECT_EQ(FloatRect(45, 80, 15, 8), layer->updateRect());
    … …  
    780780    // Push the tiles to the impl side and check that there is exactly one.
    781781    layer->setTexturePriorities(priorityCalculator);
    782     textureManager->prioritizeTextures(0);
     782    textureManager->prioritizeTextures();
    783783    layer->updateContentRect(updater, IntRect(0, 0, 100, 100), 0);
    784784    updateTextures();
    … …  
    797797    // The impl side should get 2x2 tiles now.
    798798    layer->setTexturePriorities(priorityCalculator);
    799     textureManager->prioritizeTextures(0);
     799    textureManager->prioritizeTextures();
    800800    layer->updateContentRect(updater, IntRect(0, 0, 200, 200), 0);
    801801    updateTextures();
    … …  
    811811    layer->setTexturePriorities(priorityCalculator);
    812812    layer->updateContentRect(updater, IntRect(1, 0, 0, 1), 0);
    813     textureManager->prioritizeTextures(0);
     813    textureManager->prioritizeTextures();
    814814
    815815    layer->pushPropertiesTo(layerImpl.get());
    … …  
    881881
    882882    layer->setTexturePriorities(priorityCalculator);
    883     textureManager->prioritizeTextures(0);
     883    textureManager->prioritizeTextures();
    884884    layer->updateContentRect(updater, IntRect(0, 0, 700, 700), 0);
    885885
    … …  
    900900    // Ensure no crash for bounds where size * size would overflow an int.
    901901    layer->setTexturePriorities(priorityCalculator);
    902     textureManager->prioritizeTextures(0);
     902    textureManager->prioritizeTextures();
    903903    layer->updateContentRect(updater, IntRect(0, 0, 700, 700), 0);
    904904}
    … …  
    10401040
    10411041    layer->setTexturePriorities(priorityCalculator);
    1042     textureManager->prioritizeTextures(0);
     1042    textureManager->prioritizeTextures();
    10431043    layer->updateContentRect(updater, IntRect(0, 0, 100, 200), 0);
    10441044    EXPECT_EQ(2, layer->fakeLayerTextureUpdater()->prepareRectCount());
    … …  
    10611061
    10621062    layer->setTexturePriorities(priorityCalculator);
    1063     textureManager->prioritizeTextures(0);
     1063    textureManager->prioritizeTextures();
    10641064    layer->updateContentRect(updater, IntRect(0, 0, 600, 600), &occluded);
    10651065    EXPECT_EQ(36-3, layer->fakeLayerTextureUpdater()->prepareRectCount());
    … …  
    11091109
    11101110    layer->setTexturePriorities(priorityCalculator);
    1111     textureManager->prioritizeTextures(0);
     1111    textureManager->prioritizeTextures();
    11121112    layer->updateContentRect(updater, IntRect(0, 0, 600, 360), &occluded);
    11131113    EXPECT_EQ(24-3, layer->fakeLayerTextureUpdater()->prepareRectCount());
    … …  
    11241124    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    11251125    layer->setTexturePriorities(priorityCalculator);
    1126     textureManager->prioritizeTextures(0);
     1126    textureManager->prioritizeTextures();
    11271127    layer->updateContentRect(updater, IntRect(0, 0, 600, 350), &occluded);
    11281128    EXPECT_EQ(24-6, layer->fakeLayerTextureUpdater()->prepareRectCount());
    … …  
    11391139    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    11401140    layer->setTexturePriorities(priorityCalculator);
    1141     textureManager->prioritizeTextures(0);
     1141    textureManager->prioritizeTextures();
    11421142    layer->updateContentRect(updater, IntRect(0, 0, 600, 340), &occluded);
    11431143    EXPECT_EQ(24-6, layer->fakeLayerTextureUpdater()->prepareRectCount());
    … …  
    11641164    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    11651165    layer->setTexturePriorities(priorityCalculator);
    1166     textureManager->prioritizeTextures(0);
     1166    textureManager->prioritizeTextures();
    11671167    layer->updateContentRect(updater, IntRect(0, 0, 600, 600), &occluded);
    11681168    EXPECT_EQ(36-3, layer->fakeLayerTextureUpdater()->prepareRectCount());
    … …  
    12041204    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    12051205    layer->setTexturePriorities(priorityCalculator);
    1206     textureManager->prioritizeTextures(0);
     1206    textureManager->prioritizeTextures();
    12071207    layer->updateContentRect(updater, IntRect(0, 0, 600, 600), &occluded);
    12081208    EXPECT_EQ(36-3, layer->fakeLayerTextureUpdater()->prepareRectCount());
    … …  
    12321232    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    12331233    layer->setTexturePriorities(priorityCalculator);
    1234     textureManager->prioritizeTextures(0);
     1234    textureManager->prioritizeTextures();
    12351235    layer->updateContentRect(updater, IntRect(0, 0, 600, 600), &occluded);
    12361236    // The content is half the size of the layer (so the number of tiles is fewer).
    … …  
    12521252    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    12531253    layer->setTexturePriorities(priorityCalculator);
    1254     textureManager->prioritizeTextures(0);
     1254    textureManager->prioritizeTextures();
    12551255    layer->updateContentRect(updater, IntRect(0, 0, 600, 600), &occluded);
    12561256    EXPECT_EQ(9-1, layer->fakeLayerTextureUpdater()->prepareRectCount());
    … …  
    12721272    layer->invalidateContentRect(IntRect(0, 0, 600, 600));
    12731273    layer->setTexturePriorities(priorityCalculator);
    1274     textureManager->prioritizeTextures(0);
     1274    textureManager->prioritizeTextures();
    12751275    layer->updateContentRect(updater, IntRect(0, 0, 600, 600), &occluded);
    12761276    EXPECT_EQ(9-1, layer->fakeLayerTextureUpdater()->prepareRectCount());
    … …  
    13011301
    13021302    layer->setTexturePriorities(priorityCalculator);
    1303     textureManager->prioritizeTextures(0);
     1303    textureManager->prioritizeTextures();
    13041304
    13051305    // If the layer doesn't paint opaque content, then the visibleContentOpaqueRegion should be empty.
    … …  
    13941394
    13951395    layer->setTexturePriorities(priorityCalculator);
    1396     textureManager->prioritizeTextures(0);
     1396    textureManager->prioritizeTextures();
    13971397
    13981398    // Invalidates and paints the whole layer.
    … …  
    16371637
    16381638    layer->setTexturePriorities(calculator);
    1639     textureManager->prioritizeTextures(0);
     1639    textureManager->prioritizeTextures();
    16401640
    16411641    // Update the whole tile.
    … …  
    16701670
    16711671    layer->setTexturePriorities(calculator);
    1672     textureManager->prioritizeTextures(0);
     1672    textureManager->prioritizeTextures();
    16731673
    16741674    // Update the whole tile.
Note: See TracChangeset for help on using the changeset viewer.