[cc] Color evicted vs. invalidated checkerboard tiles differently

If --show-debug-layer-borders are on, tint checkerboards differently.

* Light red = texture backing for tile was evicted or never painted
* Light blue = we have a texture backing, but it's been invalidated

Previously reverted: https://codereview.chromium.org/10962042/

BUG=150610


Review URL: https://chromiumcodereview.appspot.com/10990116

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@159346 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 132 insertions, 79 deletions

diff --git a/cc/CCCheckerboardDrawQuad.cpp b/cc/CCCheckerboardDrawQuad.cpp
index 75c9980..7ea800c 100644
--- a/cc/CCCheckerboardDrawQuad.cpp
+++ b/cc/CCCheckerboardDrawQuad.cpp
@@ -8,13 +8,14 @@
 
 namespace cc {
 
-scoped_ptr<CCCheckerboardDrawQuad> CCCheckerboardDrawQuad::create(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect)
+scoped_ptr<CCCheckerboardDrawQuad> CCCheckerboardDrawQuad::create(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, SkColor color)
 {
-    return scoped_ptr<CCCheckerboardDrawQuad>(new CCCheckerboardDrawQuad(sharedQuadState, quadRect));
+    return scoped_ptr<CCCheckerboardDrawQuad>(new CCCheckerboardDrawQuad(sharedQuadState, quadRect, color));
 }
 
-CCCheckerboardDrawQuad::CCCheckerboardDrawQuad(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect)
+CCCheckerboardDrawQuad::CCCheckerboardDrawQuad(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, SkColor color)
     : CCDrawQuad(sharedQuadState, CCDrawQuad::Checkerboard, quadRect)
+    , m_color(color)
 {
 }
 
diff --git a/cc/CCCheckerboardDrawQuad.h b/cc/CCCheckerboardDrawQuad.h
index c908531e..1ef147f 100644
--- a/cc/CCCheckerboardDrawQuad.h
+++ b/cc/CCCheckerboardDrawQuad.h
@@ -7,6 +7,7 @@
 
 #include "CCDrawQuad.h"
 #include "base/memory/scoped_ptr.h"
+#include "SkColor.h"
 
 namespace cc {
 
@@ -14,11 +15,15 @@ namespace cc {
 
 class CCCheckerboardDrawQuad : public CCDrawQuad {
 public:
-    static scoped_ptr<CCCheckerboardDrawQuad> create(const CCSharedQuadState*, const IntRect&);
+    static scoped_ptr<CCCheckerboardDrawQuad> create(const CCSharedQuadState*, const IntRect&, SkColor);
+
+    SkColor color() const { return m_color; };
 
     static const CCCheckerboardDrawQuad* materialCast(const CCDrawQuad*);
 private:
-    CCCheckerboardDrawQuad(const CCSharedQuadState*, const IntRect&);
+    CCCheckerboardDrawQuad(const CCSharedQuadState*, const IntRect&, SkColor);
+
+    SkColor m_color;
 };
 
 #pragma pack(pop)
diff --git a/cc/CCDrawQuadTest.cpp b/cc/CCDrawQuadTest.cpp
index 8c00986..4970cd6 100644
--- a/cc/CCDrawQuadTest.cpp
+++ b/cc/CCDrawQuadTest.cpp
@@ -161,8 +161,10 @@ void compareDrawQuad(CCDrawQuad* quad, CCDrawQuad* copy, CCSharedQuadState* copy
 
 TEST(CCDrawQuadTest, copyCheckerboardDrawQuad)
 {
+    SkColor color = 0xfabb0011;
     CREATE_SHARED_STATE();
-    CREATE_QUAD_0(CCCheckerboardDrawQuad);
+    CREATE_QUAD_1(CCCheckerboardDrawQuad, color);
+    EXPECT_EQ(color, copyQuad->color());
 }
 
 TEST(CCDrawQuadTest, copyDebugBorderDrawQuad)
diff --git a/cc/CCRenderPassTest.cpp b/cc/CCRenderPassTest.cpp
index 8873366..eed74e5 100644
--- a/cc/CCRenderPassTest.cpp
+++ b/cc/CCRenderPassTest.cpp
@@ -66,7 +66,7 @@ TEST(CCRenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
     // Stick a quad in the pass, this should not get copied.
     CCTestRenderPass* testPass = static_cast<CCTestRenderPass*>(pass.get());
     testPass->sharedQuadStateList().append(CCSharedQuadState::create(WebTransformationMatrix(), IntRect(), IntRect(), 1, false));
-    testPass->quadList().append(CCCheckerboardDrawQuad::create(testPass->sharedQuadStateList().last(), IntRect()).PassAs<CCDrawQuad>());
+    testPass->quadList().append(CCCheckerboardDrawQuad::create(testPass->sharedQuadStateList().last(), IntRect(), SkColor()).PassAs<CCDrawQuad>());
 
     CCRenderPass::Id newId(63, 4);
 
diff --git a/cc/CCRendererGL.cpp b/cc/CCRendererGL.cpp
index 50fed7a..c80533c 100644
--- a/cc/CCRendererGL.cpp
+++ b/cc/CCRendererGL.cpp
@@ -284,6 +284,9 @@ void CCRendererGL::drawCheckerboardQuad(const DrawingFrame& frame, const CCCheck
     ASSERT(program && program->initialized());
     GLC(context(), context()->useProgram(program->program()));
 
+    SkColor color = quad->color();
+    GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), SkColorGetR(color) / 255.0, SkColorGetG(color) / 255.0, SkColorGetB(color) / 255.0, 1));
+
     IntRect tileRect = quad->quadRect();
     float texOffsetX = tileRect.x();
     float texOffsetY = tileRect.y();
diff --git a/cc/CCTiledLayerImpl.cpp b/cc/CCTiledLayerImpl.cpp
index 272422b..77d6329 100644
--- a/cc/CCTiledLayerImpl.cpp
+++ b/cc/CCTiledLayerImpl.cpp
@@ -35,6 +35,16 @@ static const int debugTileBorderMissingTileColorRed = 255;
 static const int debugTileBorderMissingTileColorGreen = 0;
 static const int debugTileBorderMissingTileColorBlue = 0;
 
+static const int defaultCheckerboardColorRed = 241;
+static const int defaultCheckerboardColorGreen = 241;
+static const int defaultCheckerboardColorBlue = 241;
+static const int debugTileEvictedCheckerboardColorRed = 255;
+static const int debugTileEvictedCheckerboardColorGreen = 200;
+static const int debugTileEvictedCheckerboardColorBlue = 200;
+static const int debugTileInvalidatedCheckerboardColorRed = 128;
+static const int debugTileInvalidatedCheckerboardColorGreen = 200;
+static const int debugTileInvalidatedCheckerboardColorBlue = 245;
+
 class DrawableTile : public CCLayerTilingData::Tile {
     WTF_MAKE_NONCOPYABLE(DrawableTile);
 public:
@@ -84,7 +94,7 @@ bool CCTiledLayerImpl::hasTileAt(int i, int j) const
     return m_tiler->tileAt(i, j);
 }
 
-bool CCTiledLayerImpl::hasTextureIdForTileAt(int i, int j) const
+bool CCTiledLayerImpl::hasResourceIdForTileAt(int i, int j) const
 {
     return hasTileAt(i, j) && tileAt(i, j)->resourceId();
 }
@@ -146,9 +156,19 @@ void CCTiledLayerImpl::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appe
                 continue;
 
             if (!tile || !tile->resourceId()) {
-                if (drawCheckerboardForMissingTiles())
-                    appendQuadsData.hadMissingTiles |= quadSink.append(CCCheckerboardDrawQuad::create(sharedQuadState, tileRect).PassAs<CCDrawQuad>(), appendQuadsData);
-                else
+                if (drawCheckerboardForMissingTiles()) {
+                    SkColor defaultColor = SkColorSetRGB(defaultCheckerboardColorRed, defaultCheckerboardColorGreen, defaultCheckerboardColorBlue);
+                    SkColor evictedColor = SkColorSetRGB(debugTileEvictedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
+                    SkColor invalidatedColor = SkColorSetRGB(debugTileInvalidatedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
+
+                    SkColor checkerColor;
+                    if (hasDebugBorders())
+                        checkerColor = tile ? invalidatedColor : evictedColor;
+                    else
+                        checkerColor = defaultColor;
+
+                    appendQuadsData.hadMissingTiles |= quadSink.append(CCCheckerboardDrawQuad::create(sharedQuadState, tileRect, checkerColor).PassAs<CCDrawQuad>(), appendQuadsData);
+                } else
                     appendQuadsData.hadMissingTiles |= quadSink.append(CCSolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()).PassAs<CCDrawQuad>(), appendQuadsData);
                 continue;
             }
@@ -198,6 +218,15 @@ void CCTiledLayerImpl::pushTileProperties(int i, int j, CCResourceProvider::Reso
     tile->setOpaqueRect(opaqueRect);
 }
 
+void CCTiledLayerImpl::pushInvalidTile(int i, int j)
+{
+    DrawableTile* tile = tileAt(i, j);
+    if (!tile)
+        tile = createTile(i, j);
+    tile->setResourceId(0);
+    tile->setOpaqueRect(IntRect());
+}
+
 Region CCTiledLayerImpl::visibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
diff --git a/cc/CCTiledLayerImpl.h b/cc/CCTiledLayerImpl.h
index 13edb05..6602e4f 100644
--- a/cc/CCTiledLayerImpl.h
+++ b/cc/CCTiledLayerImpl.h
@@ -30,6 +30,7 @@ public:
     void setSkipsDraw(bool skipsDraw) { m_skipsDraw = skipsDraw; }
     void setTilingData(const CCLayerTilingData& tiler);
     void pushTileProperties(int, int, CCResourceProvider::ResourceId, const IntRect& opaqueRect);
+    void pushInvalidTile(int, int);
 
     void setContentsSwizzled(bool contentsSwizzled) { m_contentsSwizzled = contentsSwizzled; }
     bool contentsSwizzled() const { return m_contentsSwizzled; }
@@ -41,7 +42,7 @@ protected:
     explicit CCTiledLayerImpl(int id);
     // Exposed for testing.
     bool hasTileAt(int, int) const;
-    bool hasTextureIdForTileAt(int, int) const;
+    bool hasResourceIdForTileAt(int, int) const;
 
 private:
 
diff --git a/cc/ShaderChromium.cpp b/cc/ShaderChromium.cpp
index f08adc1..cf485c1 100644
--- a/cc/ShaderChromium.cpp
+++ b/cc/ShaderChromium.cpp
@@ -846,15 +846,17 @@ void FragmentShaderCheckerboard::init(WebGraphicsContext3D* context, unsigned pr
         "alpha",
         "texTransform",
         "frequency",
+        "color",
     };
-    int locations[3];
+    int locations[4];
 
     getProgramUniformLocations(context, program, shaderUniforms, WTF_ARRAY_LENGTH(shaderUniforms), WTF_ARRAY_LENGTH(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_alphaLocation = locations[0];
     m_texTransformLocation = locations[1];
     m_frequencyLocation = locations[2];
-    ASSERT(m_alphaLocation != -1 && m_texTransformLocation != -1 && m_frequencyLocation != -1);
+    m_colorLocation = locations[3];
+    ASSERT(m_alphaLocation != -1 && m_texTransformLocation != -1 && m_frequencyLocation != -1 && m_colorLocation != -1);
 }
 
 std::string FragmentShaderCheckerboard::getShaderString() const
@@ -868,10 +870,11 @@ std::string FragmentShaderCheckerboard::getShaderString() const
         uniform float alpha;
         uniform float frequency;
         uniform vec4 texTransform;
+        uniform vec4 color;
         void main()
         {
             vec4 color1 = vec4(1.0, 1.0, 1.0, 1.0);
-            vec4 color2 = vec4(0.945, 0.945, 0.945, 1.0);
+            vec4 color2 = color;
             vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
             vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
             float picker = abs(coord.x - coord.y);
diff --git a/cc/ShaderChromium.h b/cc/ShaderChromium.h
index 753d92a..2518382 100644
--- a/cc/ShaderChromium.h
+++ b/cc/ShaderChromium.h
@@ -338,10 +338,12 @@ public:
     int alphaLocation() const { return m_alphaLocation; }
     int texTransformLocation() const { return m_texTransformLocation; }
     int frequencyLocation() const { return m_frequencyLocation; }
+    int colorLocation() const { return m_colorLocation; }
 private:
     int m_alphaLocation;
     int m_texTransformLocation;
     int m_frequencyLocation;
+    int m_colorLocation;
 };
 
 } // namespace cc
diff --git a/cc/TiledLayerChromium.cpp b/cc/TiledLayerChromium.cpp
index 75bd57d..4a28e8a 100644
--- a/cc/TiledLayerChromium.cpp
+++ b/cc/TiledLayerChromium.cpp
@@ -215,13 +215,20 @@ void TiledLayerChromium::pushPropertiesTo(CCLayerImpl* layer)
         // 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)
+
+        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;
diff --git a/cc/TiledLayerChromiumTest.cpp b/cc/TiledLayerChromiumTest.cpp
index 5b90e2e..a30052c 100644
--- a/cc/TiledLayerChromiumTest.cpp
+++ b/cc/TiledLayerChromiumTest.cpp
@@ -181,8 +181,8 @@ TEST_F(TiledLayerChromiumTest, pushDirtyTiles)
     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));
@@ -191,8 +191,8 @@ TEST_F(TiledLayerChromiumTest, pushDirtyTiles)
     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)
@@ -213,8 +213,8 @@ TEST_F(TiledLayerChromiumTest, pushOccludedDirtyTiles)
     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));
