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