picture_layer_impl_unittest.cc revision 4e180b6a0b4720a9b8e9e959a882386f690f08ff
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 "cc/layers/picture_layer_impl.h" 6 7#include <utility> 8 9#include "cc/debug/test_web_graphics_context_3d.h" 10#include "cc/layers/append_quads_data.h" 11#include "cc/layers/picture_layer.h" 12#include "cc/test/fake_content_layer_client.h" 13#include "cc/test/fake_impl_proxy.h" 14#include "cc/test/fake_layer_tree_host_impl.h" 15#include "cc/test/fake_output_surface.h" 16#include "cc/test/fake_picture_layer_impl.h" 17#include "cc/test/fake_picture_pile_impl.h" 18#include "cc/test/geometry_test_utils.h" 19#include "cc/test/impl_side_painting_settings.h" 20#include "cc/test/mock_quad_culler.h" 21#include "cc/trees/layer_tree_impl.h" 22#include "testing/gtest/include/gtest/gtest.h" 23#include "third_party/skia/include/core/SkBitmapDevice.h" 24#include "ui/gfx/rect_conversions.h" 25 26namespace cc { 27namespace { 28 29class MockCanvas : public SkCanvas { 30 public: 31 explicit MockCanvas(SkBaseDevice* device) : SkCanvas(device) {} 32 33 virtual void drawRect(const SkRect& rect, const SkPaint& paint) OVERRIDE { 34 // Capture calls before SkCanvas quickReject() kicks in. 35 rects_.push_back(rect); 36 } 37 38 std::vector<SkRect> rects_; 39}; 40 41class PictureLayerImplTest : public testing::Test { 42 public: 43 PictureLayerImplTest() 44 : host_impl_(ImplSidePaintingSettings(), &proxy_), id_(7) {} 45 46 explicit PictureLayerImplTest(const LayerTreeSettings& settings) 47 : host_impl_(settings, &proxy_), id_(7) {} 48 49 virtual ~PictureLayerImplTest() { 50 } 51 52 virtual void SetUp() OVERRIDE { 53 InitializeRenderer(); 54 } 55 56 virtual void InitializeRenderer() { 57 host_impl_.InitializeRenderer(CreateFakeOutputSurface()); 58 } 59 60 void SetupDefaultTrees(gfx::Size layer_bounds) { 61 gfx::Size tile_size(100, 100); 62 63 scoped_refptr<FakePicturePileImpl> pending_pile = 64 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 65 scoped_refptr<FakePicturePileImpl> active_pile = 66 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 67 68 SetupTrees(pending_pile, active_pile); 69 } 70 71 void SetupTrees( 72 scoped_refptr<PicturePileImpl> pending_pile, 73 scoped_refptr<PicturePileImpl> active_pile) { 74 SetupPendingTree(active_pile); 75 host_impl_.ActivatePendingTree(); 76 77 active_layer_ = static_cast<FakePictureLayerImpl*>( 78 host_impl_.active_tree()->LayerById(id_)); 79 80 SetupPendingTree(pending_pile); 81 } 82 83 void AddDefaultTilingsWithInvalidation(const Region& invalidation) { 84 active_layer_->AddTiling(2.3f); 85 active_layer_->AddTiling(1.0f); 86 active_layer_->AddTiling(0.5f); 87 for (size_t i = 0; i < active_layer_->tilings()->num_tilings(); ++i) 88 active_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting(); 89 pending_layer_->set_invalidation(invalidation); 90 for (size_t i = 0; i < pending_layer_->tilings()->num_tilings(); ++i) 91 pending_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting(); 92 } 93 94 void SetupPendingTree( 95 scoped_refptr<PicturePileImpl> pile) { 96 host_impl_.CreatePendingTree(); 97 LayerTreeImpl* pending_tree = host_impl_.pending_tree(); 98 // Clear recycled tree. 99 pending_tree->DetachLayerTree(); 100 101 scoped_ptr<FakePictureLayerImpl> pending_layer = 102 FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile); 103 pending_layer->SetDrawsContent(true); 104 pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>()); 105 106 pending_layer_ = static_cast<FakePictureLayerImpl*>( 107 host_impl_.pending_tree()->LayerById(id_)); 108 pending_layer_->DoPostCommitInitializationIfNeeded(); 109 } 110 111 static void VerifyAllTilesExistAndHavePile( 112 const PictureLayerTiling* tiling, 113 PicturePileImpl* pile) { 114 for (PictureLayerTiling::CoverageIterator 115 iter(tiling, tiling->contents_scale(), tiling->ContentRect()); 116 iter; 117 ++iter) { 118 EXPECT_TRUE(*iter); 119 EXPECT_EQ(pile, iter->picture_pile()); 120 } 121 } 122 123 void SetContentsScaleOnBothLayers(float contents_scale, 124 float device_scale_factor, 125 float page_scale_factor, 126 bool animating_transform) { 127 float result_scale_x, result_scale_y; 128 gfx::Size result_bounds; 129 pending_layer_->CalculateContentsScale( 130 contents_scale, 131 device_scale_factor, 132 page_scale_factor, 133 animating_transform, 134 &result_scale_x, 135 &result_scale_y, 136 &result_bounds); 137 active_layer_->CalculateContentsScale( 138 contents_scale, 139 device_scale_factor, 140 page_scale_factor, 141 animating_transform, 142 &result_scale_x, 143 &result_scale_y, 144 &result_bounds); 145 } 146 147 void ResetTilingsAndRasterScales() { 148 pending_layer_->DidLoseOutputSurface(); 149 active_layer_->DidLoseOutputSurface(); 150 } 151 152 protected: 153 void TestTileGridAlignmentCommon() { 154 // Layer to span 4 raster tiles in x and in y 155 ImplSidePaintingSettings settings; 156 gfx::Size layer_size( 157 settings.default_tile_size.width() * 7 / 2, 158 settings.default_tile_size.height() * 7 / 2); 159 160 scoped_refptr<FakePicturePileImpl> pending_pile = 161 FakePicturePileImpl::CreateFilledPile(layer_size, layer_size); 162 scoped_refptr<FakePicturePileImpl> active_pile = 163 FakePicturePileImpl::CreateFilledPile(layer_size, layer_size); 164 165 SetupTrees(pending_pile, active_pile); 166 167 float result_scale_x, result_scale_y; 168 gfx::Size result_bounds; 169 active_layer_->CalculateContentsScale( 170 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 171 172 // Add 1x1 rects at the centers of each tile, then re-record pile contents 173 active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 174 std::vector<Tile*> tiles = 175 active_layer_->tilings()->tiling_at(0)->AllTilesForTesting(); 176 EXPECT_EQ(16u, tiles.size()); 177 std::vector<SkRect> rects; 178 std::vector<Tile*>::const_iterator tile_iter; 179 for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) { 180 gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint(); 181 gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1); 182 active_pile->add_draw_rect(rect); 183 rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1)); 184 } 185 // Force re-record with newly injected content 186 active_pile->RemoveRecordingAt(0, 0); 187 active_pile->AddRecordingAt(0, 0); 188 189 SkBitmap store; 190 store.setConfig(SkBitmap::kNo_Config, 1000, 1000); 191 SkBitmapDevice device(store); 192 193 std::vector<SkRect>::const_iterator rect_iter = rects.begin(); 194 for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) { 195 MockCanvas mock_canvas(&device); 196 active_pile->RasterDirect( 197 &mock_canvas, (*tile_iter)->content_rect(), 1.0f, NULL); 198 199 // This test verifies that when drawing the contents of a specific tile 200 // at content scale 1.0, the playback canvas never receives content from 201 // neighboring tiles which indicates that the tile grid embedded in 202 // SkPicture is perfectly aligned with the compositor's tiles. 203 EXPECT_EQ(1u, mock_canvas.rects_.size()); 204 EXPECT_RECT_EQ(*rect_iter, mock_canvas.rects_[0]); 205 rect_iter++; 206 } 207 } 208 209 FakeImplProxy proxy_; 210 FakeLayerTreeHostImpl host_impl_; 211 int id_; 212 FakePictureLayerImpl* pending_layer_; 213 FakePictureLayerImpl* active_layer_; 214 215 private: 216 DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest); 217}; 218 219TEST_F(PictureLayerImplTest, TileGridAlignment) { 220 host_impl_.SetDeviceScaleFactor(1.f); 221 TestTileGridAlignmentCommon(); 222} 223 224TEST_F(PictureLayerImplTest, TileGridAlignmentHiDPI) { 225 host_impl_.SetDeviceScaleFactor(2.f); 226 TestTileGridAlignmentCommon(); 227} 228 229TEST_F(PictureLayerImplTest, CloneNoInvalidation) { 230 gfx::Size tile_size(100, 100); 231 gfx::Size layer_bounds(400, 400); 232 233 scoped_refptr<FakePicturePileImpl> pending_pile = 234 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 235 scoped_refptr<FakePicturePileImpl> active_pile = 236 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 237 238 SetupTrees(pending_pile, active_pile); 239 240 Region invalidation; 241 AddDefaultTilingsWithInvalidation(invalidation); 242 243 EXPECT_EQ(pending_layer_->tilings()->num_tilings(), 244 active_layer_->tilings()->num_tilings()); 245 246 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 247 EXPECT_GT(tilings->num_tilings(), 0u); 248 for (size_t i = 0; i < tilings->num_tilings(); ++i) 249 VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), active_pile.get()); 250} 251 252TEST_F(PictureLayerImplTest, SuppressUpdateTilePriorities) { 253 base::TimeTicks time_ticks; 254 host_impl_.SetCurrentFrameTimeTicks(time_ticks); 255 256 gfx::Size tile_size(100, 100); 257 gfx::Size layer_bounds(400, 400); 258 259 scoped_refptr<FakePicturePileImpl> pending_pile = 260 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 261 scoped_refptr<FakePicturePileImpl> active_pile = 262 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 263 264 SetupTrees(pending_pile, active_pile); 265 266 Region invalidation; 267 AddDefaultTilingsWithInvalidation(invalidation); 268 float dummy_contents_scale_x; 269 float dummy_contents_scale_y; 270 gfx::Size dummy_content_bounds; 271 active_layer_->CalculateContentsScale(1.f, 272 1.f, 273 1.f, 274 false, 275 &dummy_contents_scale_x, 276 &dummy_contents_scale_y, 277 &dummy_content_bounds); 278 279 EXPECT_TRUE(host_impl_.manage_tiles_needed()); 280 active_layer_->UpdateTilePriorities(); 281 host_impl_.ManageTiles(); 282 EXPECT_FALSE(host_impl_.manage_tiles_needed()); 283 284 time_ticks += base::TimeDelta::FromMilliseconds(200); 285 host_impl_.SetCurrentFrameTimeTicks(time_ticks); 286 287 // Setting this boolean should cause an early out in UpdateTilePriorities. 288 bool valid_for_tile_management = false; 289 host_impl_.SetExternalDrawConstraints(gfx::Transform(), 290 gfx::Rect(layer_bounds), 291 gfx::Rect(layer_bounds), 292 valid_for_tile_management); 293 active_layer_->UpdateTilePriorities(); 294 EXPECT_FALSE(host_impl_.manage_tiles_needed()); 295 296 time_ticks += base::TimeDelta::FromMilliseconds(200); 297 host_impl_.SetCurrentFrameTimeTicks(time_ticks); 298 299 valid_for_tile_management = true; 300 host_impl_.SetExternalDrawConstraints(gfx::Transform(), 301 gfx::Rect(layer_bounds), 302 gfx::Rect(layer_bounds), 303 valid_for_tile_management); 304 active_layer_->UpdateTilePriorities(); 305 EXPECT_TRUE(host_impl_.manage_tiles_needed()); 306} 307 308TEST_F(PictureLayerImplTest, ClonePartialInvalidation) { 309 gfx::Size tile_size(100, 100); 310 gfx::Size layer_bounds(400, 400); 311 gfx::Rect layer_invalidation(150, 200, 30, 180); 312 313 scoped_refptr<FakePicturePileImpl> pending_pile = 314 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 315 scoped_refptr<FakePicturePileImpl> active_pile = 316 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 317 318 SetupTrees(pending_pile, active_pile); 319 320 Region invalidation(layer_invalidation); 321 AddDefaultTilingsWithInvalidation(invalidation); 322 323 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 324 EXPECT_GT(tilings->num_tilings(), 0u); 325 for (size_t i = 0; i < tilings->num_tilings(); ++i) { 326 const PictureLayerTiling* tiling = tilings->tiling_at(i); 327 gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect( 328 layer_invalidation, 329 tiling->contents_scale()); 330 for (PictureLayerTiling::CoverageIterator 331 iter(tiling, 332 tiling->contents_scale(), 333 tiling->ContentRect()); 334 iter; 335 ++iter) { 336 EXPECT_TRUE(*iter); 337 EXPECT_FALSE(iter.geometry_rect().IsEmpty()); 338 if (iter.geometry_rect().Intersects(content_invalidation)) 339 EXPECT_EQ(pending_pile, iter->picture_pile()); 340 else 341 EXPECT_EQ(active_pile, iter->picture_pile()); 342 } 343 } 344} 345 346TEST_F(PictureLayerImplTest, CloneFullInvalidation) { 347 gfx::Size tile_size(90, 80); 348 gfx::Size layer_bounds(300, 500); 349 350 scoped_refptr<FakePicturePileImpl> pending_pile = 351 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 352 scoped_refptr<FakePicturePileImpl> active_pile = 353 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 354 355 SetupTrees(pending_pile, active_pile); 356 357 Region invalidation((gfx::Rect(layer_bounds))); 358 AddDefaultTilingsWithInvalidation(invalidation); 359 360 EXPECT_EQ(pending_layer_->tilings()->num_tilings(), 361 active_layer_->tilings()->num_tilings()); 362 363 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 364 EXPECT_GT(tilings->num_tilings(), 0u); 365 for (size_t i = 0; i < tilings->num_tilings(); ++i) 366 VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get()); 367} 368 369TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) { 370 gfx::Size tile_size(90, 80); 371 gfx::Size active_layer_bounds(300, 500); 372 gfx::Size pending_layer_bounds(400, 800); 373 374 scoped_refptr<FakePicturePileImpl> pending_pile = 375 FakePicturePileImpl::CreateFilledPile(tile_size, 376 pending_layer_bounds); 377 scoped_refptr<FakePicturePileImpl> active_pile = 378 FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds); 379 380 SetupTrees(pending_pile, active_pile); 381 pending_layer_->set_fixed_tile_size(gfx::Size(100, 100)); 382 383 Region invalidation; 384 AddDefaultTilingsWithInvalidation(invalidation); 385 386 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 387 EXPECT_GT(tilings->num_tilings(), 0u); 388 for (size_t i = 0; i < tilings->num_tilings(); ++i) { 389 const PictureLayerTiling* tiling = tilings->tiling_at(i); 390 gfx::Rect active_content_bounds = gfx::ScaleToEnclosingRect( 391 gfx::Rect(active_layer_bounds), 392 tiling->contents_scale()); 393 for (PictureLayerTiling::CoverageIterator 394 iter(tiling, 395 tiling->contents_scale(), 396 tiling->ContentRect()); 397 iter; 398 ++iter) { 399 EXPECT_TRUE(*iter); 400 EXPECT_FALSE(iter.geometry_rect().IsEmpty()); 401 std::vector<Tile*> active_tiles = 402 active_layer_->tilings()->tiling_at(i)->AllTilesForTesting(); 403 std::vector<Tile*> pending_tiles = tiling->AllTilesForTesting(); 404 if (iter.geometry_rect().right() >= active_content_bounds.width() || 405 iter.geometry_rect().bottom() >= active_content_bounds.height() || 406 active_tiles[0]->content_rect().size() != 407 pending_tiles[0]->content_rect().size()) { 408 EXPECT_EQ(pending_pile, iter->picture_pile()); 409 } else { 410 EXPECT_EQ(active_pile, iter->picture_pile()); 411 } 412 } 413 } 414} 415 416TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) { 417 gfx::Size tile_size(400, 400); 418 gfx::Size layer_bounds(1300, 1900); 419 420 scoped_refptr<FakePicturePileImpl> pending_pile = 421 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 422 scoped_refptr<FakePicturePileImpl> active_pile = 423 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 424 425 // Fill in some of active pile, but more of pending pile. 426 int hole_count = 0; 427 for (int x = 0; x < active_pile->tiling().num_tiles_x(); ++x) { 428 for (int y = 0; y < active_pile->tiling().num_tiles_y(); ++y) { 429 if ((x + y) % 2) { 430 pending_pile->AddRecordingAt(x, y); 431 active_pile->AddRecordingAt(x, y); 432 } else { 433 hole_count++; 434 if (hole_count % 2) 435 pending_pile->AddRecordingAt(x, y); 436 } 437 } 438 } 439 440 SetupTrees(pending_pile, active_pile); 441 Region invalidation; 442 AddDefaultTilingsWithInvalidation(invalidation); 443 444 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 445 EXPECT_GT(tilings->num_tilings(), 0u); 446 for (size_t i = 0; i < tilings->num_tilings(); ++i) { 447 const PictureLayerTiling* tiling = tilings->tiling_at(i); 448 449 for (PictureLayerTiling::CoverageIterator 450 iter(tiling, 451 tiling->contents_scale(), 452 tiling->ContentRect()); 453 iter; 454 ++iter) { 455 EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty()); 456 // Ensure there is a recording for this tile. 457 gfx::Rect layer_rect = gfx::ScaleToEnclosingRect( 458 iter.full_tile_geometry_rect(), 1.f / tiling->contents_scale()); 459 layer_rect.Intersect(gfx::Rect(layer_bounds)); 460 461 bool in_pending = pending_pile->recorded_region().Contains(layer_rect); 462 bool in_active = active_pile->recorded_region().Contains(layer_rect); 463 464 if (in_pending && !in_active) 465 EXPECT_EQ(pending_pile, iter->picture_pile()); 466 else if (in_active) 467 EXPECT_EQ(active_pile, iter->picture_pile()); 468 else 469 EXPECT_FALSE(*iter); 470 } 471 } 472} 473 474TEST_F(PictureLayerImplTest, ManageTilingsWithNoRecording) { 475 gfx::Size tile_size(400, 400); 476 gfx::Size layer_bounds(1300, 1900); 477 478 scoped_refptr<FakePicturePileImpl> pending_pile = 479 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 480 scoped_refptr<FakePicturePileImpl> active_pile = 481 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 482 483 float result_scale_x, result_scale_y; 484 gfx::Size result_bounds; 485 486 SetupTrees(pending_pile, active_pile); 487 488 pending_layer_->CalculateContentsScale( 489 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 490 491 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 492} 493 494TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) { 495 gfx::Size tile_size(400, 400); 496 gfx::Size layer_bounds(1300, 1900); 497 498 scoped_refptr<FakePicturePileImpl> pending_pile = 499 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 500 scoped_refptr<FakePicturePileImpl> active_pile = 501 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 502 503 float result_scale_x, result_scale_y; 504 gfx::Size result_bounds; 505 506 SetupTrees(pending_pile, active_pile); 507 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 508 509 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 510 EXPECT_LT(low_res_factor, 1.f); 511 512 pending_layer_->CalculateContentsScale(1.3f, // ideal contents scale 513 1.7f, // device scale 514 3.2f, // page cale 515 false, 516 &result_scale_x, 517 &result_scale_y, 518 &result_bounds); 519 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 520 EXPECT_FLOAT_EQ( 521 1.3f, 522 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 523 EXPECT_FLOAT_EQ( 524 1.3f * low_res_factor, 525 pending_layer_->tilings()->tiling_at(1)->contents_scale()); 526 527 // If we change the layer's CSS scale factor, then we should not get new 528 // tilings. 529 pending_layer_->CalculateContentsScale(1.8f, // ideal contents scale 530 1.7f, // device scale 531 3.2f, // page cale 532 false, 533 &result_scale_x, 534 &result_scale_y, 535 &result_bounds); 536 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 537 EXPECT_FLOAT_EQ( 538 1.3f, 539 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 540 EXPECT_FLOAT_EQ( 541 1.3f * low_res_factor, 542 pending_layer_->tilings()->tiling_at(1)->contents_scale()); 543 544 // If we change the page scale factor, then we should get new tilings. 545 pending_layer_->CalculateContentsScale(1.8f, // ideal contents scale 546 1.7f, // device scale 547 2.2f, // page cale 548 false, 549 &result_scale_x, 550 &result_scale_y, 551 &result_bounds); 552 ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings()); 553 EXPECT_FLOAT_EQ( 554 1.8f, 555 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 556 EXPECT_FLOAT_EQ( 557 1.8f * low_res_factor, 558 pending_layer_->tilings()->tiling_at(2)->contents_scale()); 559 560 // If we change the device scale factor, then we should get new tilings. 561 pending_layer_->CalculateContentsScale(1.9f, // ideal contents scale 562 1.4f, // device scale 563 2.2f, // page cale 564 false, 565 &result_scale_x, 566 &result_scale_y, 567 &result_bounds); 568 ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings()); 569 EXPECT_FLOAT_EQ( 570 1.9f, 571 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 572 EXPECT_FLOAT_EQ( 573 1.9f * low_res_factor, 574 pending_layer_->tilings()->tiling_at(3)->contents_scale()); 575 576 // If we change the device scale factor, but end up at the same total scale 577 // factor somehow, then we don't get new tilings. 578 pending_layer_->CalculateContentsScale(1.9f, // ideal contents scale 579 2.2f, // device scale 580 1.4f, // page cale 581 false, 582 &result_scale_x, 583 &result_scale_y, 584 &result_bounds); 585 ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings()); 586 EXPECT_FLOAT_EQ( 587 1.9f, 588 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 589 EXPECT_FLOAT_EQ( 590 1.9f * low_res_factor, 591 pending_layer_->tilings()->tiling_at(3)->contents_scale()); 592} 593 594TEST_F(PictureLayerImplTest, CleanUpTilings) { 595 gfx::Size tile_size(400, 400); 596 gfx::Size layer_bounds(1300, 1900); 597 598 scoped_refptr<FakePicturePileImpl> pending_pile = 599 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 600 scoped_refptr<FakePicturePileImpl> active_pile = 601 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 602 603 float result_scale_x, result_scale_y; 604 gfx::Size result_bounds; 605 std::vector<PictureLayerTiling*> used_tilings; 606 607 SetupTrees(pending_pile, active_pile); 608 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 609 610 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 611 EXPECT_LT(low_res_factor, 1.f); 612 613 float device_scale = 1.7f; 614 float page_scale = 3.2f; 615 616 SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, false); 617 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 618 619 // We only have ideal tilings, so they aren't removed. 620 used_tilings.clear(); 621 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 622 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 623 624 // Changing the ideal but not creating new tilings. 625 SetContentsScaleOnBothLayers(1.5f, device_scale, page_scale, false); 626 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 627 628 // The tilings are still our target scale, so they aren't removed. 629 used_tilings.clear(); 630 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 631 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 632 633 // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2. 634 page_scale = 1.2f; 635 SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, false); 636 ASSERT_EQ(4u, active_layer_->tilings()->num_tilings()); 637 EXPECT_FLOAT_EQ( 638 1.f, 639 active_layer_->tilings()->tiling_at(1)->contents_scale()); 640 EXPECT_FLOAT_EQ( 641 1.f * low_res_factor, 642 active_layer_->tilings()->tiling_at(3)->contents_scale()); 643 644 // Mark the non-ideal tilings as used. They won't be removed. 645 used_tilings.clear(); 646 used_tilings.push_back(active_layer_->tilings()->tiling_at(1)); 647 used_tilings.push_back(active_layer_->tilings()->tiling_at(3)); 648 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 649 ASSERT_EQ(4u, active_layer_->tilings()->num_tilings()); 650 651 // Now move the ideal scale to 0.5. Our target stays 1.2. 652 SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, false); 653 654 // The high resolution tiling is between target and ideal, so is not 655 // removed. The low res tiling for the old ideal=1.0 scale is removed. 656 used_tilings.clear(); 657 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 658 ASSERT_EQ(3u, active_layer_->tilings()->num_tilings()); 659 660 // Now move the ideal scale to 1.0. Our target stays 1.2. 661 SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, false); 662 663 // All the tilings are between are target and the ideal, so they are not 664 // removed. 665 used_tilings.clear(); 666 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 667 ASSERT_EQ(3u, active_layer_->tilings()->num_tilings()); 668 669 // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2. 670 active_layer_->CalculateContentsScale(1.1f, 671 device_scale, 672 page_scale, 673 false, 674 &result_scale_x, 675 &result_scale_y, 676 &result_bounds); 677 678 // Because the pending layer's ideal scale is still 1.0, our tilings fall 679 // in the range [1.0,1.2] and are kept. 680 used_tilings.clear(); 681 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 682 ASSERT_EQ(3u, active_layer_->tilings()->num_tilings()); 683 684 // Move the ideal scale on the pending layer to 1.1 as well. Our target stays 685 // 1.2 still. 686 pending_layer_->CalculateContentsScale(1.1f, 687 device_scale, 688 page_scale, 689 false, 690 &result_scale_x, 691 &result_scale_y, 692 &result_bounds); 693 694 // Our 1.0 tiling now falls outside the range between our ideal scale and our 695 // target raster scale. But it is in our used tilings set, so nothing is 696 // deleted. 697 used_tilings.clear(); 698 used_tilings.push_back(active_layer_->tilings()->tiling_at(1)); 699 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 700 ASSERT_EQ(3u, active_layer_->tilings()->num_tilings()); 701 702 // If we remove it from our used tilings set, it is outside the range to keep 703 // so it is deleted. 704 used_tilings.clear(); 705 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 706 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 707} 708 709#define EXPECT_BOTH_EQ(expression, x) \ 710 do { \ 711 EXPECT_EQ(pending_layer_->expression, x); \ 712 EXPECT_EQ(active_layer_->expression, x); \ 713 } while (false) 714 715TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) { 716 // Make sure this layer covers multiple tiles, since otherwise low 717 // res won't get created because it is too small. 718 gfx::Size tile_size(host_impl_.settings().default_tile_size); 719 SetupDefaultTrees(gfx::Size(tile_size.width() + 1, tile_size.height() + 1)); 720 // Avoid max untiled layer size heuristics via fixed tile size. 721 pending_layer_->set_fixed_tile_size(tile_size); 722 active_layer_->set_fixed_tile_size(tile_size); 723 724 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 725 float contents_scale = 1.f; 726 float device_scale = 1.f; 727 float page_scale = 1.f; 728 bool animating_transform = true; 729 730 // Animating, so don't create low res even if there isn't one already. 731 SetContentsScaleOnBothLayers( 732 contents_scale, device_scale, page_scale, animating_transform); 733 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f); 734 EXPECT_BOTH_EQ(num_tilings(), 1u); 735 736 // Stop animating, low res gets created. 737 animating_transform = false; 738 SetContentsScaleOnBothLayers( 739 contents_scale, device_scale, page_scale, animating_transform); 740 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f); 741 EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor); 742 EXPECT_BOTH_EQ(num_tilings(), 2u); 743 744 // Page scale animation, new high res, but not new low res because animating. 745 contents_scale = 2.f; 746 page_scale = 2.f; 747 animating_transform = true; 748 SetContentsScaleOnBothLayers( 749 contents_scale, device_scale, page_scale, animating_transform); 750 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f); 751 EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor); 752 EXPECT_BOTH_EQ(num_tilings(), 3u); 753 754 // Stop animating, new low res gets created for final page scale. 755 animating_transform = false; 756 SetContentsScaleOnBothLayers( 757 contents_scale, device_scale, page_scale, animating_transform); 758 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f); 759 EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 2.f * low_res_factor); 760 EXPECT_BOTH_EQ(num_tilings(), 4u); 761} 762 763TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) { 764 gfx::Size tile_size(host_impl_.settings().default_tile_size); 765 SetupDefaultTrees(tile_size); 766 767 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 768 float device_scale = 1.f; 769 float page_scale = 1.f; 770 bool animating_transform = false; 771 772 // Contents exactly fit on one tile at scale 1, no low res. 773 float contents_scale = 1.f; 774 SetContentsScaleOnBothLayers( 775 contents_scale, device_scale, page_scale, animating_transform); 776 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale); 777 EXPECT_BOTH_EQ(num_tilings(), 1u); 778 779 ResetTilingsAndRasterScales(); 780 781 // Contents that are smaller than one tile, no low res. 782 contents_scale = 0.123f; 783 SetContentsScaleOnBothLayers( 784 contents_scale, device_scale, page_scale, animating_transform); 785 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale); 786 EXPECT_BOTH_EQ(num_tilings(), 1u); 787 788 ResetTilingsAndRasterScales(); 789 790 // Any content bounds that would create more than one tile will 791 // generate a low res tiling. 792 contents_scale = 2.5f; 793 SetContentsScaleOnBothLayers( 794 contents_scale, device_scale, page_scale, animating_transform); 795 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale); 796 EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 797 contents_scale * low_res_factor); 798 EXPECT_BOTH_EQ(num_tilings(), 2u); 799 800 ResetTilingsAndRasterScales(); 801 802 // Mask layers dont create low res since they always fit on one tile. 803 pending_layer_->SetIsMask(true); 804 active_layer_->SetIsMask(true); 805 SetContentsScaleOnBothLayers( 806 contents_scale, device_scale, page_scale, animating_transform); 807 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale); 808 EXPECT_BOTH_EQ(num_tilings(), 1u); 809} 810 811TEST_F(PictureLayerImplTest, DidLoseOutputSurface) { 812 gfx::Size tile_size(400, 400); 813 gfx::Size layer_bounds(1300, 1900); 814 815 scoped_refptr<FakePicturePileImpl> pending_pile = 816 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 817 scoped_refptr<FakePicturePileImpl> active_pile = 818 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 819 820 float result_scale_x, result_scale_y; 821 gfx::Size result_bounds; 822 823 SetupTrees(pending_pile, active_pile); 824 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 825 826 pending_layer_->CalculateContentsScale(1.3f, // ideal contents scale 827 2.7f, // device scale 828 3.2f, // page cale 829 false, 830 &result_scale_x, 831 &result_scale_y, 832 &result_bounds); 833 EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings()); 834 835 // All tilings should be removed when losing output surface. 836 active_layer_->DidLoseOutputSurface(); 837 EXPECT_EQ(0u, active_layer_->tilings()->num_tilings()); 838 pending_layer_->DidLoseOutputSurface(); 839 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 840 841 // This should create new tilings. 842 pending_layer_->CalculateContentsScale(1.3f, // ideal contents scale 843 2.7f, // device scale 844 3.2f, // page cale 845 false, 846 &result_scale_x, 847 &result_scale_y, 848 &result_bounds); 849 EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings()); 850} 851 852TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) { 853 // The default max tile size is larger than 400x400. 854 gfx::Size tile_size(400, 400); 855 gfx::Size layer_bounds(5000, 5000); 856 857 scoped_refptr<FakePicturePileImpl> pending_pile = 858 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 859 scoped_refptr<FakePicturePileImpl> active_pile = 860 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 861 862 float result_scale_x, result_scale_y; 863 gfx::Size result_bounds; 864 865 SetupTrees(pending_pile, active_pile); 866 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 867 868 pending_layer_->CalculateContentsScale( 869 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 870 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 871 872 pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 873 874 // The default value. 875 EXPECT_EQ(gfx::Size(256, 256).ToString(), 876 host_impl_.settings().default_tile_size.ToString()); 877 878 Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0]; 879 EXPECT_EQ(gfx::Size(256, 256).ToString(), 880 tile->content_rect().size().ToString()); 881 882 pending_layer_->DidLoseOutputSurface(); 883 884 // Change the max texture size on the output surface context. 885 scoped_ptr<TestWebGraphicsContext3D> context = 886 TestWebGraphicsContext3D::Create(); 887 context->set_max_texture_size(140); 888 host_impl_.InitializeRenderer(FakeOutputSurface::Create3d( 889 context.Pass()).PassAs<OutputSurface>()); 890 891 pending_layer_->CalculateContentsScale( 892 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 893 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 894 895 pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 896 897 // Verify the tiles are not larger than the context's max texture size. 898 tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0]; 899 EXPECT_GE(140, tile->content_rect().width()); 900 EXPECT_GE(140, tile->content_rect().height()); 901} 902 903TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) { 904 // The default max tile size is larger than 400x400. 905 gfx::Size tile_size(400, 400); 906 gfx::Size layer_bounds(500, 500); 907 908 scoped_refptr<FakePicturePileImpl> pending_pile = 909 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 910 scoped_refptr<FakePicturePileImpl> active_pile = 911 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 912 913 float result_scale_x, result_scale_y; 914 gfx::Size result_bounds; 915 916 SetupTrees(pending_pile, active_pile); 917 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 918 919 pending_layer_->CalculateContentsScale( 920 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 921 ASSERT_LE(1u, pending_layer_->tilings()->num_tilings()); 922 923 pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 924 925 // The default value. The layer is smaller than this. 926 EXPECT_EQ(gfx::Size(512, 512).ToString(), 927 host_impl_.settings().max_untiled_layer_size.ToString()); 928 929 // There should be a single tile since the layer is small. 930 PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0); 931 EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size()); 932 933 pending_layer_->DidLoseOutputSurface(); 934 935 // Change the max texture size on the output surface context. 936 scoped_ptr<TestWebGraphicsContext3D> context = 937 TestWebGraphicsContext3D::Create(); 938 context->set_max_texture_size(140); 939 host_impl_.InitializeRenderer(FakeOutputSurface::Create3d( 940 context.Pass()).PassAs<OutputSurface>()); 941 942 pending_layer_->CalculateContentsScale( 943 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 944 ASSERT_LE(1u, pending_layer_->tilings()->num_tilings()); 945 946 pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 947 948 // There should be more than one tile since the max texture size won't cover 949 // the layer. 950 high_res_tiling = pending_layer_->tilings()->tiling_at(0); 951 EXPECT_LT(1u, high_res_tiling->AllTilesForTesting().size()); 952 953 // Verify the tiles are not larger than the context's max texture size. 954 Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0]; 955 EXPECT_GE(140, tile->content_rect().width()); 956 EXPECT_GE(140, tile->content_rect().height()); 957} 958 959TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) { 960 MockQuadCuller quad_culler; 961 962 gfx::Size tile_size(400, 400); 963 gfx::Size layer_bounds(1300, 1900); 964 965 scoped_refptr<FakePicturePileImpl> pending_pile = 966 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 967 scoped_refptr<FakePicturePileImpl> active_pile = 968 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 969 970 SetupTrees(pending_pile, active_pile); 971 972 active_layer_->SetContentBounds(layer_bounds); 973 active_layer_->draw_properties().visible_content_rect = 974 gfx::Rect(layer_bounds); 975 976 gfx::Rect layer_invalidation(150, 200, 30, 180); 977 Region invalidation(layer_invalidation); 978 AddDefaultTilingsWithInvalidation(invalidation); 979 980 AppendQuadsData data; 981 active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, NULL); 982 active_layer_->AppendQuads(&quad_culler, &data); 983 active_layer_->DidDraw(NULL); 984 985 ASSERT_EQ(1U, quad_culler.quad_list().size()); 986 EXPECT_EQ(DrawQuad::PICTURE_CONTENT, quad_culler.quad_list()[0]->material); 987} 988 989TEST_F(PictureLayerImplTest, MarkRequiredNullTiles) { 990 gfx::Size tile_size(100, 100); 991 gfx::Size layer_bounds(1000, 1000); 992 993 scoped_refptr<FakePicturePileImpl> pending_pile = 994 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 995 // Layers with entirely empty piles can't get tilings. 996 pending_pile->AddRecordingAt(0, 0); 997 998 SetupPendingTree(pending_pile); 999 1000 ASSERT_TRUE(pending_layer_->CanHaveTilings()); 1001 pending_layer_->AddTiling(1.0f); 1002 pending_layer_->AddTiling(2.0f); 1003 1004 // It should be safe to call this (and MarkVisibleResourcesAsRequired) 1005 // on a layer with no recordings. 1006 host_impl_.pending_tree()->UpdateDrawProperties(); 1007 pending_layer_->MarkVisibleResourcesAsRequired(); 1008} 1009 1010TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) { 1011 gfx::Size tile_size(100, 100); 1012 gfx::Size layer_bounds(200, 100); 1013 1014 scoped_refptr<FakePicturePileImpl> pending_pile = 1015 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1016 SetupPendingTree(pending_pile); 1017 1018 pending_layer_->set_fixed_tile_size(tile_size); 1019 ASSERT_TRUE(pending_layer_->CanHaveTilings()); 1020 PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f); 1021 host_impl_.pending_tree()->UpdateDrawProperties(); 1022 EXPECT_EQ(tiling->resolution(), HIGH_RESOLUTION); 1023 1024 // Fake set priorities. 1025 int tile_count = 0; 1026 for (PictureLayerTiling::CoverageIterator iter( 1027 tiling, 1028 pending_layer_->contents_scale_x(), 1029 gfx::Rect(pending_layer_->visible_content_rect())); 1030 iter; 1031 ++iter) { 1032 if (!*iter) 1033 continue; 1034 Tile* tile = *iter; 1035 TilePriority priority; 1036 priority.resolution = HIGH_RESOLUTION; 1037 if (++tile_count % 2) { 1038 priority.time_to_visible_in_seconds = 0.f; 1039 priority.distance_to_visible_in_pixels = 0.f; 1040 } else { 1041 priority.time_to_visible_in_seconds = 1.f; 1042 priority.distance_to_visible_in_pixels = 1.f; 1043 } 1044 tile->SetPriority(PENDING_TREE, priority); 1045 } 1046 1047 pending_layer_->MarkVisibleResourcesAsRequired(); 1048 1049 int num_visible = 0; 1050 int num_offscreen = 0; 1051 1052 for (PictureLayerTiling::CoverageIterator iter( 1053 tiling, 1054 pending_layer_->contents_scale_x(), 1055 gfx::Rect(pending_layer_->visible_content_rect())); 1056 iter; 1057 ++iter) { 1058 if (!*iter) 1059 continue; 1060 const Tile* tile = *iter; 1061 if (tile->priority(PENDING_TREE).distance_to_visible_in_pixels == 0.f) { 1062 EXPECT_TRUE(tile->required_for_activation()); 1063 num_visible++; 1064 } else { 1065 EXPECT_FALSE(tile->required_for_activation()); 1066 num_offscreen++; 1067 } 1068 } 1069 1070 EXPECT_GT(num_visible, 0); 1071 EXPECT_GT(num_offscreen, 0); 1072} 1073 1074TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) { 1075 gfx::Size tile_size(100, 100); 1076 gfx::Size layer_bounds(400, 400); 1077 scoped_refptr<FakePicturePileImpl> pending_pile = 1078 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1079 1080 host_impl_.CreatePendingTree(); 1081 LayerTreeImpl* pending_tree = host_impl_.pending_tree(); 1082 1083 scoped_ptr<FakePictureLayerImpl> pending_layer = 1084 FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pending_pile); 1085 pending_layer->SetDrawsContent(true); 1086 pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>()); 1087 1088 pending_layer_ = static_cast<FakePictureLayerImpl*>( 1089 host_impl_.pending_tree()->LayerById(id_)); 1090 1091 // Set some state on the pending layer, make sure it is not clobbered 1092 // by a sync from the active layer. This could happen because if the 1093 // pending layer has not been post-commit initialized it will attempt 1094 // to sync from the active layer. 1095 bool default_lcd_text_setting = pending_layer_->is_using_lcd_text(); 1096 pending_layer_->force_set_lcd_text(!default_lcd_text_setting); 1097 EXPECT_TRUE(pending_layer_->needs_post_commit_initialization()); 1098 1099 host_impl_.ActivatePendingTree(); 1100 1101 active_layer_ = static_cast<FakePictureLayerImpl*>( 1102 host_impl_.active_tree()->LayerById(id_)); 1103 1104 EXPECT_EQ(0u, active_layer_->num_tilings()); 1105 EXPECT_EQ(!default_lcd_text_setting, active_layer_->is_using_lcd_text()); 1106 EXPECT_FALSE(active_layer_->needs_post_commit_initialization()); 1107} 1108 1109// Solid color scrollbar setting is required for deferred initialization. 1110class ImplSidePaintingSolidColorScrollbarSettings 1111 : public ImplSidePaintingSettings { 1112 public: 1113 ImplSidePaintingSolidColorScrollbarSettings() { 1114 solid_color_scrollbars = true; 1115 } 1116}; 1117 1118class DeferredInitPictureLayerImplTest : public PictureLayerImplTest { 1119 public: 1120 DeferredInitPictureLayerImplTest() 1121 : PictureLayerImplTest(ImplSidePaintingSolidColorScrollbarSettings()) {} 1122 1123 virtual void InitializeRenderer() OVERRIDE { 1124 host_impl_.InitializeRenderer(FakeOutputSurface::CreateDeferredGL( 1125 scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice)) 1126 .PassAs<OutputSurface>()); 1127 } 1128 1129 virtual void SetUp() OVERRIDE { 1130 PictureLayerImplTest::SetUp(); 1131 1132 // Create some default active and pending trees. 1133 gfx::Size tile_size(100, 100); 1134 gfx::Size layer_bounds(400, 400); 1135 1136 scoped_refptr<FakePicturePileImpl> pending_pile = 1137 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1138 scoped_refptr<FakePicturePileImpl> active_pile = 1139 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1140 1141 SetupTrees(pending_pile, active_pile); 1142 } 1143}; 1144 1145// This test is really a LayerTreeHostImpl test, in that it makes sure 1146// that trees need update draw properties after deferred initialization. 1147// However, this is also a regression test for PictureLayerImpl in that 1148// not having this update will cause a crash. 1149TEST_F(DeferredInitPictureLayerImplTest, 1150 PreventUpdateTilePrioritiesDuringLostContext) { 1151 host_impl_.pending_tree()->UpdateDrawProperties(); 1152 host_impl_.active_tree()->UpdateDrawProperties(); 1153 EXPECT_FALSE(host_impl_.pending_tree()->needs_update_draw_properties()); 1154 EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties()); 1155 1156 FakeOutputSurface* fake_output_surface = 1157 static_cast<FakeOutputSurface*>(host_impl_.output_surface()); 1158 ASSERT_TRUE(fake_output_surface->InitializeAndSetContext3d( 1159 TestContextProvider::Create(), NULL)); 1160 1161 // These will crash PictureLayerImpl if this is not true. 1162 ASSERT_TRUE(host_impl_.pending_tree()->needs_update_draw_properties()); 1163 ASSERT_TRUE(host_impl_.active_tree()->needs_update_draw_properties()); 1164 host_impl_.active_tree()->UpdateDrawProperties(); 1165} 1166 1167} // namespace 1168} // namespace cc 1169