cc: Rename PrioritizedTexture to PrioritizedResource.

cc/tiled_layer.cc

 // 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"
 
 #include "cc/tiled_layer.h"
 
 #include "Region.h"
 #include "base/basictypes.h"
@@ skipping 21 matching lines @@
 
 
 class UpdatableTile : public LayerTilingData::Tile {
 public:
     static scoped_ptr<UpdatableTile> create(scoped_ptr<LayerUpdater::Resource> updaterResource)
     {
         return make_scoped_ptr(new UpdatableTile(updaterResource.Pass()));
     }
 
     LayerUpdater::Resource* updaterResource() { return m_updaterResource.get(); }
-    PrioritizedTexture* managedTexture() { return m_updaterResource->texture(); }
+    PrioritizedResource* managedResource() { return m_updaterResource->texture(); }
 
     bool isDirty() const { return !dirtyRect.IsEmpty(); }
 
     // Reset update state for the current frame. This should occur before painting
     // for all layers. Since painting one layer can invalidate another layer
     // after it has already painted, mark all non-dirty tiles as valid before painting
     // such that invalidations during painting won't prevent them from being pushed.
     void resetUpdateState()
     {
         updateRect = gfx::Rect();
@@ skipping 145 matching lines @@
     std::vector<UpdatableTile*> invalidTiles;
 
     for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
         int i = iter->first.first;
         int j = iter->first.second;
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
 
-        if (!tile->managedTexture()->haveBackingTexture()) {
+        if (!tile->managedResource()->haveBackingTexture()) {
             // Evicted tiles get deleted from both layers
             invalidTiles.push_back(tile);
             continue;
         }
 
         if (!tile->validForFrame) {
             // Invalidated tiles are set so they can get different debug colors.
             tiledLayer->pushInvalidTile(i, j);
             continue;
         }
 
-        tiledLayer->pushTileProperties(i, j, tile->managedTexture()->resourceId(), tile->opaqueRect(), tile->managedTexture()->contentsSwizzled());
+        tiledLayer->pushTileProperties(i, j, tile->managedResource()->resourceId(), tile->opaqueRect(), tile->managedResource()->contentsSwizzled());
     }
     for (std::vector<UpdatableTile*>::const_iterator iter = invalidTiles.begin(); iter != invalidTiles.end(); ++iter)
         m_tiler->takeTile((*iter)->i(), (*iter)->j());
 }
 
-PrioritizedTextureManager* TiledLayer::textureManager() const
+PrioritizedResourceManager* TiledLayer::resourceManager() const
 {
     if (!layerTreeHost())
         return 0;
     return layerTreeHost()->contentsTextureManager();
 }
 
 void TiledLayer::setLayerTreeHost(LayerTreeHost* host)
 {
     if (host && host != layerTreeHost()) {
         for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
             UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
-            tile->managedTexture()->setTextureManager(host->contentsTextureManager());
+            tile->managedResource()->setTextureManager(host->contentsTextureManager());
         }
     }
     ContentsScalingLayer::setLayerTreeHost(host);
 }
 
 UpdatableTile* TiledLayer::tileAt(int i, int j) const
 {
     return static_cast<UpdatableTile*>(m_tiler->tileAt(i, j));
 }
 
 UpdatableTile* TiledLayer::createTile(int i, int j)
 {
     createUpdaterIfNeeded();
 
-    scoped_ptr<UpdatableTile> tile(UpdatableTile::create(updater()->createResource(textureManager())));
-    tile->managedTexture()->setDimensions(m_tiler->tileSize(), m_textureFormat);
+    scoped_ptr<UpdatableTile> tile(UpdatableTile::create(updater()->createResource(resourceManager())));
+    tile->managedResource()->setDimensions(m_tiler->tileSize(), m_textureFormat);
 
     UpdatableTile* addedTile = tile.get();
     m_tiler->addTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
 
     addedTile->dirtyRect = m_tiler->tileRect(addedTile);
 
     // Temporary diagnostic crash.
     if (!addedTile)
         CRASH();
     if (!tileAt(i, j))
@@ skipping 36 matching lines @@
             continue;
         gfx::Rect bound = m_tiler->tileRect(tile);
         bound.Intersect(contentRect);
         tile->dirtyRect.Union(bound);
     }
 }
 
 // Returns true if tile is dirty and only part of it needs to be updated.
 bool TiledLayer::tileOnlyNeedsPartialUpdate(UpdatableTile* tile)
 {
-    return !tile->dirtyRect.Contains(m_tiler->tileRect(tile)) && tile->managedTexture()->haveBackingTexture();
+    return !tile->dirtyRect.Contains(m_tiler->tileRect(tile)) && tile->managedResource()->haveBackingTexture();
 }
 
 bool TiledLayer::updateTiles(int left, int top, int right, int bottom, ResourceUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats& stats, bool& didPaint)
 {
     didPaint = false;
     createUpdaterIfNeeded();
 
     bool ignoreOcclusions = !occlusion;
     if (!haveTexturesForTiles(left, top, right, bottom, ignoreOcclusions)) {
         m_failedUpdate = true;
@@ skipping 29 matching lines @@
             DCHECK(tile); // Did setTexturePriorities get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
             DCHECK(!tile->occluded); // Did resetUpdateState get skipped? Are we doing more than one occlusion pass?
             gfx::Rect visibleTileRect = gfx::IntersectRects(m_tiler->tileBounds(i, j), visibleContentRect());
             if (occlusion && occlusion->occluded(renderTarget(), visibleTileRect, drawTransform(), drawTransformIsAnimating(), drawableContentRect())) {
                 tile->occluded = true;
                 occludedTileCount++;
             } else {
-                succeeded &= tile->managedTexture()->requestLate();
+                succeeded &= tile->managedResource()->requestLate();
             }
         }
     }
 
     if (!succeeded)
         return;
     if (occlusion)
         occlusion->overdrawMetrics().didCullTilesForUpload(occludedTileCount);
 }
 
 bool TiledLayer::haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions)
 {
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
             DCHECK(tile); // Did setTexturePriorites get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
 
             // Ensure the entire tile is dirty if we don't have the texture.
-            if (!tile->managedTexture()->haveBackingTexture())
+            if (!tile->managedResource()->haveBackingTexture())
                 tile->dirtyRect = m_tiler->tileRect(tile);
 
             // If using occlusion and the visible region of the tile is occluded,
             // don't reserve a texture or update the tile.
             if (tile->occluded && !ignoreOcclusions)
                 continue;
 
-            if (!tile->managedTexture()->canAcquireBackingTexture())
+            if (!tile->managedResource()->canAcquireBackingTexture())
                 return false;
         }
     }
     return true;
 }
 
 gfx::Rect TiledLayer::markTilesForUpdate(int left, int top, int right, int bottom, bool ignoreOcclusions)
 {
   gfx::Rect paintRect;
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
             DCHECK(tile); // Did setTexturePriorites get skipped?
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
             if (tile->occluded && !ignoreOcclusions)
                 continue;
             // FIXME: Decide if partial update should be allowed based on cost
             // of update. https://bugs.webkit.org/show_bug.cgi?id=77376
             if (tile->isDirty() && layerTreeHost() && layerTreeHost()->bufferedUpdates()) {
                 // If we get a partial update, we use the same texture, otherwise return the
                 // current texture backing, so we don't update visible textures non-atomically.
                 // If the current backing is in-use, it won't be deleted until after the commit
                 // as the texture manager will not allow deletion or recycling of in-use textures.
                 if (tileOnlyNeedsPartialUpdate(tile) && layerTreeHost()->requestPartialTextureUpdate())
                     tile->partialUpdate = true;
                 else {
                     tile->dirtyRect = m_tiler->tileRect(tile);
-                    tile->managedTexture()->returnBackingTexture();
+                    tile->managedResource()->returnBackingTexture();
                 }
             }
 
             paintRect.Union(tile->dirtyRect);
             tile->markForUpdate();
         }
     }
     return paintRect;
 }
 
