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: 24 LayerTreeHostReadbackPixelTest() 25 : insert_copy_request_after_frame_count_(0) {} 26 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 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 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 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 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 100 void IgnoreReadbackResult(scoped_ptr<CopyOutputResult> result) {} 101 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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: 917 LayerTreeHostReadbackDeviceScalePixelTest() 918 : device_scale_factor_(1.f), 919 white_client_(SK_ColorWHITE), 920 green_client_(SK_ColorGREEN), 921 blue_client_(SK_ColorBLUE) {} 922 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 928 virtual void SetupTree() OVERRIDE { 929 layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_); 930 LayerTreePixelTest::SetupTree(); 931 } 932 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 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 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 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 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 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
