Add CCDelegatingRenderer, and corresponding IPCs

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 "base/basictypes.h"
 #include "TiledLayerChromium.h"
 
 #include "CCLayerImpl.h"
 #include "CCLayerTreeHost.h"
+#include "CCLayerTreeHostImpl.h"
 #include "CCOverdrawMetrics.h"
+#include "CCResourceProvider.h"
 #include "CCTextureUpdateQueue.h"
 #include "CCTiledLayerImpl.h"
 #include "GraphicsContext3D.h"
 #include "Region.h"
 #include <wtf/CurrentTime.h>
 #include <wtf/MathExtras.h>
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
@@ skipping 171 matching lines @@
 void TiledLayerChromium::pushPropertiesTo(CCLayerImpl* layer)
 {
     LayerChromium::pushPropertiesTo(layer);
 
     CCTiledLayerImpl* tiledLayer = static_cast<CCTiledLayerImpl*>(layer);
 
     tiledLayer->setSkipsDraw(m_skipsDraw);
     tiledLayer->setContentsSwizzled(m_sampledTexelFormat != LayerTextureUpdater::SampledTexelFormatRGBA);
     tiledLayer->setTilingData(*m_tiler);
     Vector<UpdatableTile*> invalidTiles;
+    CCResourceProvider* resourceProvider = tiledLayer->layerTreeHostImpl()->resourceProvider();
 
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
         int i = iter->key.first;
         int j = iter->key.second;
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
 #else
         int i = iter->first.first;
         int j = iter->first.second;
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
 #endif
         // 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);
+            tile->isInUseOnImpl = false;
+            continue;
+        }
+        if (!tile->validForFrame) {
+            // Invalidated tiles are set so they can get different debug colors.
+            tiledLayer->pushInvalidTile(i, j);
+            CCResourceProvider::ResourceId id = tile->managedTexture()->resourceId();
+            ASSERT(id);
+            if (!resourceProvider->inUseByConsumer(id) /* && ubercomp */)
+                tile->isInUseOnImpl = false;
             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())
@@ skipping 362 matching lines @@
             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)
+    if (smallAnimatedLayer || true /* s/true/ubercomp */)
         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) {
@@ skipping 183 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)