cc: The recent texture manager bug uncovered some unnecessary code

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 "CCLayerImpl.h"
 #include "CCLayerTreeHost.h"
@@ skipping 40 matching lines @@
         validForFrame = true;
         updateRect = dirtyRect;
         dirtyRect = IntRect();
     }
 
     IntRect dirtyRect;
     IntRect updateRect;
     bool partialUpdate;
     bool validForFrame;
     bool occluded;
-    bool isInUseOnImpl;
 
 private:
     explicit UpdatableTile(scoped_ptr<LayerTextureUpdater::Texture> texture)
         : partialUpdate(false)
         , validForFrame(false)
         , occluded(false)
-        , isInUseOnImpl(false)
         , m_texture(texture.Pass())
     {
     }
 
     scoped_ptr<LayerTextureUpdater::Texture> m_texture;
 
     DISALLOW_COPY_AND_ASSIGN(UpdatableTile);
 };
 
 TiledLayerChromium::TiledLayerChromium()
@@ skipping 122 matching lines @@
     Vector<UpdatableTile*> invalidTiles;
 
     for (CCLayerTilingData::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;
 
-        tile->isInUseOnImpl = false;
-
         if (!tile->managedTexture()->haveBackingTexture()) {
             // Evicted tiles get deleted from both layers
             invalidTiles.append(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->isInUseOnImpl = true;
     }
     for (Vector<UpdatableTile*>::const_iterator iter = invalidTiles.begin(); iter != invalidTiles.end(); ++iter)
         m_tiler->takeTile((*iter)->i(), (*iter)->j());
 }
 
 CCPrioritizedTextureManager* TiledLayerChromium::textureManager() const
 {
     if (!layerTreeHost())
         return 0;
     return layerTreeHost()->contentsTextureManager();
@@ skipping 91 matching lines @@
 // Dirty tiles with valid textures needs buffered update to guarantee that
 // we don't modify textures currently used for drawing by the impl thread.
 bool TiledLayerChromium::tileNeedsBufferedUpdate(UpdatableTile* tile)
 {
     if (!tile->managedTexture()->haveBackingTexture())
         return false;
 
     if (!tile->isDirty())
         return false;
 
-    if (!tile->isInUseOnImpl)
-        return false;
-
     return true;
 }
 
-
 bool TiledLayerChromium::updateTiles(int left, int top, int right, int bottom, CCTextureUpdateQueue& queue, const CCOcclusionTracker* occlusion, CCRenderingStats& stats, bool& didPaint)
 {
     didPaint = false;
     createTextureUpdaterIfNeeded();
 
     bool ignoreOcclusions = !occlusion;
     if (!haveTexturesForTiles(left, top, right, bottom, ignoreOcclusions)) {
         m_failedUpdate = true;
         return false;
     }
@@ skipping 35 matching lines @@
                 occludedTileCount++;
             } else {
                 succeeded &= tile->managedTexture()->requestLate();
             }
         }
     }
 
     if (!succeeded)
         return;
 
-    // FIXME: Remove the loop and just pass the count!
-    for (int i = 0; i < occludedTileCount; i++)
-        occlusion->overdrawMetrics().didCullTileForUpload();
+    occlusion->overdrawMetrics().didCullTilesForUpload(occludedTileCount);

[danakj, 2012/10/18 03:03:42]

Nice, thanks for this :)

 }
 
-bool TiledLayerChromium::haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions)
+bool TiledLayerChromium::haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions) const
 {
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
             ASSERT(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())
-                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())
                 return false;
         }
     }
     return true;
 }
 
 IntRect TiledLayerChromium::markTilesForUpdate(int left, int top, int right, int bottom, bool ignoreOcclusions)
 {
     IntRect paintRect;
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             UpdatableTile* tile = tileAt(i, j);
             ASSERT(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 (layerTreeHost() && layerTreeHost()->bufferedUpdates() && tileNeedsBufferedUpdate(tile)) {
+                // 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->managedTexture()->returnBackingTexture();
+            }
+            // Ensure the entire tile is dirty if we don't have the texture.
+            if (!tile->managedTexture()->haveBackingTexture())
+                tile->dirtyRect = m_tiler->tileRect(tile);
+
             paintRect.unite(tile->dirtyRect);
             tile->markForUpdate();
         }
     }
     return paintRect;
 }
 
 void TiledLayerChromium::updateTileTextures(const IntRect& paintRect, int left, int top, int right, int bottom, CCTextureUpdateQueue& queue, const CCOcclusionTracker* occlusion, CCRenderingStats& stats)
 {
     // The updateRect should be in layer space. So we have to convert the paintRect from content space to layer space.
@@ skipping 117 matching lines @@
     resetUpdateState();
 
     if (m_tiler->hasEmptyBounds())
         return;
 
     bool drawsToRoot = !renderTarget()->parent();
     bool smallAnimatedLayer = isSmallAnimatedLayer(this);
 
     // Minimally create the tiles in the desired pre-paint rect.
     IntRect createTilesRect = idlePaintRect();
+    if (smallAnimatedLayer)
+        createTilesRect = IntRect(IntPoint::zero(), contentBounds());
     if (!createTilesRect.isEmpty()) {
         int left, top, right, bottom;
         m_tiler->contentRectToTileIndices(createTilesRect, left, top, right, bottom);
         for (int j = top; j <= bottom; ++j) {
             for (int i = left; i <= right; ++i) {
                 if (!tileAt(i, j))
                     createTile(i, j);
             }
         }
     }
 
-    // Also, minimally create all tiles for small animated layers and also
-    // double-buffer them since we have limited their size to be reasonable.
-    IntRect doubleBufferedRect = visibleContentRect();
-    if (smallAnimatedLayer)
-        doubleBufferedRect = IntRect(IntPoint::zero(), contentBounds());
-
-    // Create additional textures for double-buffered updates when needed.
-    // These textures must stay alive while the updated textures are incrementally
-    // uploaded, swapped atomically via pushProperties, and finally deleted
-    // after the commit is complete, after which they can be recycled.
-    if (!doubleBufferedRect.isEmpty()) {
-        int left, top, right, bottom;
-        m_tiler->contentRectToTileIndices(doubleBufferedRect, left, top, right, bottom);
-        for (int j = top; j <= bottom; ++j) {
-            for (int i = left; i <= right; ++i) {
-                UpdatableTile* tile = tileAt(i, j);
-                if (!tile)
-                    tile = createTile(i, j);
-                // We need an additional texture if the tile needs a buffered-update and it's not a partial update.
-                // FIXME: Decide if partial update should be allowed based on cost
-                // of update. https://bugs.webkit.org/show_bug.cgi?id=77376
-                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(visibleContentRect(), tile->dirtyRect, drawsToRoot, smallAnimatedLayer, backBuffer->texture());
-                scoped_ptr<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.Pass());
-            }
-        }
-    }
-
     // 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);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect tileRect = m_tiler->tileRect(tile);
         setPriorityForTexture(visibleContentRect(), tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
     }
 }
@@ skipping 136 matching lines @@
     IntRect prepaintRect = visibleContentRect();
     prepaintRect.inflateX(m_tiler->tileSize().width());
     prepaintRect.inflateY(m_tiler->tileSize().height() * 2);
     IntRect contentRect(IntPoint::zero(), contentBounds());
     prepaintRect.intersect(contentRect);
 
     return prepaintRect;
 }
 
 }