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 |