@@ skipping 94 matching lines @@
         && 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 gfx::Rect& visibleRect,
                            const gfx::Rect& tileRect,
                            bool drawsToRoot,
                            bool isSmallAnimatedLayer,
-                           PrioritizedTexture* texture)
+                           PrioritizedResource* texture)
 {
     int priority = PriorityCalculator::lowestPriority();
     if (!visibleRect.IsEmpty())
         priority = PriorityCalculator::priorityFromDistance(visibleRect, tileRect, drawsToRoot);
     if (isSmallAnimatedLayer)
         priority = PriorityCalculator::maxPriority(priority, PriorityCalculator::smallAnimatedLayerMinPriority());
     if (priority != PriorityCalculator::lowestPriority())
         texture->setRequestPriority(priority);
 }
 }
@@ skipping 25 matching lines @@
         }
     }
 
     // Now update priorities on all tiles we have in the layer, no matter where they are.
     for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         gfx::Rect tileRect = m_tiler->tileRect(tile);
-        setPriorityForTexture(m_predictedVisibleRect, tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
+        setPriorityForTexture(m_predictedVisibleRect, tileRect, drawsToRoot, smallAnimatedLayer, tile->managedResource());
     }
 }
 
 Region TiledLayer::visibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
         return Region();
     if (contentsOpaque())
         return visibleContentRect();
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
@@ skipping 156 matching lines @@
     m_tiler->contentRectToTileIndices(idlePaintContentRect, left, top, right, bottom);
 
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
             DCHECK(tile); // Did setTexturePriorities get skipped?
             if (!tile)
                 continue;
 
             bool updated = !tile->updateRect.IsEmpty();
-            bool canAcquire = tile->managedTexture()->canAcquireBackingTexture();
-            bool dirty = tile->isDirty() || !tile->managedTexture()->haveBackingTexture();
+            bool canAcquire = tile->managedResource()->canAcquireBackingTexture();
+            bool dirty = tile->isDirty() || !tile->managedResource()->haveBackingTexture();
             if (!updated && canAcquire && dirty)
                 return true;
         }
     }
     return false;
 }
 
 gfx::Rect TiledLayer::idlePaintRect()
 {
     // Don't inflate an empty rect.
     if (visibleContentRect().IsEmpty())
       return gfx::Rect();
 
     gfx::Rect prepaintRect = visibleContentRect();
     prepaintRect.Inset(-m_tiler->tileSize().width() * prepaintColumns,
                        -m_tiler->tileSize().height() * prepaintRows);
     gfx::Rect contentRect(gfx::Point(), contentBounds());
     prepaintRect.Intersect(contentRect);
 
     return prepaintRect;
 }
 
 }  // namespace cc