Adjust texture priorities in preparation of impl-thread eviction of only some textures

cc/TiledLayerChromium.cpp

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #if USE(ACCELERATED_COMPOSITING)
 
 #include "TiledLayerChromium.h"
 
@@ skipping 530 matching lines @@
         return false;
     IntSize viewportSize = layer->layerTreeHost() ? layer->layerTreeHost()->deviceViewportSize() : IntSize();
     IntRect contentRect(IntPoint::zero(), layer->contentBounds());
     return contentRect.width() <= viewportSize.width() + 64
         && contentRect.height() <= viewportSize.height() + 64;
 }
 
 // FIXME: Remove this and make this based on distance once distance can be calculated
 // for offscreen layers. For now, prioritize all small animated layers after 512
 // pixels of pre-painting.
-void setPriorityForTexture(const CCPriorityCalculator& priorityCalc,
-                           const IntRect& visibleRect,
+void setPriorityForTexture(const IntRect& visibleRect,
                            const IntRect& tileRect,
                            bool drawsToRoot,
                            bool isSmallAnimatedLayer,
                            CCPrioritizedTexture* texture)
 {
     int priority = CCPriorityCalculator::lowestPriority();
     if (!visibleRect.isEmpty())
-        priority = priorityCalc.priorityFromDistance(visibleRect, tileRect, drawsToRoot);
+        priority = CCPriorityCalculator::priorityFromDistance(visibleRect, tileRect, drawsToRoot);
     if (isSmallAnimatedLayer)
-        priority = CCPriorityCalculator::maxPriority(priority, priorityCalc.priorityFromDistance(512, drawsToRoot));
+        priority = CCPriorityCalculator::maxPriority(priority, CCPriorityCalculator::smallAnimatedLayerMinPriority());
     if (priority != CCPriorityCalculator::lowestPriority())
         texture->setRequestPriority(priority);
 }
 }
 
 void TiledLayerChromium::setTexturePriorities(const CCPriorityCalculator& priorityCalc)
 {
     updateBounds();
     resetUpdateState();
 
@@ skipping 40 matching lines @@
                 if (!layerTreeHost() || !layerTreeHost()->bufferedUpdates() || !tileNeedsBufferedUpdate(tile))
                     continue;
                 if (tileOnlyNeedsPartialUpdate(tile) && layerTreeHost()->requestPartialTextureUpdate()) {
                     tile->partialUpdate = true;
                     continue;
                 }
 
                 IntRect tileRect = m_tiler->tileRect(tile);
                 tile->dirtyRect = tileRect;
                 LayerTextureUpdater::Texture* backBuffer = tile->texture();
-                setPriorityForTexture(priorityCalc, visibleContentRect(), tile->dirtyRect, drawsToRoot, smallAnimatedLayer, backBuffer->texture());
+                setPriorityForTexture(visibleContentRect(), tile->dirtyRect, drawsToRoot, smallAnimatedLayer, backBuffer->texture());
                 OwnPtr<CCPrioritizedTexture> frontBuffer = CCPrioritizedTexture::create(backBuffer->texture()->textureManager(),
                                                                                         backBuffer->texture()->size(),
                                                                                         backBuffer->texture()->format());
                 // Swap backBuffer into frontBuffer and add it to delete after commit queue.
                 backBuffer->swapTextureWith(frontBuffer);
                 layerTreeHost()->deleteTextureAfterCommit(frontBuffer.release());
             }
         }
     }
 
     // Now update priorities on all tiles we have in the layer, no matter where they are.
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect tileRect = m_tiler->tileRect(tile);
-        setPriorityForTexture(priorityCalc, visibleContentRect(), tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
+        setPriorityForTexture(visibleContentRect(), tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
     }
 }
 
 Region TiledLayerChromium::visibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
         return Region();
     if (opaque())
         return visibleContentRect();
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
@@ skipping 129 matching lines @@
     prepaintRect.inflateX(m_tiler->tileSize().width());
     prepaintRect.inflateY(m_tiler->tileSize().height() * 2);
     IntRect contentRect(IntPoint::zero(), contentBounds());
     prepaintRect.intersect(contentRect);
 
     return prepaintRect;
 }
 
 }
 #endif // USE(ACCELERATED_COMPOSITING)