[cc] Color evicted vs. invalidated checkerboard tiles differently

cc/TiledLayerChromiumTest.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"
 
 #include "TiledLayerChromium.h"
 
 #include "BitmapCanvasLayerTextureUpdater.h"
 #include "CCAnimationTestCommon.h"
@@ skipping 163 matching lines @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(IntSize(100, 200));
     layer->setVisibleContentRect(IntRect(0, 0, 100, 200));
     layer->invalidateContentRect(IntRect(0, 0, 100, 200));
     updateAndPush(layer.get(), layerImpl.get());
 
     // We should have both tiles on the impl side.
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     // Invalidates both tiles, but then only update one of them.
     layer->setBounds(IntSize(100, 200));
     layer->setVisibleContentRect(IntRect(0, 0, 100, 100));
     layer->invalidateContentRect(IntRect(0, 0, 100, 200));
     updateAndPush(layer.get(), layerImpl.get());
 
     // We should only have the first tile since the other tile was invalidated but not painted.
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_FALSE(layerImpl->hasTileAt(0, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerChromiumTest, pushOccludedDirtyTiles)
 {
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
     TestCCOcclusionTracker occluded;
     m_occlusion = &occluded;
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(IntSize(100, 200));
     layer->setVisibleContentRect(IntRect(0, 0, 100, 200));
     layer->invalidateContentRect(IntRect(0, 0, 100, 200));
     updateAndPush(layer.get(), layerImpl.get());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // We should have both tiles on the impl side.
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     // Invalidates part of the top tile...
     layer->invalidateContentRect(IntRect(0, 0, 50, 50));
     // ....but the area is occluded.
     occluded.setOcclusion(IntRect(0, 0, 50, 50));
     updateAndPush(layer.get(), layerImpl.get());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000 + 2500, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // We should still have both tiles, as part of the top tile is still unoccluded.
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerChromiumTest, pushDeletedTiles)
 {
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(IntSize(100, 200));
     layer->setVisibleContentRect(IntRect(0, 0, 100, 200));
     layer->invalidateContentRect(IntRect(0, 0, 100, 200));
     updateAndPush(layer.get(), layerImpl.get());
 
     // We should have both tiles on the impl side.
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     m_textureManager->clearPriorities();
     textureManagerClearAllMemory(m_textureManager.get(), m_resourceProvider.get());
     m_textureManager->setMaxMemoryLimitBytes(4*1024*1024);
 
     // This should drop the tiles on the impl thread.
     layerPushPropertiesTo(layer.get(), layerImpl.get());
 
     // We should now have no textures on the impl thread.
-    EXPECT_FALSE(layerImpl->hasTileAt(0, 0));
-    EXPECT_FALSE(layerImpl->hasTileAt(0, 1));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     // This should recreate and update one of the deleted textures.
     layer->setVisibleContentRect(IntRect(0, 0, 100, 100));
     updateAndPush(layer.get(), layerImpl.get());
 
     // We should have one tiles on the impl side.
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_FALSE(layerImpl->hasTileAt(0, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerChromiumTest, pushIdlePaintTiles)
 {
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
 
     // The tile size is 100x100. Setup 5x5 tiles with one visible tile in the center.
     // This paints 1 visible of the 25 invalid tiles.
     layer->setBounds(IntSize(500, 500));
     layer->setVisibleContentRect(IntRect(200, 200, 100, 100));
     layer->invalidateContentRect(IntRect(0, 0, 500, 500));
     bool needsUpdate = updateAndPush(layer.get(), layerImpl.get());
     // We should need idle-painting for surrounding tiles.
     EXPECT_TRUE(needsUpdate);
 
     // We should have one tile on the impl side.
-    EXPECT_TRUE(layerImpl->hasTileAt(2, 2));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(2, 2));
 
     // For the next four updates, we should detect we still need idle painting.
     for (int i = 0; i < 4; i++) {
         needsUpdate = updateAndPush(layer.get(), layerImpl.get());
         EXPECT_TRUE(needsUpdate);
     }
 
     // We should have one tile surrounding the visible tile on all sides, but no other tiles.
     IntRect idlePaintTiles(1, 1, 3, 3);
     for (int i = 0; i < 5; i++) {
         for (int j = 0; j < 5; j++)
-            EXPECT_EQ(layerImpl->hasTileAt(i, j), idlePaintTiles.contains(i, j));
+            EXPECT_EQ(layerImpl->hasResourceIdForTileAt(i, j), idlePaintTiles.contains(i, j));
     }
 
     // We should always finish painting eventually.
     for (int i = 0; i < 20; i++)
         needsUpdate = updateAndPush(layer.get(), layerImpl.get());
     EXPECT_FALSE(needsUpdate);
 }
 
 TEST_F(TiledLayerChromiumTest, pushTilesAfterIdlePaintFailed)
 {
@@ skipping 28 matching lines @@
     m_textureManager->setMaxMemoryLimitBytes(1024 * 1024);
 
     // Now idle paint layer2. We are going to run out of memory though!
     // Oh well, commit the frame and push.
     for (int i = 0; i < 4; i++) {
         needsUpdate = updateAndPush(layer1.get(), layerImpl1.get(),
                                     layer2.get(), layerImpl2.get());
     }
 
     // Sanity check, we should have textures for the big layer.
-    EXPECT_TRUE(layerImpl1->hasTextureIdForTileAt(0, 0));
-    EXPECT_TRUE(layerImpl1->hasTextureIdForTileAt(0, 23));
+    EXPECT_TRUE(layerImpl1->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl1->hasResourceIdForTileAt(0, 23));
 
     // We should only have the first two tiles from layer2 since
     // it failed to idle update the last tile.
-    EXPECT_TRUE(layerImpl2->hasTileAt(0, 0));
-    EXPECT_TRUE(layerImpl2->hasTextureIdForTileAt(0, 0));
-    EXPECT_TRUE(layerImpl2->hasTileAt(0, 1));
-    EXPECT_TRUE(layerImpl2->hasTextureIdForTileAt(0, 1));
+    EXPECT_TRUE(layerImpl2->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl2->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl2->hasResourceIdForTileAt(0, 1));
+    EXPECT_TRUE(layerImpl2->hasResourceIdForTileAt(0, 1));
     
     EXPECT_FALSE(needsUpdate);
-    EXPECT_FALSE(layerImpl2->hasTileAt(0, 2));
+    EXPECT_FALSE(layerImpl2->hasResourceIdForTileAt(0, 2));
 }
 
 TEST_F(TiledLayerChromiumTest, pushIdlePaintedOccludedTiles)
 {
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
     TestCCOcclusionTracker occluded;
     m_occlusion = &occluded;
     
     // The tile size is 100x100, so this invalidates one occluded tile, culls it during paint, but prepaints it.
     occluded.setOcclusion(IntRect(0, 0, 100, 100));
 
     layer->setBounds(IntSize(100, 100));
     layer->setVisibleContentRect(IntRect(0, 0, 100, 100));
     updateAndPush(layer.get(), layerImpl.get());
 
     // We should have the prepainted tile on the impl side, but culled it during paint.
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_EQ(1, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerChromiumTest, pushTilesMarkedDirtyDuringPaint)
 {
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     // However, during the paint, we invalidate one of the tiles. This should
     // not prevent the tile from being pushed.
     layer->fakeLayerTextureUpdater()->setRectToInvalidate(IntRect(0, 50, 100, 50), layer.get());
     layer->setBounds(IntSize(100, 200));
     layer->setVisibleContentRect(IntRect(0, 0, 100, 200));    
     updateAndPush(layer.get(), layerImpl.get());
 
     // We should have both tiles on the impl side.
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerChromiumTest, pushTilesLayerMarkedDirtyDuringPaintOnNextLayer)
 {
     RefPtr<FakeTiledLayerChromium> layer1 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     RefPtr<FakeTiledLayerChromium> layer2 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layer1Impl(1);
     ScopedFakeCCTiledLayerImpl layer2Impl(2);
 
     // Invalidate a tile on layer1, during update of layer 2.
     layer2->fakeLayerTextureUpdater()->setRectToInvalidate(IntRect(0, 50, 100, 50), layer1.get());
     layer1->setBounds(IntSize(100, 200));
     layer1->setVisibleContentRect(IntRect(0, 0, 100, 200));    
     layer2->setBounds(IntSize(100, 200));
     layer2->setVisibleContentRect(IntRect(0, 0, 100, 200));    
     updateAndPush(layer1.get(), layer1Impl.get(),
                   layer2.get(), layer2Impl.get());
 
     // We should have both tiles on the impl side for all layers.
-    EXPECT_TRUE(layer1Impl->hasTileAt(0, 0));
-    EXPECT_TRUE(layer1Impl->hasTileAt(0, 1));
-    EXPECT_TRUE(layer2Impl->hasTileAt(0, 0));
-    EXPECT_TRUE(layer2Impl->hasTileAt(0, 1));
+    EXPECT_TRUE(layer1Impl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layer1Impl->hasResourceIdForTileAt(0, 1));
+    EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerChromiumTest, pushTilesLayerMarkedDirtyDuringPaintOnPreviousLayer)
 {
     RefPtr<FakeTiledLayerChromium> layer1 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     RefPtr<FakeTiledLayerChromium> layer2 = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layer1Impl(1);
     ScopedFakeCCTiledLayerImpl layer2Impl(2);
 
     layer1->fakeLayerTextureUpdater()->setRectToInvalidate(IntRect(0, 50, 100, 50), layer2.get());
     layer1->setBounds(IntSize(100, 200));
     layer1->setVisibleContentRect(IntRect(0, 0, 100, 200));    
     layer2->setBounds(IntSize(100, 200));
     layer2->setVisibleContentRect(IntRect(0, 0, 100, 200));    
     updateAndPush(layer1.get(), layer1Impl.get(),
                   layer2.get(), layer2Impl.get());
 
     // We should have both tiles on the impl side for all layers.
-    EXPECT_TRUE(layer1Impl->hasTileAt(0, 0));
-    EXPECT_TRUE(layer1Impl->hasTileAt(0, 1));
-    EXPECT_TRUE(layer2Impl->hasTileAt(0, 0));
-    EXPECT_TRUE(layer2Impl->hasTileAt(0, 1));
+    EXPECT_TRUE(layer1Impl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layer1Impl->hasResourceIdForTileAt(0, 1));
+    EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerChromiumTest, paintSmallAnimatedLayersImmediately)
 {
     // Create a CCLayerTreeHost that has the right viewportsize,
     // so the layer is considered small enough.
     FakeCCLayerTreeHostClient fakeCCLayerTreeHostClient;
     OwnPtr<CCLayerTreeHost> ccLayerTreeHost = CCLayerTreeHost::create(&fakeCCLayerTreeHostClient, CCLayerTreeSettings());
 
     bool runOutOfMemory[2] = {false, true};
@@ skipping 33 matching lines @@
         layer->update(*m_queue.get(), 0, m_stats);
         updateTextures();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
 
         // We should have all the tiles for the small animated layer.
         // We should still have the visible tiles when we didn't
         // have enough memory for all the tiles.
         if (!runOutOfMemory[i]) {
             for (int i = 0; i < 4; ++i) {
                 for (int j = 0; j < 4; ++j)
-                    EXPECT_TRUE(layerImpl->hasTileAt(i, j));
+                    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(i, j));
             }
         } else {
             for (int i = 0; i < 8; ++i) {
                 for (int j = 0; j < 4; ++j)
-                    EXPECT_EQ(layerImpl->hasTileAt(i, j), i < 4);
+                    EXPECT_EQ(layerImpl->hasResourceIdForTileAt(i, j), i < 4);
             }
         }
     }
     ccLayerTreeHost.clear();
 }
 
 TEST_F(TiledLayerChromiumTest, idlePaintOutOfMemory)
 {
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
 
     // We have enough memory for only the visible rect, so we will run out of memory in first idle paint.
     int memoryLimit = 4 * 100 * 100; // 1 tiles, 4 bytes per pixel.
     m_textureManager->setMaxMemoryLimitBytes(memoryLimit);
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     bool needsUpdate = false;
     layer->setBounds(IntSize(300, 300));
     layer->setVisibleContentRect(IntRect(100, 100, 100, 100));
     for (int i = 0; i < 2; i++)
         needsUpdate = updateAndPush(layer.get(), layerImpl.get());
 
     // Idle-painting should see no more priority tiles for painting.
     EXPECT_FALSE(needsUpdate);
 
     // We should have one tile on the impl side.
-    EXPECT_TRUE(layerImpl->hasTileAt(1, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(1, 1));
 }
 
 TEST_F(TiledLayerChromiumTest, idlePaintZeroSizedLayer)
 {
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
 
     bool animating[2] = {false, true};
     for (int i = 0; i < 2; i++) {
         // Pretend the layer is animating.
         layer->setDrawTransformIsAnimating(animating[i]);
 
         // The layer's bounds are empty.
         // Empty layers don't paint or idle-paint.
         layer->setBounds(IntSize());
         layer->setVisibleContentRect(IntRect());
         bool needsUpdate = updateAndPush(layer.get(), layerImpl.get());
         
         // Empty layers don't have tiles.
         EXPECT_EQ(0u, layer->numPaintedTiles());
 
         // Empty layers don't need prepaint.
         EXPECT_FALSE(needsUpdate);
 
         // Empty layers don't have tiles.
-        EXPECT_FALSE(layerImpl->hasTileAt(0, 0));
+        EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 0));
     }
 }
 
 TEST_F(TiledLayerChromiumTest, idlePaintNonVisibleLayers)
 {
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
 
     // Alternate between not visible and visible.
     IntRect v(0, 0, 100, 100);
     IntRect nv(0, 0, 0, 0);
     IntRect visibleRect[10] = {nv, nv, v, v, nv, nv, v, v, nv, nv};
     bool invalidate[10] =  {true, true, true, true, true, true, true, true, false, false };
 
     // We should not have any tiles except for when the layer was visible
     // or after the layer was visible and we didn't invalidate.
     bool haveTile[10] = { false, false, true, true, false, false, true, true, true, true };
     
     for (int i = 0; i < 10; i++) {
         layer->setBounds(IntSize(100, 100));
         layer->setVisibleContentRect(visibleRect[i]);
 
         if (invalidate[i])
             layer->invalidateContentRect(IntRect(0, 0, 100, 100));
         bool needsUpdate = updateAndPush(layer.get(), layerImpl.get());
         
         // We should never signal idle paint, as we painted the entire layer
         // or the layer was not visible.
         EXPECT_FALSE(needsUpdate);
-        EXPECT_EQ(layerImpl->hasTileAt(0, 0), haveTile[i]);
+        EXPECT_EQ(layerImpl->hasResourceIdForTileAt(0, 0), haveTile[i]);
     }
 }
 
 TEST_F(TiledLayerChromiumTest, invalidateFromPrepare)
 {
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(m_textureManager.get()));
     ScopedFakeCCTiledLayerImpl layerImpl(1);
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(IntSize(100, 200));
     layer->setVisibleContentRect(IntRect(0, 0, 100, 200));
     updateAndPush(layer.get(), layerImpl.get());
 
     // We should have both tiles on the impl side.
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     layer->fakeLayerTextureUpdater()->clearPrepareCount();
     // Invoke update again. As the layer is valid update shouldn't be invoked on
     // the LayerTextureUpdater.
     updateAndPush(layer.get(), layerImpl.get());
     EXPECT_EQ(0, layer->fakeLayerTextureUpdater()->prepareCount());
 
     // setRectToInvalidate triggers invalidateContentRect() being invoked from update.
     layer->fakeLayerTextureUpdater()->setRectToInvalidate(IntRect(25, 25, 50, 50), layer.get());
     layer->fakeLayerTextureUpdater()->clearPrepareCount();
