| OLD | NEW |
| (Empty) |
| 1 // Copyright 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/macros.h" | |
| 6 | |
| 7 #include "cc/debug/debug_colors.h" | |
| 8 | |
| 9 #include "cc/trees/layer_tree_impl.h" | |
| 10 | |
| 11 namespace cc { | |
| 12 | |
| 13 static float Scale(float width, const LayerTreeImpl* tree_impl) { | |
| 14 return width * (tree_impl ? tree_impl->device_scale_factor() : 1); | |
| 15 } | |
| 16 | |
| 17 // ======= Layer border colors ======= | |
| 18 | |
| 19 // Tiled content layers are orange. | |
| 20 SkColor DebugColors::TiledContentLayerBorderColor() { | |
| 21 return SkColorSetARGB(128, 255, 128, 0); | |
| 22 } | |
| 23 int DebugColors::TiledContentLayerBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 24 return Scale(2, tree_impl); | |
| 25 } | |
| 26 | |
| 27 // Image layers are olive. | |
| 28 SkColor DebugColors::ImageLayerBorderColor() { | |
| 29 return SkColorSetARGB(128, 128, 128, 0); | |
| 30 } | |
| 31 int DebugColors::ImageLayerBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 32 return Scale(2, tree_impl); | |
| 33 } | |
| 34 | |
| 35 // Non-tiled content layers area green. | |
| 36 SkColor DebugColors::ContentLayerBorderColor() { | |
| 37 return SkColorSetARGB(128, 0, 128, 32); | |
| 38 } | |
| 39 int DebugColors::ContentLayerBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 40 return Scale(2, tree_impl); | |
| 41 } | |
| 42 | |
| 43 // Masking layers are pale blue and wide. | |
| 44 SkColor DebugColors::MaskingLayerBorderColor() { | |
| 45 return SkColorSetARGB(48, 128, 255, 255); | |
| 46 } | |
| 47 int DebugColors::MaskingLayerBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 48 return Scale(20, tree_impl); | |
| 49 } | |
| 50 | |
| 51 // Other container layers are yellow. | |
| 52 SkColor DebugColors::ContainerLayerBorderColor() { | |
| 53 return SkColorSetARGB(192, 255, 255, 0); | |
| 54 } | |
| 55 int DebugColors::ContainerLayerBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 56 return Scale(2, tree_impl); | |
| 57 } | |
| 58 | |
| 59 // Surface layers are a blue-ish green. | |
| 60 SkColor DebugColors::SurfaceLayerBorderColor() { | |
| 61 return SkColorSetARGB(128, 0, 255, 136); | |
| 62 } | |
| 63 int DebugColors::SurfaceLayerBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 64 return Scale(2, tree_impl); | |
| 65 } | |
| 66 | |
| 67 // Render surfaces are blue. | |
| 68 SkColor DebugColors::SurfaceBorderColor() { | |
| 69 return SkColorSetARGB(100, 0, 0, 255); | |
| 70 } | |
| 71 int DebugColors::SurfaceBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 72 return Scale(2, tree_impl); | |
| 73 } | |
| 74 | |
| 75 // Replicas of render surfaces are purple. | |
| 76 SkColor DebugColors::SurfaceReplicaBorderColor() { | |
| 77 return SkColorSetARGB(100, 160, 0, 255); | |
| 78 } | |
| 79 int DebugColors::SurfaceReplicaBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 80 return Scale(2, tree_impl); | |
| 81 } | |
| 82 | |
| 83 // ======= Tile colors ======= | |
| 84 | |
| 85 // High-res tile borders are cyan. | |
| 86 SkColor DebugColors::HighResTileBorderColor() { | |
| 87 return SkColorSetARGB(100, 80, 200, 200); | |
| 88 } | |
| 89 int DebugColors::HighResTileBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 90 return Scale(1, tree_impl); | |
| 91 } | |
| 92 | |
| 93 // Low-res tile borders are purple. | |
| 94 SkColor DebugColors::LowResTileBorderColor() { | |
| 95 return SkColorSetARGB(100, 212, 83, 192); | |
| 96 } | |
| 97 int DebugColors::LowResTileBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 98 return Scale(2, tree_impl); | |
| 99 } | |
| 100 | |
| 101 // Other high-resolution tile borders are yellow. | |
| 102 SkColor DebugColors::ExtraHighResTileBorderColor() { | |
| 103 return SkColorSetARGB(100, 239, 231, 20); | |
| 104 } | |
| 105 int DebugColors::ExtraHighResTileBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 106 return Scale(2, tree_impl); | |
| 107 } | |
| 108 | |
| 109 // Other low-resolution tile borders are green. | |
| 110 SkColor DebugColors::ExtraLowResTileBorderColor() { | |
| 111 return SkColorSetARGB(100, 93, 186, 18); | |
| 112 } | |
| 113 int DebugColors::ExtraLowResTileBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 114 return Scale(2, tree_impl); | |
| 115 } | |
| 116 | |
| 117 // Missing tile borders are dark grey. | |
| 118 SkColor DebugColors::MissingTileBorderColor() { | |
| 119 return SkColorSetARGB(64, 64, 64, 0); | |
| 120 } | |
| 121 int DebugColors::MissingTileBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 122 return Scale(1, tree_impl); | |
| 123 } | |
| 124 | |
| 125 // Solid color tile borders are grey. | |
| 126 SkColor DebugColors::SolidColorTileBorderColor() { | |
| 127 return SkColorSetARGB(128, 128, 128, 128); | |
| 128 } | |
| 129 int DebugColors::SolidColorTileBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 130 return Scale(1, tree_impl); | |
| 131 } | |
| 132 | |
| 133 // OOM tile borders are red. | |
| 134 SkColor DebugColors::OOMTileBorderColor() { | |
| 135 return SkColorSetARGB(100, 255, 0, 0); | |
| 136 } | |
| 137 int DebugColors::OOMTileBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 138 return Scale(1, tree_impl); | |
| 139 } | |
| 140 | |
| 141 // Direct picture borders are chartreuse. | |
| 142 SkColor DebugColors::DirectPictureBorderColor() { | |
| 143 return SkColorSetARGB(255, 127, 255, 0); | |
| 144 } | |
| 145 int DebugColors::DirectPictureBorderWidth(const LayerTreeImpl* tree_impl) { | |
| 146 return Scale(1, tree_impl); | |
| 147 } | |
| 148 | |
| 149 // ======= Checkerboard colors ======= | |
| 150 | |
| 151 // Non-debug checkerboards are grey. | |
| 152 SkColor DebugColors::DefaultCheckerboardColor() { | |
| 153 return SkColorSetRGB(241, 241, 241); | |
| 154 } | |
| 155 | |
| 156 // Invalidated tiles get sky blue checkerboards. | |
| 157 SkColor DebugColors::InvalidatedTileCheckerboardColor() { | |
| 158 return SkColorSetRGB(128, 200, 245); | |
| 159 } | |
| 160 | |
| 161 // Evicted tiles get pale red checkerboards. | |
| 162 SkColor DebugColors::EvictedTileCheckerboardColor() { | |
| 163 return SkColorSetRGB(255, 200, 200); | |
| 164 } | |
| 165 | |
| 166 // ======= Debug rect colors ======= | |
| 167 | |
| 168 static SkColor FadedGreen(int initial_value, int step) { | |
| 169 DCHECK_GE(step, 0); | |
| 170 DCHECK_LE(step, DebugColors::kFadeSteps); | |
| 171 int value = step * initial_value / DebugColors::kFadeSteps; | |
| 172 return SkColorSetARGB(value, 0, 195, 0); | |
| 173 } | |
| 174 // Paint rects in green. | |
| 175 SkColor DebugColors::PaintRectBorderColor(int step) { | |
| 176 return FadedGreen(255, step); | |
| 177 } | |
| 178 int DebugColors::PaintRectBorderWidth() { return 2; } | |
| 179 SkColor DebugColors::PaintRectFillColor(int step) { | |
| 180 return FadedGreen(60, step); | |
| 181 } | |
| 182 | |
| 183 // Property-changed rects in blue. | |
| 184 SkColor DebugColors::PropertyChangedRectBorderColor() { | |
| 185 return SkColorSetARGB(255, 0, 0, 255); | |
| 186 } | |
| 187 int DebugColors::PropertyChangedRectBorderWidth() { return 2; } | |
| 188 SkColor DebugColors::PropertyChangedRectFillColor() { | |
| 189 return SkColorSetARGB(30, 0, 0, 255); | |
| 190 } | |
| 191 | |
| 192 // Surface damage rects in yellow-orange. | |
| 193 SkColor DebugColors::SurfaceDamageRectBorderColor() { | |
| 194 return SkColorSetARGB(255, 200, 100, 0); | |
| 195 } | |
| 196 int DebugColors::SurfaceDamageRectBorderWidth() { return 2; } | |
| 197 SkColor DebugColors::SurfaceDamageRectFillColor() { | |
| 198 return SkColorSetARGB(30, 200, 100, 0); | |
| 199 } | |
| 200 | |
| 201 // Surface replica screen space rects in green. | |
| 202 SkColor DebugColors::ScreenSpaceLayerRectBorderColor() { | |
| 203 return SkColorSetARGB(255, 100, 200, 0); | |
| 204 } | |
| 205 int DebugColors::ScreenSpaceLayerRectBorderWidth() { return 2; } | |
| 206 SkColor DebugColors::ScreenSpaceLayerRectFillColor() { | |
| 207 return SkColorSetARGB(30, 100, 200, 0); | |
| 208 } | |
| 209 | |
| 210 // Layer screen space rects in purple. | |
| 211 SkColor DebugColors::ScreenSpaceSurfaceReplicaRectBorderColor() { | |
| 212 return SkColorSetARGB(255, 100, 0, 200); | |
| 213 } | |
| 214 int DebugColors::ScreenSpaceSurfaceReplicaRectBorderWidth() { return 2; } | |
| 215 SkColor DebugColors::ScreenSpaceSurfaceReplicaRectFillColor() { | |
| 216 return SkColorSetARGB(10, 100, 0, 200); | |
| 217 } | |
| 218 | |
| 219 // Touch-event-handler rects in yellow. | |
| 220 SkColor DebugColors::TouchEventHandlerRectBorderColor() { | |
| 221 return SkColorSetARGB(255, 239, 229, 60); | |
| 222 } | |
| 223 int DebugColors::TouchEventHandlerRectBorderWidth() { return 2; } | |
| 224 SkColor DebugColors::TouchEventHandlerRectFillColor() { | |
| 225 return SkColorSetARGB(30, 239, 229, 60); | |
| 226 } | |
| 227 | |
| 228 // Wheel-event-handler rects in green. | |
| 229 SkColor DebugColors::WheelEventHandlerRectBorderColor() { | |
| 230 return SkColorSetARGB(255, 189, 209, 57); | |
| 231 } | |
| 232 int DebugColors::WheelEventHandlerRectBorderWidth() { return 2; } | |
| 233 SkColor DebugColors::WheelEventHandlerRectFillColor() { | |
| 234 return SkColorSetARGB(30, 189, 209, 57); | |
| 235 } | |
| 236 | |
| 237 // Scroll-event-handler rects in teal. | |
| 238 SkColor DebugColors::ScrollEventHandlerRectBorderColor() { | |
| 239 return SkColorSetARGB(255, 24, 167, 181); | |
| 240 } | |
| 241 int DebugColors::ScrollEventHandlerRectBorderWidth() { return 2; } | |
| 242 SkColor DebugColors::ScrollEventHandlerRectFillColor() { | |
| 243 return SkColorSetARGB(30, 24, 167, 181); | |
| 244 } | |
| 245 | |
| 246 // Non-fast-scrollable rects in orange. | |
| 247 SkColor DebugColors::NonFastScrollableRectBorderColor() { | |
| 248 return SkColorSetARGB(255, 238, 163, 59); | |
| 249 } | |
| 250 int DebugColors::NonFastScrollableRectBorderWidth() { return 2; } | |
| 251 SkColor DebugColors::NonFastScrollableRectFillColor() { | |
| 252 return SkColorSetARGB(30, 238, 163, 59); | |
| 253 } | |
| 254 | |
| 255 // Animation bounds are lime-green. | |
| 256 SkColor DebugColors::LayerAnimationBoundsBorderColor() { | |
| 257 return SkColorSetARGB(255, 112, 229, 0); | |
| 258 } | |
| 259 int DebugColors::LayerAnimationBoundsBorderWidth() { return 2; } | |
| 260 SkColor DebugColors::LayerAnimationBoundsFillColor() { | |
| 261 return SkColorSetARGB(30, 112, 229, 0); | |
| 262 } | |
| 263 | |
| 264 // Non-Painted rects in cyan. | |
| 265 SkColor DebugColors::NonPaintedFillColor() { return SK_ColorCYAN; } | |
| 266 | |
| 267 // Missing picture rects in magenta. | |
| 268 SkColor DebugColors::MissingPictureFillColor() { return SK_ColorMAGENTA; } | |
| 269 | |
| 270 // Missing resize invalidations are in salmon pink. | |
| 271 SkColor DebugColors::MissingResizeInvalidations() { | |
| 272 return SkColorSetARGB(255, 255, 155, 170); | |
| 273 } | |
| 274 | |
| 275 // Picture borders in transparent blue. | |
| 276 SkColor DebugColors::PictureBorderColor() { | |
| 277 return SkColorSetARGB(100, 0, 0, 200); | |
| 278 } | |
| 279 | |
| 280 // ======= HUD widget colors ======= | |
| 281 | |
| 282 SkColor DebugColors::HUDBackgroundColor() { | |
| 283 return SkColorSetARGB(215, 17, 17, 17); | |
| 284 } | |
| 285 SkColor DebugColors::HUDSeparatorLineColor() { | |
| 286 return SkColorSetARGB(255, 130, 130, 130); | |
| 287 } | |
| 288 SkColor DebugColors::HUDIndicatorLineColor() { | |
| 289 return SkColorSetARGB(255, 80, 80, 80); | |
| 290 } | |
| 291 | |
| 292 SkColor DebugColors::PlatformLayerTreeTextColor() { return SK_ColorRED; } | |
| 293 SkColor DebugColors::FPSDisplayTextAndGraphColor() { return SK_ColorRED; } | |
| 294 SkColor DebugColors::MemoryDisplayTextColor() { | |
| 295 return SkColorSetARGB(255, 220, 220, 220); | |
| 296 } | |
| 297 | |
| 298 // Paint time display in green (similar to paint times in the WebInspector) | |
| 299 SkColor DebugColors::PaintTimeDisplayTextAndGraphColor() { | |
| 300 return SkColorSetRGB(75, 155, 55); | |
| 301 } | |
| 302 | |
| 303 } // namespace cc | |
| OLD | NEW |