@@ -227,8 +227,8 @@ TEST_F(TiledLayerChromiumTest, pushOccludedDirtyTiles)
     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)
@@ -243,8 +243,8 @@ TEST_F(TiledLayerChromiumTest, pushDeletedTiles)
     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());
@@ -254,16 +254,16 @@ TEST_F(TiledLayerChromiumTest, pushDeletedTiles)
     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)
@@ -281,7 +281,7 @@ TEST_F(TiledLayerChromiumTest, pushIdlePaintTiles)
     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++) {
@@ -293,7 +293,7 @@ TEST_F(TiledLayerChromiumTest, pushIdlePaintTiles)
     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.
@@ -342,18 +342,18 @@ TEST_F(TiledLayerChromiumTest, pushTilesAfterIdlePaintFailed)
     }
 
     // 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)
@@ -371,7 +371,7 @@ TEST_F(TiledLayerChromiumTest, pushIdlePaintedOccludedTiles)
     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());
 }
 
@@ -389,8 +389,8 @@ TEST_F(TiledLayerChromiumTest, pushTilesMarkedDirtyDuringPaint)
     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)
@@ -410,10 +410,10 @@ TEST_F(TiledLayerChromiumTest, pushTilesLayerMarkedDirtyDuringPaintOnNextLayer)
                   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)
