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