cc: Create cc::DebugColors class to hold all the debugging color/width constants.

cc/tiled_layer_impl.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 "cc/tiled_layer_impl.h"
 
 #include "base/basictypes.h"
 #include "base/stringprintf.h"
 #include "cc/append_quads_data.h"
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
+#include "cc/debug_colors.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/quad_f.h"
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
-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;
+// Non-debug checkerboards are grey.
+const SkColor kTileCheckerboardColor = SkColorSetRGB(241, 241, 241);
 
 class DrawableTile : public LayerTilingData::Tile {
 public:
     static scoped_ptr<DrawableTile> create() { return make_scoped_ptr(new DrawableTile()); }
 
     ResourceProvider::ResourceId resourceId() const { return m_resourceId; }
     void setResourceId(ResourceProvider::ResourceId resourceId) { m_resourceId = resourceId; }
     bool contentsSwizzled() { return m_contentsSwizzled; }
     void setContentsSwizzled(bool contentsSwizzled) { m_contentsSwizzled = contentsSwizzled; }
 
@@ skipping 55 matching lines @@
 DrawableTile* TiledLayerImpl::createTile(int i, int j)
 {
     scoped_ptr<DrawableTile> tile(DrawableTile::create());
     DrawableTile* addedTile = tile.get();
     m_tiler->addTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
     return addedTile;
 }
 
 void TiledLayerImpl::getDebugBorderProperties(SkColor* color, float* width) const
 {
-    // Tiled content layers are orange.
-    *color = SkColorSetARGBInline(128, 255, 128, 0);
-    *width = 2;
+    *color = DebugColors::kTiledContentLayerBorderColor();
+    *width = DebugColors::kTiledContentLayerBorderWidth(layerTreeHostImpl());
 }
 
 void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
 {
     const gfx::Rect& contentRect = visibleContentRect();
 
     if (!m_tiler || m_tiler->hasEmptyBounds() || contentRect.IsEmpty())
         return;
 
     SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
     appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
 
     int left, top, right, bottom;
     m_tiler->contentRectToTileIndices(contentRect, left, top, right, bottom);
 
     if (showDebugBorders()) {
         for (int j = top; j <= bottom; ++j) {
             for (int i = left; i <= right; ++i) {
                 DrawableTile* tile = tileAt(i, j);
                 gfx::Rect tileRect = m_tiler->tileBounds(i, j);
                 SkColor borderColor;
+                float borderWidth;
 
-                if (m_skipsDraw || !tile || !tile->resourceId())
-                    borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderMissingTileColorRed, debugTileBorderMissingTileColorGreen, debugTileBorderMissingTileColorBlue);
-                else
-                    borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderColorRed, debugTileBorderColorGreen, debugTileBorderColorBlue);
-                quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, debugTileBorderWidth).PassAs<DrawQuad>(), appendQuadsData);
+                if (m_skipsDraw || !tile || !tile->resourceId()) {
+                    borderColor = DebugColors::kMissingTileBorderColor();
+                    borderWidth = DebugColors::kMissingTileBorderWidth(layerTreeHostImpl());
+                } else {
+                    borderColor = DebugColors::kTileBorderColor();
+                    borderWidth = DebugColors::kTileBorderWidth(layerTreeHostImpl());
+                }
+                quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, borderWidth).PassAs<DrawQuad>(), appendQuadsData);
             }
         }
     }
 
     if (m_skipsDraw)
         return;
 
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             DrawableTile* tile = tileAt(i, j);
             gfx::Rect tileRect = m_tiler->tileBounds(i, j);
             gfx::Rect displayRect = tileRect;
             tileRect.Intersect(contentRect);
 
             // Skip empty tiles.
             if (tileRect.IsEmpty())
                 continue;
 
             if (!tile || !tile->resourceId()) {
                 if (drawCheckerboardForMissingTiles()) {
-                    SkColor defaultColor = SkColorSetRGB(defaultCheckerboardColorRed, defaultCheckerboardColorGreen, defaultCheckerboardColorBlue);
-                    SkColor evictedColor = SkColorSetRGB(debugTileEvictedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
-                    SkColor invalidatedColor = SkColorSetRGB(debugTileInvalidatedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
-
                     SkColor checkerColor;
                     if (showDebugBorders())
-                        checkerColor = tile ? invalidatedColor : evictedColor;
+                        checkerColor = tile ? DebugColors::kInvalidatedTileCheckerboardColor() : DebugColors::kEvictedTileCheckerboardColor();
                     else
-                        checkerColor = defaultColor;
+                        checkerColor = kTileCheckerboardColor;
 
                     appendQuadsData.hadMissingTiles |= quadSink.append(CheckerboardDrawQuad::create(sharedQuadState, tileRect, checkerColor).PassAs<DrawQuad>(), appendQuadsData);
                 } else
                     appendQuadsData.hadMissingTiles |= quadSink.append(SolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()).PassAs<DrawQuad>(), appendQuadsData);
                 continue;
             }
 
             gfx::Rect tileOpaqueRect = tile->opaqueRect();
             tileOpaqueRect.Intersect(contentRect);
 
@@ skipping 62 matching lines @@
 {
     m_tiler->reset();
 }
 
 const char* TiledLayerImpl::layerTypeAsString() const
 {
     return "ContentLayer";
 }
 
 }  // namespace cc