@@ -432,10 +432,10 @@ TEST_F(TiledLayerChromiumTest, pushTilesLayerMarkedDirtyDuringPaintOnPreviousLay
                   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)
@@ -489,12 +489,12 @@ TEST_F(TiledLayerChromiumTest, paintSmallAnimatedLayersImmediately)
         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);
             }
         }
     }
@@ -521,7 +521,7 @@ TEST_F(TiledLayerChromiumTest, idlePaintOutOfMemory)
     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)
@@ -547,7 +547,7 @@ TEST_F(TiledLayerChromiumTest, idlePaintZeroSizedLayer)
         EXPECT_FALSE(needsUpdate);
 
         // Empty layers don't have tiles.
-        EXPECT_FALSE(layerImpl->hasTileAt(0, 0));
+        EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 0));
     }
 }
 
@@ -577,7 +577,7 @@ TEST_F(TiledLayerChromiumTest, idlePaintNonVisibleLayers)
         // 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]);
     }
 }
 
@@ -592,8 +592,8 @@ TEST_F(TiledLayerChromiumTest, invalidateFromPrepare)
     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
@@ -673,10 +673,10 @@ TEST_F(TiledLayerChromiumTest, verifyInvalidationWhenContentsScaleChanges)
     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.
@@ -690,10 +690,10 @@ TEST_F(TiledLayerChromiumTest, verifyInvalidationWhenContentsScaleChanges)
     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.
