1 // Copyright 2013 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 "build/build_config.h"
6 #include "cc/layers/content_layer.h"
7 #include "cc/layers/solid_color_layer.h"
8 #include "cc/layers/texture_layer.h"
9 #include "cc/output/copy_output_request.h"
10 #include "cc/output/copy_output_result.h"
11 #include "cc/test/layer_tree_pixel_test.h"
12 #include "cc/test/paths.h"
13 #include "cc/test/solid_color_content_layer_client.h"
14 #include "cc/trees/layer_tree_impl.h"
15
16 #if !defined(OS_ANDROID)
17
18 namespace cc {
19 namespace {
20
21 class LayerTreeHostReadbackPixelTest : public LayerTreePixelTest {
22 protected:
CreateCopyOutputRequest()23 virtual scoped_ptr<CopyOutputRequest> CreateCopyOutputRequest() OVERRIDE {
24 scoped_ptr<CopyOutputRequest> request;
25
26 switch (test_type_) {
27 case GL_WITH_BITMAP:
28 case SOFTWARE_WITH_BITMAP:
29 request = CopyOutputRequest::CreateBitmapRequest(
30 base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsBitmap,
31 base::Unretained(this)));
32 break;
33 case SOFTWARE_WITH_DEFAULT:
34 request = CopyOutputRequest::CreateRequest(
35 base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsBitmap,
36 base::Unretained(this)));
37 break;
38 case GL_WITH_DEFAULT:
39 request = CopyOutputRequest::CreateRequest(
40 base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsTexture,
41 base::Unretained(this)));
42 break;
43 }
44
45 if (!copy_subrect_.IsEmpty())
46 request->set_area(copy_subrect_);
47 return request.Pass();
48 }
49
ReadbackResultAsBitmap(scoped_ptr<CopyOutputResult> result)50 void ReadbackResultAsBitmap(scoped_ptr<CopyOutputResult> result) {
51 EXPECT_TRUE(proxy()->IsMainThread());
52 EXPECT_TRUE(result->HasBitmap());
53 result_bitmap_ = result->TakeBitmap().Pass();
54 EndTest();
55 }
56
ReadbackResultAsTexture(scoped_ptr<CopyOutputResult> result)57 void ReadbackResultAsTexture(scoped_ptr<CopyOutputResult> result) {
58 EXPECT_TRUE(proxy()->IsMainThread());
59 EXPECT_TRUE(result->HasTexture());
60
61 TextureMailbox texture_mailbox;
62 scoped_ptr<SingleReleaseCallback> release_callback;
63 result->TakeTexture(&texture_mailbox, &release_callback);
64 EXPECT_TRUE(texture_mailbox.IsValid());
65 EXPECT_TRUE(texture_mailbox.IsTexture());
66
67 scoped_ptr<SkBitmap> bitmap =
68 CopyTextureMailboxToBitmap(result->size(), texture_mailbox);
69 release_callback->Run(0, false);
70
71 ReadbackResultAsBitmap(CopyOutputResult::CreateBitmapResult(bitmap.Pass()));
72 }
73
74 gfx::Rect copy_subrect_;
75 };
76
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackRootLayer_Software)77 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_Software) {
78 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
79 gfx::Rect(200, 200), SK_ColorWHITE);
80
81 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
82 gfx::Rect(200, 200), SK_ColorGREEN);
83 background->AddChild(green);
84
85 RunPixelTest(SOFTWARE_WITH_DEFAULT,
86 background,
87 base::FilePath(FILE_PATH_LITERAL(
88 "green.png")));
89 }
90
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackRootLayer_Software_Bitmap)91 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_Software_Bitmap) {
92 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
93 gfx::Rect(200, 200), SK_ColorWHITE);
94
95 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
96 gfx::Rect(200, 200), SK_ColorGREEN);
97 background->AddChild(green);
98
99 RunPixelTest(SOFTWARE_WITH_BITMAP,
100 background,
101 base::FilePath(FILE_PATH_LITERAL(
102 "green.png")));
103 }
104
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackRootLayer_GL_Bitmap)105 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_GL_Bitmap) {
106 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
107 gfx::Rect(200, 200), SK_ColorWHITE);
108
109 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
110 gfx::Rect(200, 200), SK_ColorGREEN);
111 background->AddChild(green);
112
113 RunPixelTest(GL_WITH_BITMAP,
114 background,
115 base::FilePath(FILE_PATH_LITERAL(
116 "green.png")));
117 }
118
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackRootLayer_GL)119 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_GL) {
120 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
121 gfx::Rect(200, 200), SK_ColorWHITE);
122
123 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
124 gfx::Rect(200, 200), SK_ColorGREEN);
125 background->AddChild(green);
126
127 RunPixelTest(GL_WITH_DEFAULT,
128 background,
129 base::FilePath(FILE_PATH_LITERAL(
130 "green.png")));
131 }
132
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackRootLayerWithChild_Software)133 TEST_F(LayerTreeHostReadbackPixelTest,
134 ReadbackRootLayerWithChild_Software) {
135 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
136 gfx::Rect(200, 200), SK_ColorWHITE);
137
138 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
139 gfx::Rect(200, 200), SK_ColorGREEN);
140 background->AddChild(green);
141
142 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
143 gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
144 green->AddChild(blue);
145
146 RunPixelTest(SOFTWARE_WITH_DEFAULT,
147 background,
148 base::FilePath(FILE_PATH_LITERAL(
149 "green_with_blue_corner.png")));
150 }
151
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackRootLayerWithChild_GL_Bitmap)152 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayerWithChild_GL_Bitmap) {
153 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
154 gfx::Rect(200, 200), SK_ColorWHITE);
155
156 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
157 gfx::Rect(200, 200), SK_ColorGREEN);
158 background->AddChild(green);
159
160 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
161 gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
162 green->AddChild(blue);
163
164 RunPixelTest(GL_WITH_BITMAP,
165 background,
166 base::FilePath(FILE_PATH_LITERAL(
167 "green_with_blue_corner.png")));
168 }
169
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackRootLayerWithChild_GL)170 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayerWithChild_GL) {
171 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
172 gfx::Rect(200, 200), SK_ColorWHITE);
173
174 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
175 gfx::Rect(200, 200), SK_ColorGREEN);
176 background->AddChild(green);
177
178 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
179 gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
180 green->AddChild(blue);
181
182 RunPixelTest(GL_WITH_DEFAULT,
183 background,
184 base::FilePath(FILE_PATH_LITERAL(
185 "green_with_blue_corner.png")));
186 }
187
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackNonRootLayer_Software)188 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayer_Software) {
189 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
190 gfx::Rect(200, 200), SK_ColorWHITE);
191
192 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
193 gfx::Rect(200, 200), SK_ColorGREEN);
194 background->AddChild(green);
195
196 RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
197 background,
198 green.get(),
199 base::FilePath(FILE_PATH_LITERAL(
200 "green.png")));
201 }
202
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackNonRootLayer_GL_Bitmap)203 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayer_GL_Bitmap) {
204 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
205 gfx::Rect(200, 200), SK_ColorWHITE);
206
207 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
208 gfx::Rect(200, 200), SK_ColorGREEN);
209 background->AddChild(green);
210
211 RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
212 background,
213 green.get(),
214 base::FilePath(FILE_PATH_LITERAL(
215 "green.png")));
216 }
217
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackNonRootLayer_GL)218 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayer_GL) {
219 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
220 gfx::Rect(200, 200), SK_ColorWHITE);
221
222 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
223 gfx::Rect(200, 200), SK_ColorGREEN);
224 background->AddChild(green);
225
226 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
227 background,
228 green.get(),
229 base::FilePath(FILE_PATH_LITERAL(
230 "green.png")));
231 }
232
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSmallNonRootLayer_Software)233 TEST_F(LayerTreeHostReadbackPixelTest,
234 ReadbackSmallNonRootLayer_Software) {
235 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
236 gfx::Rect(200, 200), SK_ColorWHITE);
237
238 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
239 gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
240 background->AddChild(green);
241
242 RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
243 background,
244 green.get(),
245 base::FilePath(FILE_PATH_LITERAL(
246 "green_small.png")));
247 }
248
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSmallNonRootLayer_GL_Bitmap)249 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSmallNonRootLayer_GL_Bitmap) {
250 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
251 gfx::Rect(200, 200), SK_ColorWHITE);
252
253 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
254 gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
255 background->AddChild(green);
256
257 RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
258 background,
259 green.get(),
260 base::FilePath(FILE_PATH_LITERAL(
261 "green_small.png")));
262 }
263
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSmallNonRootLayer_GL)264 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSmallNonRootLayer_GL) {
265 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
266 gfx::Rect(200, 200), SK_ColorWHITE);
267
268 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
269 gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
270 background->AddChild(green);
271
272 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
273 background,
274 green.get(),
275 base::FilePath(FILE_PATH_LITERAL(
276 "green_small.png")));
277 }
278
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSmallNonRootLayerWithChild_Software)279 TEST_F(LayerTreeHostReadbackPixelTest,
280 ReadbackSmallNonRootLayerWithChild_Software) {
281 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
282 gfx::Rect(200, 200), SK_ColorWHITE);
283
284 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
285 gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
286 background->AddChild(green);
287
288 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
289 gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
290 green->AddChild(blue);
291
292 RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
293 background,
294 green.get(),
295 base::FilePath(FILE_PATH_LITERAL(
296 "green_small_with_blue_corner.png")));
297 }
298
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSmallNonRootLayerWithChild_GL_Bitmap)299 TEST_F(LayerTreeHostReadbackPixelTest,
300 ReadbackSmallNonRootLayerWithChild_GL_Bitmap) {
301 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
302 gfx::Rect(200, 200), SK_ColorWHITE);
303
304 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
305 gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
306 background->AddChild(green);
307
308 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
309 gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
310 green->AddChild(blue);
311
312 RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
313 background,
314 green.get(),
315 base::FilePath(FILE_PATH_LITERAL(
316 "green_small_with_blue_corner.png")));
317 }
318
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSmallNonRootLayerWithChild_GL)319 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSmallNonRootLayerWithChild_GL) {
320 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
321 gfx::Rect(200, 200), SK_ColorWHITE);
322
323 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
324 gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
325 background->AddChild(green);
326
327 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
328 gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
329 green->AddChild(blue);
330
331 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
332 background,
333 green.get(),
334 base::FilePath(FILE_PATH_LITERAL(
335 "green_small_with_blue_corner.png")));
336 }
337
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSubtreeSurroundsTargetLayer_Software)338 TEST_F(LayerTreeHostReadbackPixelTest,
339 ReadbackSubtreeSurroundsTargetLayer_Software) {
340 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
341 gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
342
343 scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
344 gfx::Rect(100, 100, 100, 100), SK_ColorRED);
345 background->AddChild(target);
346
347 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
348 gfx::Rect(-100, -100, 300, 300), SK_ColorGREEN);
349 target->AddChild(green);
350
351 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
352 gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
353 target->AddChild(blue);
354
355 copy_subrect_ = gfx::Rect(0, 0, 100, 100);
356 RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
357 background,
358 target.get(),
359 base::FilePath(FILE_PATH_LITERAL(
360 "green_small_with_blue_corner.png")));
361 }
362
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSubtreeSurroundsLayer_GL_Bitmap)363 TEST_F(LayerTreeHostReadbackPixelTest,
364 ReadbackSubtreeSurroundsLayer_GL_Bitmap) {
365 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
366 gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
367
368 scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
369 gfx::Rect(100, 100, 100, 100), SK_ColorRED);
370 background->AddChild(target);
371
372 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
373 gfx::Rect(-100, -100, 300, 300), SK_ColorGREEN);
374 target->AddChild(green);
375
376 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
377 gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
378 target->AddChild(blue);
379
380 copy_subrect_ = gfx::Rect(0, 0, 100, 100);
381 RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
382 background,
383 target.get(),
384 base::FilePath(FILE_PATH_LITERAL(
385 "green_small_with_blue_corner.png")));
386 }
387
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSubtreeSurroundsTargetLayer_GL)388 TEST_F(LayerTreeHostReadbackPixelTest,
389 ReadbackSubtreeSurroundsTargetLayer_GL) {
390 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
391 gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
392
393 scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
394 gfx::Rect(100, 100, 100, 100), SK_ColorRED);
395 background->AddChild(target);
396
397 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
398 gfx::Rect(-100, -100, 300, 300), SK_ColorGREEN);
399 target->AddChild(green);
400
401 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
402 gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
403 target->AddChild(blue);
404
405 copy_subrect_ = gfx::Rect(0, 0, 100, 100);
406 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
407 background,
408 target.get(),
409 base::FilePath(FILE_PATH_LITERAL(
410 "green_small_with_blue_corner.png")));
411 }
412
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSubtreeExtendsBeyondTargetLayer_Software)413 TEST_F(LayerTreeHostReadbackPixelTest,
414 ReadbackSubtreeExtendsBeyondTargetLayer_Software) {
415 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
416 gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
417
418 scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
419 gfx::Rect(50, 50, 150, 150), SK_ColorRED);
420 background->AddChild(target);
421
422 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
423 gfx::Rect(50, 50, 200, 200), SK_ColorGREEN);
424 target->AddChild(green);
425
426 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
427 gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
428 target->AddChild(blue);
429
430 copy_subrect_ = gfx::Rect(50, 50, 100, 100);
431 RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
432 background,
433 target.get(),
434 base::FilePath(FILE_PATH_LITERAL(
435 "green_small_with_blue_corner.png")));
436 }
437
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSubtreeExtendsBeyondTargetLayer_GL_Bitmap)438 TEST_F(LayerTreeHostReadbackPixelTest,
439 ReadbackSubtreeExtendsBeyondTargetLayer_GL_Bitmap) {
440 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
441 gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
442
443 scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
444 gfx::Rect(50, 50, 150, 150), SK_ColorRED);
445 background->AddChild(target);
446
447 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
448 gfx::Rect(50, 50, 200, 200), SK_ColorGREEN);
449 target->AddChild(green);
450
451 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
452 gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
453 target->AddChild(blue);
454
455 copy_subrect_ = gfx::Rect(50, 50, 100, 100);
456 RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
457 background,
458 target.get(),
459 base::FilePath(FILE_PATH_LITERAL(
460 "green_small_with_blue_corner.png")));
461 }
462
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSubtreeExtendsBeyondTargetLayer_GL)463 TEST_F(LayerTreeHostReadbackPixelTest,
464 ReadbackSubtreeExtendsBeyondTargetLayer_GL) {
465 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
466 gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
467
468 scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
469 gfx::Rect(50, 50, 150, 150), SK_ColorRED);
470 background->AddChild(target);
471
472 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
473 gfx::Rect(50, 50, 200, 200), SK_ColorGREEN);
474 target->AddChild(green);
475
476 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
477 gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
478 target->AddChild(blue);
479
480 copy_subrect_ = gfx::Rect(50, 50, 100, 100);
481 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
482 background,
483 target.get(),
484 base::FilePath(FILE_PATH_LITERAL(
485 "green_small_with_blue_corner.png")));
486 }
487
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSubrect_Software)488 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSubrect_Software) {
489 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
490 gfx::Rect(200, 200), SK_ColorWHITE);
491
492 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
493 gfx::Rect(200, 200), SK_ColorGREEN);
494 background->AddChild(green);
495
496 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
497 gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
498 green->AddChild(blue);
499
500 // Grab the middle of the root layer.
501 copy_subrect_ = gfx::Rect(50, 50, 100, 100);
502
503 RunPixelTest(SOFTWARE_WITH_DEFAULT,
504 background,
505 base::FilePath(FILE_PATH_LITERAL(
506 "green_small_with_blue_corner.png")));
507 }
508
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSubrect_GL_Bitmap)509 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSubrect_GL_Bitmap) {
510 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
511 gfx::Rect(200, 200), SK_ColorWHITE);
512
513 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
514 gfx::Rect(200, 200), SK_ColorGREEN);
515 background->AddChild(green);
516
517 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
518 gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
519 green->AddChild(blue);
520
521 // Grab the middle of the root layer.
522 copy_subrect_ = gfx::Rect(50, 50, 100, 100);
523
524 RunPixelTest(GL_WITH_BITMAP,
525 background,
526 base::FilePath(FILE_PATH_LITERAL(
527 "green_small_with_blue_corner.png")));
528 }
529
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackSubrect_GL)530 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSubrect_GL) {
531 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
532 gfx::Rect(200, 200), SK_ColorWHITE);
533
534 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
535 gfx::Rect(200, 200), SK_ColorGREEN);
536 background->AddChild(green);
537
538 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
539 gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
540 green->AddChild(blue);
541
542 // Grab the middle of the root layer.
543 copy_subrect_ = gfx::Rect(50, 50, 100, 100);
544
545 RunPixelTest(GL_WITH_DEFAULT,
546 background,
547 base::FilePath(FILE_PATH_LITERAL(
548 "green_small_with_blue_corner.png")));
549 }
550
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackNonRootLayerSubrect_Software)551 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerSubrect_Software) {
552 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
553 gfx::Rect(200, 200), SK_ColorWHITE);
554
555 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
556 gfx::Rect(25, 25, 150, 150), SK_ColorGREEN);
557 background->AddChild(green);
558
559 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
560 gfx::Rect(75, 75, 50, 50), SK_ColorBLUE);
561 green->AddChild(blue);
562
563 // Grab the middle of the green layer.
564 copy_subrect_ = gfx::Rect(25, 25, 100, 100);
565
566 RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
567 background,
568 green.get(),
569 base::FilePath(FILE_PATH_LITERAL(
570 "green_small_with_blue_corner.png")));
571 }
572
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackNonRootLayerSubrect_GL_Bitmap)573 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerSubrect_GL_Bitmap) {
574 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
575 gfx::Rect(200, 200), SK_ColorWHITE);
576
577 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
578 gfx::Rect(25, 25, 150, 150), SK_ColorGREEN);
579 background->AddChild(green);
580
581 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
582 gfx::Rect(75, 75, 50, 50), SK_ColorBLUE);
583 green->AddChild(blue);
584
585 // Grab the middle of the green layer.
586 copy_subrect_ = gfx::Rect(25, 25, 100, 100);
587
588 RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
589 background,
590 green.get(),
591 base::FilePath(FILE_PATH_LITERAL(
592 "green_small_with_blue_corner.png")));
593 }
594
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackNonRootLayerSubrect_GL)595 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerSubrect_GL) {
596 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
597 gfx::Rect(200, 200), SK_ColorWHITE);
598
599 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
600 gfx::Rect(25, 25, 150, 150), SK_ColorGREEN);
601 background->AddChild(green);
602
603 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
604 gfx::Rect(75, 75, 50, 50), SK_ColorBLUE);
605 green->AddChild(blue);
606
607 // Grab the middle of the green layer.
608 copy_subrect_ = gfx::Rect(25, 25, 100, 100);
609
610 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
611 background,
612 green.get(),
613 base::FilePath(FILE_PATH_LITERAL(
614 "green_small_with_blue_corner.png")));
615 }
616
617 class LayerTreeHostReadbackDeviceScalePixelTest
618 : public LayerTreeHostReadbackPixelTest {
619 protected:
LayerTreeHostReadbackDeviceScalePixelTest()620 LayerTreeHostReadbackDeviceScalePixelTest()
621 : device_scale_factor_(1.f),
622 white_client_(SK_ColorWHITE),
623 green_client_(SK_ColorGREEN),
624 blue_client_(SK_ColorBLUE) {}
625
InitializeSettings(LayerTreeSettings * settings)626 virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
627 // Cause the device scale factor to be inherited by contents scales.
628 settings->layer_transforms_should_scale_layer_contents = true;
629 }
630
SetupTree()631 virtual void SetupTree() OVERRIDE {
632 layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
633 LayerTreePixelTest::SetupTree();
634 }
635
DrawLayersOnThread(LayerTreeHostImpl * host_impl)636 virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
637 LayerImpl* root_impl = host_impl->active_tree()->root_layer();
638
639 LayerImpl* background_impl = root_impl->children()[0];
640 EXPECT_EQ(device_scale_factor_, background_impl->contents_scale_x());
641 EXPECT_EQ(device_scale_factor_, background_impl->contents_scale_y());
642
643 LayerImpl* green_impl = background_impl->children()[0];
644 EXPECT_EQ(device_scale_factor_, green_impl->contents_scale_x());
645 EXPECT_EQ(device_scale_factor_, green_impl->contents_scale_y());
646
647 LayerImpl* blue_impl = green_impl->children()[0];
648 EXPECT_EQ(device_scale_factor_, blue_impl->contents_scale_x());
649 EXPECT_EQ(device_scale_factor_, blue_impl->contents_scale_y());
650 }
651
652 float device_scale_factor_;
653 SolidColorContentLayerClient white_client_;
654 SolidColorContentLayerClient green_client_;
655 SolidColorContentLayerClient blue_client_;
656 };
657
TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,ReadbackSubrect_Software)658 TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,
659 ReadbackSubrect_Software) {
660 scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
661 background->SetAnchorPoint(gfx::PointF());
662 background->SetBounds(gfx::Size(100, 100));
663 background->SetIsDrawable(true);
664
665 scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
666 green->SetAnchorPoint(gfx::PointF());
667 green->SetBounds(gfx::Size(100, 100));
668 green->SetIsDrawable(true);
669 background->AddChild(green);
670
671 scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
672 blue->SetAnchorPoint(gfx::PointF());
673 blue->SetPosition(gfx::Point(50, 50));
674 blue->SetBounds(gfx::Size(25, 25));
675 blue->SetIsDrawable(true);
676 green->AddChild(blue);
677
678 // Grab the middle of the root layer.
679 copy_subrect_ = gfx::Rect(25, 25, 50, 50);
680 device_scale_factor_ = 2.f;
681
682 this->impl_side_painting_ = false;
683 RunPixelTest(SOFTWARE_WITH_DEFAULT,
684 background,
685 base::FilePath(FILE_PATH_LITERAL(
686 "green_small_with_blue_corner.png")));
687 }
688
TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,ReadbackSubrect_GL)689 TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,
690 ReadbackSubrect_GL) {
691 scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
692 background->SetAnchorPoint(gfx::PointF());
693 background->SetBounds(gfx::Size(100, 100));
694 background->SetIsDrawable(true);
695
696 scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
697 green->SetAnchorPoint(gfx::PointF());
698 green->SetBounds(gfx::Size(100, 100));
699 green->SetIsDrawable(true);
700 background->AddChild(green);
701
702 scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
703 blue->SetAnchorPoint(gfx::PointF());
704 blue->SetPosition(gfx::Point(50, 50));
705 blue->SetBounds(gfx::Size(25, 25));
706 blue->SetIsDrawable(true);
707 green->AddChild(blue);
708
709 // Grab the middle of the root layer.
710 copy_subrect_ = gfx::Rect(25, 25, 50, 50);
711 device_scale_factor_ = 2.f;
712
713 this->impl_side_painting_ = false;
714 RunPixelTest(GL_WITH_DEFAULT,
715 background,
716 base::FilePath(FILE_PATH_LITERAL(
717 "green_small_with_blue_corner.png")));
718 }
719
TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,ReadbackNonRootLayerSubrect_Software)720 TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,
721 ReadbackNonRootLayerSubrect_Software) {
722 scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
723 background->SetAnchorPoint(gfx::PointF());
724 background->SetBounds(gfx::Size(100, 100));
725 background->SetIsDrawable(true);
726
727 scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
728 green->SetAnchorPoint(gfx::PointF());
729 green->SetPosition(gfx::Point(10, 20));
730 green->SetBounds(gfx::Size(90, 80));
731 green->SetIsDrawable(true);
732 background->AddChild(green);
733
734 scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
735 blue->SetAnchorPoint(gfx::PointF());
736 blue->SetPosition(gfx::Point(50, 50));
737 blue->SetBounds(gfx::Size(25, 25));
738 blue->SetIsDrawable(true);
739 green->AddChild(blue);
740
741 // Grab the green layer's content with blue in the bottom right.
742 copy_subrect_ = gfx::Rect(25, 25, 50, 50);
743 device_scale_factor_ = 2.f;
744
745 this->impl_side_painting_ = false;
746 RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
747 background,
748 green.get(),
749 base::FilePath(FILE_PATH_LITERAL(
750 "green_small_with_blue_corner.png")));
751 }
752
TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,ReadbackNonRootLayerSubrect_GL)753 TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,
754 ReadbackNonRootLayerSubrect_GL) {
755 scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
756 background->SetAnchorPoint(gfx::PointF());
757 background->SetBounds(gfx::Size(100, 100));
758 background->SetIsDrawable(true);
759
760 scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
761 green->SetAnchorPoint(gfx::PointF());
762 green->SetPosition(gfx::Point(10, 20));
763 green->SetBounds(gfx::Size(90, 80));
764 green->SetIsDrawable(true);
765 background->AddChild(green);
766
767 scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
768 blue->SetAnchorPoint(gfx::PointF());
769 blue->SetPosition(gfx::Point(50, 50));
770 blue->SetBounds(gfx::Size(25, 25));
771 blue->SetIsDrawable(true);
772 green->AddChild(blue);
773
774 // Grab the green layer's content with blue in the bottom right.
775 copy_subrect_ = gfx::Rect(25, 25, 50, 50);
776 device_scale_factor_ = 2.f;
777
778 this->impl_side_painting_ = false;
779 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
780 background,
781 green.get(),
782 base::FilePath(FILE_PATH_LITERAL(
783 "green_small_with_blue_corner.png")));
784 }
785
786 class LayerTreeHostReadbackViaCompositeAndReadbackPixelTest
787 : public LayerTreePixelTest {
788 protected:
LayerTreeHostReadbackViaCompositeAndReadbackPixelTest()789 LayerTreeHostReadbackViaCompositeAndReadbackPixelTest()
790 : device_scale_factor_(1.f),
791 white_client_(SK_ColorWHITE),
792 green_client_(SK_ColorGREEN),
793 blue_client_(SK_ColorBLUE) {}
794
InitializeSettings(LayerTreeSettings * settings)795 virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
796 // Cause the device scale factor to be inherited by contents scales.
797 settings->layer_transforms_should_scale_layer_contents = true;
798 }
799
SetupTree()800 virtual void SetupTree() OVERRIDE {
801 layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
802 LayerTreePixelTest::SetupTree();
803 }
804
BeginTest()805 virtual void BeginTest() OVERRIDE {
806 EXPECT_EQ(device_scale_factor_, layer_tree_host()->device_scale_factor());
807 if (TestEnded())
808 return;
809
810 gfx::Rect device_viewport_copy_rect(
811 layer_tree_host()->device_viewport_size());
812 if (!device_viewport_copy_subrect_.IsEmpty())
813 device_viewport_copy_rect.Intersect(device_viewport_copy_subrect_);
814
815 scoped_ptr<SkBitmap> bitmap(new SkBitmap);
816 bitmap->setConfig(SkBitmap::kARGB_8888_Config,
817 device_viewport_copy_rect.width(),
818 device_viewport_copy_rect.height());
819 bitmap->allocPixels();
820 {
821 scoped_ptr<SkAutoLockPixels> lock(new SkAutoLockPixels(*bitmap));
822 layer_tree_host()->CompositeAndReadback(bitmap->getPixels(),
823 device_viewport_copy_rect);
824 }
825
826 result_bitmap_ = bitmap.Pass();
827 EndTest();
828 }
829
DrawLayersOnThread(LayerTreeHostImpl * host_impl)830 virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
831 LayerImpl* root_impl = host_impl->active_tree()->root_layer();
832
833 LayerImpl* background_impl = root_impl->children()[0];
834 EXPECT_EQ(device_scale_factor_, background_impl->contents_scale_x());
835 EXPECT_EQ(device_scale_factor_, background_impl->contents_scale_y());
836
837 LayerImpl* green_impl = background_impl->children()[0];
838 EXPECT_EQ(device_scale_factor_, green_impl->contents_scale_x());
839 EXPECT_EQ(device_scale_factor_, green_impl->contents_scale_y());
840
841 LayerImpl* blue_impl = green_impl->children()[0];
842 EXPECT_EQ(device_scale_factor_, blue_impl->contents_scale_x());
843 EXPECT_EQ(device_scale_factor_, blue_impl->contents_scale_y());
844 }
845
846 gfx::Rect device_viewport_copy_subrect_;
847 float device_scale_factor_;
848 SolidColorContentLayerClient white_client_;
849 SolidColorContentLayerClient green_client_;
850 SolidColorContentLayerClient blue_client_;
851 };
852
TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,CompositeAndReadback_Software_1)853 TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,
854 CompositeAndReadback_Software_1) {
855 scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
856 background->SetAnchorPoint(gfx::PointF());
857 background->SetBounds(gfx::Size(200, 200));
858 background->SetIsDrawable(true);
859
860 scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
861 green->SetAnchorPoint(gfx::PointF());
862 green->SetBounds(gfx::Size(200, 200));
863 green->SetIsDrawable(true);
864 background->AddChild(green);
865
866 scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
867 blue->SetAnchorPoint(gfx::PointF());
868 blue->SetPosition(gfx::Point(100, 100));
869 blue->SetBounds(gfx::Size(50, 50));
870 blue->SetIsDrawable(true);
871 green->AddChild(blue);
872
873 // Grab the middle of the device viewport.
874 device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
875 device_scale_factor_ = 1.f;
876
877 this->impl_side_painting_ = false;
878 RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
879 background,
880 green.get(),
881 base::FilePath(FILE_PATH_LITERAL(
882 "green_small_with_blue_corner.png")));
883 }
884
TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,CompositeAndReadback_Software_2)885 TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,
886 CompositeAndReadback_Software_2) {
887 scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
888 background->SetAnchorPoint(gfx::PointF());
889 background->SetBounds(gfx::Size(100, 100));
890 background->SetIsDrawable(true);
891
892 scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
893 green->SetAnchorPoint(gfx::PointF());
894 green->SetBounds(gfx::Size(100, 100));
895 green->SetIsDrawable(true);
896 background->AddChild(green);
897
898 scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
899 blue->SetAnchorPoint(gfx::PointF());
900 blue->SetPosition(gfx::Point(50, 50));
901 blue->SetBounds(gfx::Size(25, 25));
902 blue->SetIsDrawable(true);
903 green->AddChild(blue);
904
905 // Grab the middle of the device viewport.
906 device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
907 device_scale_factor_ = 2.f;
908
909 this->impl_side_painting_ = false;
910 RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
911 background,
912 green.get(),
913 base::FilePath(FILE_PATH_LITERAL(
914 "green_small_with_blue_corner.png")));
915 }
916
TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,CompositeAndReadback_GL_1)917 TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,
918 CompositeAndReadback_GL_1) {
919 scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
920 background->SetAnchorPoint(gfx::PointF());
921 background->SetBounds(gfx::Size(200, 200));
922 background->SetIsDrawable(true);
923
924 scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
925 green->SetAnchorPoint(gfx::PointF());
926 green->SetBounds(gfx::Size(200, 200));
927 green->SetIsDrawable(true);
928 background->AddChild(green);
929
930 scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
931 blue->SetAnchorPoint(gfx::PointF());
932 blue->SetPosition(gfx::Point(100, 100));
933 blue->SetBounds(gfx::Size(50, 50));
934 blue->SetIsDrawable(true);
935 green->AddChild(blue);
936
937 // Grab the middle of the device viewport.
938 device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
939 device_scale_factor_ = 1.f;
940
941 this->impl_side_painting_ = false;
942 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
943 background,
944 green.get(),
945 base::FilePath(FILE_PATH_LITERAL(
946 "green_small_with_blue_corner.png")));
947 }
948
TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,CompositeAndReadback_GL_2)949 TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,
950 CompositeAndReadback_GL_2) {
951 scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
952 background->SetAnchorPoint(gfx::PointF());
953 background->SetBounds(gfx::Size(100, 100));
954 background->SetIsDrawable(true);
955
956 scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
957 green->SetAnchorPoint(gfx::PointF());
958 green->SetBounds(gfx::Size(100, 100));
959 green->SetIsDrawable(true);
960 background->AddChild(green);
961
962 scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
963 blue->SetAnchorPoint(gfx::PointF());
964 blue->SetPosition(gfx::Point(50, 50));
965 blue->SetBounds(gfx::Size(25, 25));
966 blue->SetIsDrawable(true);
967 green->AddChild(blue);
968
969 // Grab the middle of the device viewport.
970 device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
971 device_scale_factor_ = 2.f;
972
973 this->impl_side_painting_ = false;
974 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
975 background,
976 green.get(),
977 base::FilePath(FILE_PATH_LITERAL(
978 "green_small_with_blue_corner.png")));
979 }
980
TEST_F(LayerTreeHostReadbackPixelTest,ReadbackNonRootLayerOutsideViewport)981 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerOutsideViewport) {
982 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
983 gfx::Rect(200, 200), SK_ColorWHITE);
984
985 scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
986 gfx::Rect(200, 200), SK_ColorGREEN);
987 // Only the top left quarter of the layer is inside the viewport, so the
988 // blue layer is entirely outside.
989 green->SetPosition(gfx::Point(100, 100));
990 background->AddChild(green);
991
992 scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
993 gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
994 green->AddChild(blue);
995
996 RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
997 background,
998 green.get(),
999 base::FilePath(FILE_PATH_LITERAL(
1000 "green_with_blue_corner.png")));
1001 }
1002
1003 } // namespace
1004 } // namespace cc
1005
1006 #endif // OS_ANDROID
1007