[cc] Color evicted vs. invalidated checkerboard tiles differently

cc/CCTiledLayerImpl.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 "CCTiledLayerImpl.h"
 
@@ skipping 17 matching lines @@
 
 static const int debugTileBorderWidth = 1;
 static const int debugTileBorderAlpha = 100;
 static const int debugTileBorderColorRed = 80;
 static const int debugTileBorderColorGreen = 200;
 static const int debugTileBorderColorBlue = 200;
 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:
     static PassOwnPtr<DrawableTile> create() { return adoptPtr(new DrawableTile()); }
 
     CCResourceProvider::ResourceId resourceId() const { return m_resourceId; }
     void setResourceId(CCResourceProvider::ResourceId resourceId) { m_resourceId = resourceId; }
 
 private:
     DrawableTile() : m_resourceId(0) { }
@@ skipping 29 matching lines @@
     str->append(indentString(indent));
     base::StringAppendF(str, "skipsDraw: %d\n", (!m_tiler || m_skipsDraw));
     CCLayerImpl::dumpLayerProperties(str, indent);
 }
 
 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();
 }
 
 DrawableTile* CCTiledLayerImpl::tileAt(int i, int j) const
 {
     return static_cast<DrawableTile*>(m_tiler->tileAt(i, j));
 }
 
 DrawableTile* CCTiledLayerImpl::createTile(int i, int j)
@@ skipping 41 matching lines @@
             DrawableTile* tile = tileAt(i, j);
             IntRect tileRect = m_tiler->tileBounds(i, j);
             IntRect displayRect = tileRect;
             tileRect.intersect(contentRect);
 
             // Skip empty tiles.
             if (tileRect.isEmpty())
                 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;
             }
 
             IntRect tileOpaqueRect = tile->opaqueRect();
             tileOpaqueRect.intersect(contentRect);
 
             // Keep track of how the top left has moved, so the texture can be
             // offset the same amount.
             IntSize displayOffset = tileRect.minXMinYCorner() - displayRect.minXMinYCorner();
@@ skipping 29 matching lines @@
 
 void CCTiledLayerImpl::pushTileProperties(int i, int j, CCResourceProvider::ResourceId resourceId, const IntRect& opaqueRect)
 {
     DrawableTile* tile = tileAt(i, j);
     if (!tile)
         tile = createTile(i, j);
     tile->setResourceId(resourceId);
     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)
         return Region();
     if (opaque())
         return visibleContentRect();
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 }
 
 void CCTiledLayerImpl::didLoseContext()
 {
     m_tiler->reset();
 }
 
 const char* CCTiledLayerImpl::layerTypeAsString() const
 {
     return "ContentLayer";
 }
 
 } // namespace cc
 
 #endif // USE(ACCELERATED_COMPOSITING)