@@ skipping 59 matching lines @@
     // Invalidate the entire layer.
     layer->setNeedsDisplay();
     EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 100, 100), layer->lastNeedsDisplayRect());
 
     // Push the tiles to the impl side and check that there is exactly one.
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), 0, m_stats);
     updateTextures();
     layerPushPropertiesTo(layer.get(), layerImpl.get());
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_FALSE(layerImpl->hasTileAt(0, 1));
-    EXPECT_FALSE(layerImpl->hasTileAt(1, 0));
-    EXPECT_FALSE(layerImpl->hasTileAt(1, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(1, 0));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(1, 1));
 
     // Change the contents scale and verify that the content rectangle requiring painting
     // is not scaled.
     layer->setContentsScale(2);
     layer->setVisibleContentRect(IntRect(0, 0, 200, 200));
     EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 100, 100), layer->lastNeedsDisplayRect());
 
     // The impl side should get 2x2 tiles now.
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), 0, m_stats);
     updateTextures();
     layerPushPropertiesTo(layer.get(), layerImpl.get());
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 0));
-    EXPECT_TRUE(layerImpl->hasTileAt(0, 1));
-    EXPECT_TRUE(layerImpl->hasTileAt(1, 0));
-    EXPECT_TRUE(layerImpl->hasTileAt(1, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(1, 0));
+    EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(1, 1));
 
     // Invalidate the entire layer again, but do not paint. All tiles should be gone now from the
     // impl side.
     layer->setNeedsDisplay();
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
 
     layerPushPropertiesTo(layer.get(), layerImpl.get());