@@ -702,10 +702,10 @@ TEST_F(TiledLayerChromiumTest, verifyInvalidationWhenContentsScaleChanges)
     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)
@@ -1375,9 +1375,9 @@ TEST_F(TiledLayerChromiumTest, dontAllocateContentsWhenTargetSurfaceCantBeAlloca
 
         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();
@@ -1410,9 +1410,9 @@ TEST_F(TiledLayerChromiumTest, dontAllocateContentsWhenTargetSurfaceCantBeAlloca
 
         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();
@@ -1446,9 +1446,9 @@ TEST_F(TiledLayerChromiumTest, dontAllocateContentsWhenTargetSurfaceCantBeAlloca
 
         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();
diff --git a/cc/test/CCTiledLayerTestCommon.h b/cc/test/CCTiledLayerTestCommon.h
index 0eebeb0..9b69c5c 100644
--- a/cc/test/CCTiledLayerTestCommon.h
+++ b/cc/test/CCTiledLayerTestCommon.h
@@ -81,7 +81,7 @@ public:
     virtual ~FakeCCTiledLayerImpl();
 
     using cc::CCTiledLayerImpl::hasTileAt;
-    using cc::CCTiledLayerImpl::hasTextureIdForTileAt;
+    using cc::CCTiledLayerImpl::hasResourceIdForTileAt;
 };
 
 class FakeTiledLayerChromium : public cc::TiledLayerChromium {