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