-    EXPECT_FALSE(layerImpl->hasTileAt(0, 0));
-    EXPECT_FALSE(layerImpl->hasTileAt(0, 1));
-    EXPECT_FALSE(layerImpl->hasTileAt(1, 0));
-    EXPECT_FALSE(layerImpl->hasTileAt(1, 1));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 0));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(1, 0));
+    EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(1, 1));
 }
 
 TEST_F(TiledLayerChromiumTest, skipsDrawGetsReset)
 {
     FakeCCLayerTreeHostClient fakeCCLayerTreeHostClient;
     OwnPtr<CCLayerTreeHost> ccLayerTreeHost = CCLayerTreeHost::create(&fakeCCLayerTreeHostClient, CCLayerTreeSettings());
     ASSERT_TRUE(ccLayerTreeHost->initializeRendererIfNeeded());
 
     // Create two 300 x 300 tiled layers.
     IntSize contentBounds(300, 300);
@@ skipping 649 matching lines @@
 
         ScopedFakeCCTiledLayerImpl rootImpl(root->id());
         ScopedFakeCCTiledLayerImpl childImpl(child->id());
         ScopedFakeCCTiledLayerImpl child2Impl(child2->id());
         layerPushPropertiesTo(root.get(), rootImpl.get());
         layerPushPropertiesTo(child.get(), childImpl.get());
         layerPushPropertiesTo(child2.get(), child2Impl.get());
 
         for (unsigned i = 0; i < 3; ++i) {
             for (unsigned j = 0; j < 2; ++j)
-                EXPECT_TRUE(rootImpl->hasTextureIdForTileAt(i, j));
-            EXPECT_TRUE(childImpl->hasTextureIdForTileAt(i, 0));
-            EXPECT_TRUE(child2Impl->hasTextureIdForTileAt(i, 0));
+                EXPECT_TRUE(rootImpl->hasResourceIdForTileAt(i, j));
+            EXPECT_TRUE(childImpl->hasResourceIdForTileAt(i, 0));
+            EXPECT_TRUE(child2Impl->hasResourceIdForTileAt(i, 0));
         }
     }
     ccLayerTreeHost->commitComplete();
 
     // With a memory limit that includes only the root layer (3x2 tiles) and half the surface that
     // the child layers draw into, the child layers will not be allocated. If the surface isn't
     // accounted for, then one of the children would fit within the memory limit.
     root->invalidateContentRect(rootRect);
     child->invalidateContentRect(childRect);
     child2->invalidateContentRect(child2Rect);
@@ skipping 12 matching lines @@
 
         ScopedFakeCCTiledLayerImpl rootImpl(root->id());
         ScopedFakeCCTiledLayerImpl childImpl(child->id());
         ScopedFakeCCTiledLayerImpl child2Impl(child2->id());
         layerPushPropertiesTo(root.get(), rootImpl.get());
         layerPushPropertiesTo(child.get(), childImpl.get());
         layerPushPropertiesTo(child2.get(), child2Impl.get());
 
         for (unsigned i = 0; i < 3; ++i) {
             for (unsigned j = 0; j < 2; ++j)
-                EXPECT_TRUE(rootImpl->hasTextureIdForTileAt(i, j));
-            EXPECT_FALSE(childImpl->hasTextureIdForTileAt(i, 0));
-            EXPECT_FALSE(child2Impl->hasTextureIdForTileAt(i, 0));
+                EXPECT_TRUE(rootImpl->hasResourceIdForTileAt(i, j));
+            EXPECT_FALSE(childImpl->hasResourceIdForTileAt(i, 0));
+            EXPECT_FALSE(child2Impl->hasResourceIdForTileAt(i, 0));
         }
     }
     ccLayerTreeHost->commitComplete();
 
     // With a memory limit that includes only half the root layer, no contents will be
     // allocated. If render surface memory wasn't accounted for, there is enough space
     // for one of the children layers, but they draw into a surface that can't be
     // allocated.
     root->invalidateContentRect(rootRect);
     child->invalidateContentRect(childRect);
@@ skipping 13 matching lines @@
 
         ScopedFakeCCTiledLayerImpl rootImpl(root->id());
         ScopedFakeCCTiledLayerImpl childImpl(child->id());
         ScopedFakeCCTiledLayerImpl child2Impl(child2->id());
         layerPushPropertiesTo(root.get(), rootImpl.get());
         layerPushPropertiesTo(child.get(), childImpl.get());
         layerPushPropertiesTo(child2.get(), child2Impl.get());
 
         for (unsigned i = 0; i < 3; ++i) {
             for (unsigned j = 0; j < 2; ++j)
-                EXPECT_FALSE(rootImpl->hasTextureIdForTileAt(i, j));
-            EXPECT_FALSE(childImpl->hasTextureIdForTileAt(i, 0));
-            EXPECT_FALSE(child2Impl->hasTextureIdForTileAt(i, 0));
+                EXPECT_FALSE(rootImpl->hasResourceIdForTileAt(i, j));
+            EXPECT_FALSE(childImpl->hasResourceIdForTileAt(i, 0));
+            EXPECT_FALSE(child2Impl->hasResourceIdForTileAt(i, 0));
         }
     }
     ccLayerTreeHost->commitComplete();
 
     textureManagerClearAllMemory(ccLayerTreeHost->contentsTextureManager(), m_resourceProvider.get());
     ccLayerTreeHost->setRootLayer(0);
     ccLayerTreeHost.clear();
 }
 
 class TrackingLayerPainter : public LayerPainterChromium {
@@ skipping 90 matching lines @@
     updateTextures();
 
     // Invalidate the entire layer in layer space. When painting, the rect given to webkit should match the layer's bounds.
     layer->setNeedsDisplayRect(layerRect);
     layer->update(*m_queue.get(), 0, m_stats);
 
     EXPECT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
 }
 
 } // namespace