picture_layer_impl_unittest.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7
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/layers/append_quads_data.h" 10#include "cc/layers/picture_layer.h" 11#include "cc/test/fake_content_layer_client.h" 12#include "cc/test/fake_impl_proxy.h" 13#include "cc/test/fake_layer_tree_host_impl.h" 14#include "cc/test/fake_output_surface.h" 15#include "cc/test/fake_picture_layer_impl.h" 16#include "cc/test/fake_picture_pile_impl.h" 17#include "cc/test/geometry_test_utils.h" 18#include "cc/test/impl_side_painting_settings.h" 19#include "cc/test/mock_quad_culler.h" 20#include "cc/test/test_web_graphics_context_3d.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( 58 FakeOutputSurface::Create3d().PassAs<OutputSurface>()); 59 } 60 61 void SetupDefaultTrees(const gfx::Size& layer_bounds) { 62 gfx::Size tile_size(100, 100); 63 64 scoped_refptr<FakePicturePileImpl> pending_pile = 65 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 66 scoped_refptr<FakePicturePileImpl> active_pile = 67 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 68 69 SetupTrees(pending_pile, active_pile); 70 } 71 72 void ActivateTree() { 73 host_impl_.ActivatePendingTree(); 74 CHECK(!host_impl_.pending_tree()); 75 pending_layer_ = NULL; 76 active_layer_ = static_cast<FakePictureLayerImpl*>( 77 host_impl_.active_tree()->LayerById(id_)); 78 } 79 80 void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds, 81 const gfx::Size& tile_size) { 82 SetupDefaultTrees(layer_bounds); 83 pending_layer_->set_fixed_tile_size(tile_size); 84 active_layer_->set_fixed_tile_size(tile_size); 85 } 86 87 void SetupTrees( 88 scoped_refptr<PicturePileImpl> pending_pile, 89 scoped_refptr<PicturePileImpl> active_pile) { 90 SetupPendingTree(active_pile); 91 ActivateTree(); 92 SetupPendingTree(pending_pile); 93 } 94 95 void CreateHighLowResAndSetAllTilesVisible() { 96 // Active layer must get updated first so pending layer can share from it. 97 active_layer_->CreateDefaultTilingsAndTiles(); 98 active_layer_->SetAllTilesVisible(); 99 pending_layer_->CreateDefaultTilingsAndTiles(); 100 pending_layer_->SetAllTilesVisible(); 101 } 102 103 void AddDefaultTilingsWithInvalidation(const Region& invalidation) { 104 active_layer_->AddTiling(2.3f); 105 active_layer_->AddTiling(1.0f); 106 active_layer_->AddTiling(0.5f); 107 for (size_t i = 0; i < active_layer_->tilings()->num_tilings(); ++i) 108 active_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting(); 109 pending_layer_->set_invalidation(invalidation); 110 for (size_t i = 0; i < pending_layer_->tilings()->num_tilings(); ++i) 111 pending_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting(); 112 } 113 114 void SetupPendingTree( 115 scoped_refptr<PicturePileImpl> pile) { 116 host_impl_.CreatePendingTree(); 117 LayerTreeImpl* pending_tree = host_impl_.pending_tree(); 118 // Clear recycled tree. 119 pending_tree->DetachLayerTree(); 120 121 scoped_ptr<FakePictureLayerImpl> pending_layer = 122 FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile); 123 pending_layer->SetDrawsContent(true); 124 pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>()); 125 126 pending_layer_ = static_cast<FakePictureLayerImpl*>( 127 host_impl_.pending_tree()->LayerById(id_)); 128 pending_layer_->DoPostCommitInitializationIfNeeded(); 129 } 130 131 static void VerifyAllTilesExistAndHavePile( 132 const PictureLayerTiling* tiling, 133 PicturePileImpl* pile) { 134 for (PictureLayerTiling::CoverageIterator 135 iter(tiling, tiling->contents_scale(), tiling->ContentRect()); 136 iter; 137 ++iter) { 138 EXPECT_TRUE(*iter); 139 EXPECT_EQ(pile, iter->picture_pile()); 140 } 141 } 142 143 void SetContentsScaleOnBothLayers(float contents_scale, 144 float device_scale_factor, 145 float page_scale_factor, 146 bool animating_transform) { 147 float result_scale_x, result_scale_y; 148 gfx::Size result_bounds; 149 pending_layer_->CalculateContentsScale( 150 contents_scale, 151 device_scale_factor, 152 page_scale_factor, 153 animating_transform, 154 &result_scale_x, 155 &result_scale_y, 156 &result_bounds); 157 active_layer_->CalculateContentsScale( 158 contents_scale, 159 device_scale_factor, 160 page_scale_factor, 161 animating_transform, 162 &result_scale_x, 163 &result_scale_y, 164 &result_bounds); 165 } 166 167 void ResetTilingsAndRasterScales() { 168 pending_layer_->ReleaseResources(); 169 active_layer_->ReleaseResources(); 170 } 171 172 void AssertAllTilesRequired(PictureLayerTiling* tiling) { 173 std::vector<Tile*> tiles = tiling->AllTilesForTesting(); 174 for (size_t i = 0; i < tiles.size(); ++i) 175 EXPECT_TRUE(tiles[i]->required_for_activation()) << "i: " << i; 176 EXPECT_GT(tiles.size(), 0u); 177 } 178 179 void AssertNoTilesRequired(PictureLayerTiling* tiling) { 180 std::vector<Tile*> tiles = tiling->AllTilesForTesting(); 181 for (size_t i = 0; i < tiles.size(); ++i) 182 EXPECT_FALSE(tiles[i]->required_for_activation()) << "i: " << i; 183 EXPECT_GT(tiles.size(), 0u); 184 } 185 186 protected: 187 void TestTileGridAlignmentCommon() { 188 // Layer to span 4 raster tiles in x and in y 189 ImplSidePaintingSettings settings; 190 gfx::Size layer_size( 191 settings.default_tile_size.width() * 7 / 2, 192 settings.default_tile_size.height() * 7 / 2); 193 194 scoped_refptr<FakePicturePileImpl> pending_pile = 195 FakePicturePileImpl::CreateFilledPile(layer_size, layer_size); 196 scoped_refptr<FakePicturePileImpl> active_pile = 197 FakePicturePileImpl::CreateFilledPile(layer_size, layer_size); 198 199 SetupTrees(pending_pile, active_pile); 200 201 float result_scale_x, result_scale_y; 202 gfx::Size result_bounds; 203 active_layer_->CalculateContentsScale( 204 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 205 206 // Add 1x1 rects at the centers of each tile, then re-record pile contents 207 active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 208 std::vector<Tile*> tiles = 209 active_layer_->tilings()->tiling_at(0)->AllTilesForTesting(); 210 EXPECT_EQ(16u, tiles.size()); 211 std::vector<SkRect> rects; 212 std::vector<Tile*>::const_iterator tile_iter; 213 for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) { 214 gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint(); 215 gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1); 216 active_pile->add_draw_rect(rect); 217 rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1)); 218 } 219 // Force re-record with newly injected content 220 active_pile->RemoveRecordingAt(0, 0); 221 active_pile->AddRecordingAt(0, 0); 222 223 SkBitmap store; 224 store.setConfig(SkBitmap::kNo_Config, 1000, 1000); 225 SkBitmapDevice device(store); 226 227 std::vector<SkRect>::const_iterator rect_iter = rects.begin(); 228 for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) { 229 MockCanvas mock_canvas(&device); 230 active_pile->RasterDirect( 231 &mock_canvas, (*tile_iter)->content_rect(), 1.0f, NULL); 232 233 // This test verifies that when drawing the contents of a specific tile 234 // at content scale 1.0, the playback canvas never receives content from 235 // neighboring tiles which indicates that the tile grid embedded in 236 // SkPicture is perfectly aligned with the compositor's tiles. 237 EXPECT_EQ(1u, mock_canvas.rects_.size()); 238 EXPECT_RECT_EQ(*rect_iter, mock_canvas.rects_[0]); 239 rect_iter++; 240 } 241 } 242 243 FakeImplProxy proxy_; 244 FakeLayerTreeHostImpl host_impl_; 245 int id_; 246 FakePictureLayerImpl* pending_layer_; 247 FakePictureLayerImpl* active_layer_; 248 249 private: 250 DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest); 251}; 252 253TEST_F(PictureLayerImplTest, TileGridAlignment) { 254 host_impl_.SetDeviceScaleFactor(1.f); 255 TestTileGridAlignmentCommon(); 256} 257 258TEST_F(PictureLayerImplTest, TileGridAlignmentHiDPI) { 259 host_impl_.SetDeviceScaleFactor(2.f); 260 TestTileGridAlignmentCommon(); 261} 262 263TEST_F(PictureLayerImplTest, CloneNoInvalidation) { 264 gfx::Size tile_size(100, 100); 265 gfx::Size layer_bounds(400, 400); 266 267 scoped_refptr<FakePicturePileImpl> pending_pile = 268 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 269 scoped_refptr<FakePicturePileImpl> active_pile = 270 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 271 272 SetupTrees(pending_pile, active_pile); 273 274 Region invalidation; 275 AddDefaultTilingsWithInvalidation(invalidation); 276 277 EXPECT_EQ(pending_layer_->tilings()->num_tilings(), 278 active_layer_->tilings()->num_tilings()); 279 280 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 281 EXPECT_GT(tilings->num_tilings(), 0u); 282 for (size_t i = 0; i < tilings->num_tilings(); ++i) 283 VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), active_pile.get()); 284} 285 286TEST_F(PictureLayerImplTest, SuppressUpdateTilePriorities) { 287 base::TimeTicks time_ticks; 288 host_impl_.SetCurrentFrameTimeTicks(time_ticks); 289 290 gfx::Size tile_size(100, 100); 291 gfx::Size layer_bounds(400, 400); 292 293 scoped_refptr<FakePicturePileImpl> pending_pile = 294 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 295 scoped_refptr<FakePicturePileImpl> active_pile = 296 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 297 298 SetupTrees(pending_pile, active_pile); 299 300 Region invalidation; 301 AddDefaultTilingsWithInvalidation(invalidation); 302 float dummy_contents_scale_x; 303 float dummy_contents_scale_y; 304 gfx::Size dummy_content_bounds; 305 active_layer_->CalculateContentsScale(1.f, 306 1.f, 307 1.f, 308 false, 309 &dummy_contents_scale_x, 310 &dummy_contents_scale_y, 311 &dummy_content_bounds); 312 313 EXPECT_TRUE(host_impl_.manage_tiles_needed()); 314 active_layer_->UpdateTilePriorities(); 315 host_impl_.ManageTiles(); 316 EXPECT_FALSE(host_impl_.manage_tiles_needed()); 317 318 time_ticks += base::TimeDelta::FromMilliseconds(200); 319 host_impl_.SetCurrentFrameTimeTicks(time_ticks); 320 321 // Setting this boolean should cause an early out in UpdateTilePriorities. 322 bool valid_for_tile_management = false; 323 host_impl_.SetExternalDrawConstraints(gfx::Transform(), 324 gfx::Rect(layer_bounds), 325 gfx::Rect(layer_bounds), 326 valid_for_tile_management); 327 active_layer_->UpdateTilePriorities(); 328 EXPECT_FALSE(host_impl_.manage_tiles_needed()); 329 330 time_ticks += base::TimeDelta::FromMilliseconds(200); 331 host_impl_.SetCurrentFrameTimeTicks(time_ticks); 332 333 valid_for_tile_management = true; 334 host_impl_.SetExternalDrawConstraints(gfx::Transform(), 335 gfx::Rect(layer_bounds), 336 gfx::Rect(layer_bounds), 337 valid_for_tile_management); 338 active_layer_->UpdateTilePriorities(); 339 EXPECT_TRUE(host_impl_.manage_tiles_needed()); 340} 341 342TEST_F(PictureLayerImplTest, ClonePartialInvalidation) { 343 gfx::Size tile_size(100, 100); 344 gfx::Size layer_bounds(400, 400); 345 gfx::Rect layer_invalidation(150, 200, 30, 180); 346 347 scoped_refptr<FakePicturePileImpl> pending_pile = 348 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 349 scoped_refptr<FakePicturePileImpl> active_pile = 350 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 351 352 SetupTrees(pending_pile, active_pile); 353 354 Region invalidation(layer_invalidation); 355 AddDefaultTilingsWithInvalidation(invalidation); 356 357 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 358 EXPECT_GT(tilings->num_tilings(), 0u); 359 for (size_t i = 0; i < tilings->num_tilings(); ++i) { 360 const PictureLayerTiling* tiling = tilings->tiling_at(i); 361 gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect( 362 layer_invalidation, 363 tiling->contents_scale()); 364 for (PictureLayerTiling::CoverageIterator 365 iter(tiling, 366 tiling->contents_scale(), 367 tiling->ContentRect()); 368 iter; 369 ++iter) { 370 EXPECT_TRUE(*iter); 371 EXPECT_FALSE(iter.geometry_rect().IsEmpty()); 372 if (iter.geometry_rect().Intersects(content_invalidation)) 373 EXPECT_EQ(pending_pile, iter->picture_pile()); 374 else 375 EXPECT_EQ(active_pile, iter->picture_pile()); 376 } 377 } 378} 379 380TEST_F(PictureLayerImplTest, CloneFullInvalidation) { 381 gfx::Size tile_size(90, 80); 382 gfx::Size layer_bounds(300, 500); 383 384 scoped_refptr<FakePicturePileImpl> pending_pile = 385 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 386 scoped_refptr<FakePicturePileImpl> active_pile = 387 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 388 389 SetupTrees(pending_pile, active_pile); 390 391 Region invalidation((gfx::Rect(layer_bounds))); 392 AddDefaultTilingsWithInvalidation(invalidation); 393 394 EXPECT_EQ(pending_layer_->tilings()->num_tilings(), 395 active_layer_->tilings()->num_tilings()); 396 397 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 398 EXPECT_GT(tilings->num_tilings(), 0u); 399 for (size_t i = 0; i < tilings->num_tilings(); ++i) 400 VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get()); 401} 402 403TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) { 404 gfx::Size tile_size(90, 80); 405 gfx::Size active_layer_bounds(300, 500); 406 gfx::Size pending_layer_bounds(400, 800); 407 408 scoped_refptr<FakePicturePileImpl> pending_pile = 409 FakePicturePileImpl::CreateFilledPile(tile_size, 410 pending_layer_bounds); 411 scoped_refptr<FakePicturePileImpl> active_pile = 412 FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds); 413 414 SetupTrees(pending_pile, active_pile); 415 pending_layer_->set_fixed_tile_size(gfx::Size(100, 100)); 416 417 Region invalidation; 418 AddDefaultTilingsWithInvalidation(invalidation); 419 420 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 421 EXPECT_GT(tilings->num_tilings(), 0u); 422 for (size_t i = 0; i < tilings->num_tilings(); ++i) { 423 const PictureLayerTiling* tiling = tilings->tiling_at(i); 424 gfx::Rect active_content_bounds = gfx::ScaleToEnclosingRect( 425 gfx::Rect(active_layer_bounds), 426 tiling->contents_scale()); 427 for (PictureLayerTiling::CoverageIterator 428 iter(tiling, 429 tiling->contents_scale(), 430 tiling->ContentRect()); 431 iter; 432 ++iter) { 433 EXPECT_TRUE(*iter); 434 EXPECT_FALSE(iter.geometry_rect().IsEmpty()); 435 std::vector<Tile*> active_tiles = 436 active_layer_->tilings()->tiling_at(i)->AllTilesForTesting(); 437 std::vector<Tile*> pending_tiles = tiling->AllTilesForTesting(); 438 if (iter.geometry_rect().right() >= active_content_bounds.width() || 439 iter.geometry_rect().bottom() >= active_content_bounds.height() || 440 active_tiles[0]->content_rect().size() != 441 pending_tiles[0]->content_rect().size()) { 442 EXPECT_EQ(pending_pile, iter->picture_pile()); 443 } else { 444 EXPECT_EQ(active_pile, iter->picture_pile()); 445 } 446 } 447 } 448} 449 450TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) { 451 gfx::Size tile_size(400, 400); 452 gfx::Size layer_bounds(1300, 1900); 453 454 scoped_refptr<FakePicturePileImpl> pending_pile = 455 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 456 scoped_refptr<FakePicturePileImpl> active_pile = 457 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 458 459 // Fill in some of active pile, but more of pending pile. 460 int hole_count = 0; 461 for (int x = 0; x < active_pile->tiling().num_tiles_x(); ++x) { 462 for (int y = 0; y < active_pile->tiling().num_tiles_y(); ++y) { 463 if ((x + y) % 2) { 464 pending_pile->AddRecordingAt(x, y); 465 active_pile->AddRecordingAt(x, y); 466 } else { 467 hole_count++; 468 if (hole_count % 2) 469 pending_pile->AddRecordingAt(x, y); 470 } 471 } 472 } 473 474 SetupTrees(pending_pile, active_pile); 475 Region invalidation; 476 AddDefaultTilingsWithInvalidation(invalidation); 477 478 const PictureLayerTilingSet* tilings = pending_layer_->tilings(); 479 EXPECT_GT(tilings->num_tilings(), 0u); 480 for (size_t i = 0; i < tilings->num_tilings(); ++i) { 481 const PictureLayerTiling* tiling = tilings->tiling_at(i); 482 483 for (PictureLayerTiling::CoverageIterator 484 iter(tiling, 485 tiling->contents_scale(), 486 tiling->ContentRect()); 487 iter; 488 ++iter) { 489 EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty()); 490 // Ensure there is a recording for this tile. 491 gfx::Rect layer_rect = gfx::ScaleToEnclosingRect( 492 iter.full_tile_geometry_rect(), 1.f / tiling->contents_scale()); 493 layer_rect.Intersect(gfx::Rect(layer_bounds)); 494 495 bool in_pending = pending_pile->recorded_region().Contains(layer_rect); 496 bool in_active = active_pile->recorded_region().Contains(layer_rect); 497 498 if (in_pending && !in_active) 499 EXPECT_EQ(pending_pile, iter->picture_pile()); 500 else if (in_active) 501 EXPECT_EQ(active_pile, iter->picture_pile()); 502 else 503 EXPECT_FALSE(*iter); 504 } 505 } 506} 507 508TEST_F(PictureLayerImplTest, ManageTilingsWithNoRecording) { 509 gfx::Size tile_size(400, 400); 510 gfx::Size layer_bounds(1300, 1900); 511 512 scoped_refptr<FakePicturePileImpl> pending_pile = 513 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 514 scoped_refptr<FakePicturePileImpl> active_pile = 515 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 516 517 float result_scale_x, result_scale_y; 518 gfx::Size result_bounds; 519 520 SetupTrees(pending_pile, active_pile); 521 522 pending_layer_->CalculateContentsScale( 523 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 524 525 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 526} 527 528TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) { 529 gfx::Size tile_size(400, 400); 530 gfx::Size layer_bounds(1300, 1900); 531 532 scoped_refptr<FakePicturePileImpl> pending_pile = 533 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 534 scoped_refptr<FakePicturePileImpl> active_pile = 535 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 536 537 float result_scale_x, result_scale_y; 538 gfx::Size result_bounds; 539 540 SetupTrees(pending_pile, active_pile); 541 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 542 543 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 544 EXPECT_LT(low_res_factor, 1.f); 545 546 pending_layer_->CalculateContentsScale(1.3f, // ideal contents scale 547 1.7f, // device scale 548 3.2f, // page cale 549 false, 550 &result_scale_x, 551 &result_scale_y, 552 &result_bounds); 553 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 554 EXPECT_FLOAT_EQ( 555 1.3f, 556 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 557 EXPECT_FLOAT_EQ( 558 1.3f * low_res_factor, 559 pending_layer_->tilings()->tiling_at(1)->contents_scale()); 560 561 // If we change the layer's CSS scale factor, then we should not get new 562 // tilings. 563 pending_layer_->CalculateContentsScale(1.8f, // ideal contents scale 564 1.7f, // device scale 565 3.2f, // page cale 566 false, 567 &result_scale_x, 568 &result_scale_y, 569 &result_bounds); 570 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 571 EXPECT_FLOAT_EQ( 572 1.3f, 573 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 574 EXPECT_FLOAT_EQ( 575 1.3f * low_res_factor, 576 pending_layer_->tilings()->tiling_at(1)->contents_scale()); 577 578 // If we change the page scale factor, then we should get new tilings. 579 pending_layer_->CalculateContentsScale(1.8f, // ideal contents scale 580 1.7f, // device scale 581 2.2f, // page cale 582 false, 583 &result_scale_x, 584 &result_scale_y, 585 &result_bounds); 586 ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings()); 587 EXPECT_FLOAT_EQ( 588 1.8f, 589 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 590 EXPECT_FLOAT_EQ( 591 1.8f * low_res_factor, 592 pending_layer_->tilings()->tiling_at(2)->contents_scale()); 593 594 // If we change the device scale factor, then we should get new tilings. 595 pending_layer_->CalculateContentsScale(1.9f, // ideal contents scale 596 1.4f, // device scale 597 2.2f, // page cale 598 false, 599 &result_scale_x, 600 &result_scale_y, 601 &result_bounds); 602 ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings()); 603 EXPECT_FLOAT_EQ( 604 1.9f, 605 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 606 EXPECT_FLOAT_EQ( 607 1.9f * low_res_factor, 608 pending_layer_->tilings()->tiling_at(3)->contents_scale()); 609 610 // If we change the device scale factor, but end up at the same total scale 611 // factor somehow, then we don't get new tilings. 612 pending_layer_->CalculateContentsScale(1.9f, // ideal contents scale 613 2.2f, // device scale 614 1.4f, // page cale 615 false, 616 &result_scale_x, 617 &result_scale_y, 618 &result_bounds); 619 ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings()); 620 EXPECT_FLOAT_EQ( 621 1.9f, 622 pending_layer_->tilings()->tiling_at(0)->contents_scale()); 623 EXPECT_FLOAT_EQ( 624 1.9f * low_res_factor, 625 pending_layer_->tilings()->tiling_at(3)->contents_scale()); 626} 627 628TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) { 629 // This test makes sure that if a layer can have tilings, then a commit makes 630 // it not able to have tilings (empty size), and then a future commit that 631 // makes it valid again should be able to create tilings. 632 gfx::Size tile_size(400, 400); 633 gfx::Size layer_bounds(1300, 1900); 634 635 scoped_refptr<FakePicturePileImpl> empty_pile = 636 FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 0)); 637 scoped_refptr<FakePicturePileImpl> valid_pile = 638 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 639 640 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 641 EXPECT_LT(low_res_factor, 1.f); 642 643 float high_res_scale = 1.3f; 644 float low_res_scale = high_res_scale * low_res_factor; 645 float device_scale = 1.7f; 646 float page_scale = 3.2f; 647 float result_scale_x, result_scale_y; 648 gfx::Size result_bounds; 649 650 SetupPendingTree(valid_pile); 651 pending_layer_->CalculateContentsScale(high_res_scale, 652 device_scale, 653 page_scale, 654 false, 655 &result_scale_x, 656 &result_scale_y, 657 &result_bounds); 658 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 659 EXPECT_FLOAT_EQ(high_res_scale, 660 pending_layer_->HighResTiling()->contents_scale()); 661 EXPECT_FLOAT_EQ(low_res_scale, 662 pending_layer_->LowResTiling()->contents_scale()); 663 664 ActivateTree(); 665 SetupPendingTree(empty_pile); 666 pending_layer_->CalculateContentsScale(high_res_scale, 667 device_scale, 668 page_scale, 669 false, 670 &result_scale_x, 671 &result_scale_y, 672 &result_bounds); 673 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 674 ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings()); 675 676 ActivateTree(); 677 active_layer_->CalculateContentsScale(high_res_scale, 678 device_scale, 679 page_scale, 680 false, 681 &result_scale_x, 682 &result_scale_y, 683 &result_bounds); 684 ASSERT_EQ(0u, active_layer_->tilings()->num_tilings()); 685 686 SetupPendingTree(valid_pile); 687 pending_layer_->CalculateContentsScale(high_res_scale, 688 device_scale, 689 page_scale, 690 false, 691 &result_scale_x, 692 &result_scale_y, 693 &result_bounds); 694 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 695 ASSERT_EQ(0u, active_layer_->tilings()->num_tilings()); 696 EXPECT_FLOAT_EQ(high_res_scale, 697 pending_layer_->HighResTiling()->contents_scale()); 698 EXPECT_FLOAT_EQ(low_res_scale, 699 pending_layer_->LowResTiling()->contents_scale()); 700} 701 702TEST_F(PictureLayerImplTest, ZoomOutCrash) { 703 gfx::Size tile_size(400, 400); 704 gfx::Size layer_bounds(1300, 1900); 705 706 // Set up the high and low res tilings before pinch zoom. 707 scoped_refptr<FakePicturePileImpl> pending_pile = 708 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 709 scoped_refptr<FakePicturePileImpl> active_pile = 710 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 711 712 SetupTrees(pending_pile, active_pile); 713 EXPECT_EQ(0u, active_layer_->tilings()->num_tilings()); 714 SetContentsScaleOnBothLayers(32.0f, 1.0f, 32.0f, false); 715 host_impl_.PinchGestureBegin(); 716 SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, false); 717 SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, false); 718 EXPECT_EQ(active_layer_->tilings()->NumHighResTilings(), 1); 719} 720 721TEST_F(PictureLayerImplTest, PinchGestureTilings) { 722 gfx::Size tile_size(400, 400); 723 gfx::Size layer_bounds(1300, 1900); 724 725 scoped_refptr<FakePicturePileImpl> pending_pile = 726 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 727 scoped_refptr<FakePicturePileImpl> active_pile = 728 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 729 730 // Set up the high and low res tilings before pinch zoom. 731 SetupTrees(pending_pile, active_pile); 732 EXPECT_EQ(0u, active_layer_->tilings()->num_tilings()); 733 SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, false); 734 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 735 EXPECT_EQ(2u, active_layer_->tilings()->num_tilings()); 736 EXPECT_FLOAT_EQ( 737 1.0f, 738 active_layer_->tilings()->tiling_at(0)->contents_scale()); 739 EXPECT_FLOAT_EQ( 740 1.0f * low_res_factor, 741 active_layer_->tilings()->tiling_at(1)->contents_scale()); 742 743 // Start a pinch gesture. 744 host_impl_.PinchGestureBegin(); 745 746 // Zoom out by a small amount. We should create a tiling at half 747 // the scale (1/kMaxScaleRatioDuringPinch). 748 SetContentsScaleOnBothLayers(0.90f, 1.0f, 0.9f, false); 749 EXPECT_EQ(3u, active_layer_->tilings()->num_tilings()); 750 EXPECT_FLOAT_EQ( 751 1.0f, 752 active_layer_->tilings()->tiling_at(0)->contents_scale()); 753 EXPECT_FLOAT_EQ( 754 0.5f, 755 active_layer_->tilings()->tiling_at(1)->contents_scale()); 756 EXPECT_FLOAT_EQ( 757 1.0f * low_res_factor, 758 active_layer_->tilings()->tiling_at(2)->contents_scale()); 759 760 // Zoom out further, close to our low-res scale factor. We should 761 // use that tiling as high-res, and not create a new tiling. 762 SetContentsScaleOnBothLayers(low_res_factor, 1.0f, low_res_factor, false); 763 EXPECT_EQ(3u, active_layer_->tilings()->num_tilings()); 764 765 // Zoom in a lot now. Since we increase by increments of 766 // kMaxScaleRatioDuringPinch, this will first use 0.5, then 1.0 767 // and then finally create a new tiling at 2.0. 768 SetContentsScaleOnBothLayers(2.1f, 1.0f, 2.1f, false); 769 EXPECT_EQ(3u, active_layer_->tilings()->num_tilings()); 770 SetContentsScaleOnBothLayers(2.1f, 1.0f, 2.1f, false); 771 EXPECT_EQ(3u, active_layer_->tilings()->num_tilings()); 772 SetContentsScaleOnBothLayers(2.1f, 1.0f, 2.1f, false); 773 EXPECT_EQ(4u, active_layer_->tilings()->num_tilings()); 774 EXPECT_FLOAT_EQ( 775 2.0f, 776 active_layer_->tilings()->tiling_at(0)->contents_scale()); 777} 778 779TEST_F(PictureLayerImplTest, CleanUpTilings) { 780 gfx::Size tile_size(400, 400); 781 gfx::Size layer_bounds(1300, 1900); 782 783 scoped_refptr<FakePicturePileImpl> pending_pile = 784 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 785 scoped_refptr<FakePicturePileImpl> active_pile = 786 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 787 788 float result_scale_x, result_scale_y; 789 gfx::Size result_bounds; 790 std::vector<PictureLayerTiling*> used_tilings; 791 792 SetupTrees(pending_pile, active_pile); 793 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 794 795 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 796 EXPECT_LT(low_res_factor, 1.f); 797 798 float device_scale = 1.7f; 799 float page_scale = 3.2f; 800 801 SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, false); 802 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 803 804 // We only have ideal tilings, so they aren't removed. 805 used_tilings.clear(); 806 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 807 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 808 809 // Changing the ideal but not creating new tilings. 810 SetContentsScaleOnBothLayers(1.5f, device_scale, page_scale, false); 811 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 812 813 // The tilings are still our target scale, so they aren't removed. 814 used_tilings.clear(); 815 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 816 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 817 818 // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2. 819 page_scale = 1.2f; 820 SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, false); 821 ASSERT_EQ(4u, active_layer_->tilings()->num_tilings()); 822 EXPECT_FLOAT_EQ( 823 1.f, 824 active_layer_->tilings()->tiling_at(1)->contents_scale()); 825 EXPECT_FLOAT_EQ( 826 1.f * low_res_factor, 827 active_layer_->tilings()->tiling_at(3)->contents_scale()); 828 829 // Mark the non-ideal tilings as used. They won't be removed. 830 used_tilings.clear(); 831 used_tilings.push_back(active_layer_->tilings()->tiling_at(1)); 832 used_tilings.push_back(active_layer_->tilings()->tiling_at(3)); 833 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 834 ASSERT_EQ(4u, active_layer_->tilings()->num_tilings()); 835 836 // Now move the ideal scale to 0.5. Our target stays 1.2. 837 SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, false); 838 839 // The high resolution tiling is between target and ideal, so is not 840 // removed. The low res tiling for the old ideal=1.0 scale is removed. 841 used_tilings.clear(); 842 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 843 ASSERT_EQ(3u, active_layer_->tilings()->num_tilings()); 844 845 // Now move the ideal scale to 1.0. Our target stays 1.2. 846 SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, false); 847 848 // All the tilings are between are target and the ideal, so they are not 849 // removed. 850 used_tilings.clear(); 851 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 852 ASSERT_EQ(3u, active_layer_->tilings()->num_tilings()); 853 854 // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2. 855 active_layer_->CalculateContentsScale(1.1f, 856 device_scale, 857 page_scale, 858 false, 859 &result_scale_x, 860 &result_scale_y, 861 &result_bounds); 862 863 // Because the pending layer's ideal scale is still 1.0, our tilings fall 864 // in the range [1.0,1.2] and are kept. 865 used_tilings.clear(); 866 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 867 ASSERT_EQ(3u, active_layer_->tilings()->num_tilings()); 868 869 // Move the ideal scale on the pending layer to 1.1 as well. Our target stays 870 // 1.2 still. 871 pending_layer_->CalculateContentsScale(1.1f, 872 device_scale, 873 page_scale, 874 false, 875 &result_scale_x, 876 &result_scale_y, 877 &result_bounds); 878 879 // Our 1.0 tiling now falls outside the range between our ideal scale and our 880 // target raster scale. But it is in our used tilings set, so nothing is 881 // deleted. 882 used_tilings.clear(); 883 used_tilings.push_back(active_layer_->tilings()->tiling_at(1)); 884 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 885 ASSERT_EQ(3u, active_layer_->tilings()->num_tilings()); 886 887 // If we remove it from our used tilings set, it is outside the range to keep 888 // so it is deleted. 889 used_tilings.clear(); 890 active_layer_->CleanUpTilingsOnActiveLayer(used_tilings); 891 ASSERT_EQ(2u, active_layer_->tilings()->num_tilings()); 892} 893 894#define EXPECT_BOTH_EQ(expression, x) \ 895 do { \ 896 EXPECT_EQ(pending_layer_->expression, x); \ 897 EXPECT_EQ(active_layer_->expression, x); \ 898 } while (false) 899 900TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) { 901 // Make sure this layer covers multiple tiles, since otherwise low 902 // res won't get created because it is too small. 903 gfx::Size tile_size(host_impl_.settings().default_tile_size); 904 SetupDefaultTrees(gfx::Size(tile_size.width() + 1, tile_size.height() + 1)); 905 // Avoid max untiled layer size heuristics via fixed tile size. 906 pending_layer_->set_fixed_tile_size(tile_size); 907 active_layer_->set_fixed_tile_size(tile_size); 908 909 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 910 float contents_scale = 1.f; 911 float device_scale = 1.f; 912 float page_scale = 1.f; 913 bool animating_transform = true; 914 915 // Animating, so don't create low res even if there isn't one already. 916 SetContentsScaleOnBothLayers( 917 contents_scale, device_scale, page_scale, animating_transform); 918 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f); 919 EXPECT_BOTH_EQ(num_tilings(), 1u); 920 921 // Stop animating, low res gets created. 922 animating_transform = false; 923 SetContentsScaleOnBothLayers( 924 contents_scale, device_scale, page_scale, animating_transform); 925 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f); 926 EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor); 927 EXPECT_BOTH_EQ(num_tilings(), 2u); 928 929 // Page scale animation, new high res, but not new low res because animating. 930 contents_scale = 2.f; 931 page_scale = 2.f; 932 animating_transform = true; 933 SetContentsScaleOnBothLayers( 934 contents_scale, device_scale, page_scale, animating_transform); 935 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f); 936 EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor); 937 EXPECT_BOTH_EQ(num_tilings(), 3u); 938 939 // Stop animating, new low res gets created for final page scale. 940 animating_transform = false; 941 SetContentsScaleOnBothLayers( 942 contents_scale, device_scale, page_scale, animating_transform); 943 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f); 944 EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 2.f * low_res_factor); 945 EXPECT_BOTH_EQ(num_tilings(), 4u); 946} 947 948TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) { 949 gfx::Size tile_size(host_impl_.settings().default_tile_size); 950 SetupDefaultTrees(tile_size); 951 952 float low_res_factor = host_impl_.settings().low_res_contents_scale_factor; 953 float device_scale = 1.f; 954 float page_scale = 1.f; 955 bool animating_transform = false; 956 957 // Contents exactly fit on one tile at scale 1, no low res. 958 float contents_scale = 1.f; 959 SetContentsScaleOnBothLayers( 960 contents_scale, device_scale, page_scale, animating_transform); 961 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale); 962 EXPECT_BOTH_EQ(num_tilings(), 1u); 963 964 ResetTilingsAndRasterScales(); 965 966 // Contents that are smaller than one tile, no low res. 967 contents_scale = 0.123f; 968 SetContentsScaleOnBothLayers( 969 contents_scale, device_scale, page_scale, animating_transform); 970 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale); 971 EXPECT_BOTH_EQ(num_tilings(), 1u); 972 973 ResetTilingsAndRasterScales(); 974 975 // Any content bounds that would create more than one tile will 976 // generate a low res tiling. 977 contents_scale = 2.5f; 978 SetContentsScaleOnBothLayers( 979 contents_scale, device_scale, page_scale, animating_transform); 980 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale); 981 EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 982 contents_scale * low_res_factor); 983 EXPECT_BOTH_EQ(num_tilings(), 2u); 984 985 ResetTilingsAndRasterScales(); 986 987 // Mask layers dont create low res since they always fit on one tile. 988 pending_layer_->SetIsMask(true); 989 active_layer_->SetIsMask(true); 990 SetContentsScaleOnBothLayers( 991 contents_scale, device_scale, page_scale, animating_transform); 992 EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale); 993 EXPECT_BOTH_EQ(num_tilings(), 1u); 994} 995 996TEST_F(PictureLayerImplTest, ReleaseResources) { 997 gfx::Size tile_size(400, 400); 998 gfx::Size layer_bounds(1300, 1900); 999 1000 scoped_refptr<FakePicturePileImpl> pending_pile = 1001 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1002 scoped_refptr<FakePicturePileImpl> active_pile = 1003 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1004 1005 float result_scale_x, result_scale_y; 1006 gfx::Size result_bounds; 1007 1008 SetupTrees(pending_pile, active_pile); 1009 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 1010 1011 pending_layer_->CalculateContentsScale(1.3f, // ideal contents scale 1012 2.7f, // device scale 1013 3.2f, // page cale 1014 false, 1015 &result_scale_x, 1016 &result_scale_y, 1017 &result_bounds); 1018 EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings()); 1019 1020 // All tilings should be removed when losing output surface. 1021 active_layer_->ReleaseResources(); 1022 EXPECT_EQ(0u, active_layer_->tilings()->num_tilings()); 1023 pending_layer_->ReleaseResources(); 1024 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 1025 1026 // This should create new tilings. 1027 pending_layer_->CalculateContentsScale(1.3f, // ideal contents scale 1028 2.7f, // device scale 1029 3.2f, // page cale 1030 false, 1031 &result_scale_x, 1032 &result_scale_y, 1033 &result_bounds); 1034 EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings()); 1035} 1036 1037TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) { 1038 // The default max tile size is larger than 400x400. 1039 gfx::Size tile_size(400, 400); 1040 gfx::Size layer_bounds(5000, 5000); 1041 1042 scoped_refptr<FakePicturePileImpl> pending_pile = 1043 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1044 scoped_refptr<FakePicturePileImpl> active_pile = 1045 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1046 1047 float result_scale_x, result_scale_y; 1048 gfx::Size result_bounds; 1049 1050 SetupTrees(pending_pile, active_pile); 1051 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 1052 1053 pending_layer_->CalculateContentsScale( 1054 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 1055 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 1056 1057 pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 1058 1059 // The default value. 1060 EXPECT_EQ(gfx::Size(256, 256).ToString(), 1061 host_impl_.settings().default_tile_size.ToString()); 1062 1063 Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0]; 1064 EXPECT_EQ(gfx::Size(256, 256).ToString(), 1065 tile->content_rect().size().ToString()); 1066 1067 pending_layer_->ReleaseResources(); 1068 1069 // Change the max texture size on the output surface context. 1070 scoped_ptr<TestWebGraphicsContext3D> context = 1071 TestWebGraphicsContext3D::Create(); 1072 context->set_max_texture_size(140); 1073 host_impl_.DidLoseOutputSurface(); 1074 host_impl_.InitializeRenderer(FakeOutputSurface::Create3d( 1075 context.Pass()).PassAs<OutputSurface>()); 1076 1077 pending_layer_->CalculateContentsScale( 1078 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 1079 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 1080 1081 pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 1082 1083 // Verify the tiles are not larger than the context's max texture size. 1084 tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0]; 1085 EXPECT_GE(140, tile->content_rect().width()); 1086 EXPECT_GE(140, tile->content_rect().height()); 1087} 1088 1089TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) { 1090 // The default max tile size is larger than 400x400. 1091 gfx::Size tile_size(400, 400); 1092 gfx::Size layer_bounds(500, 500); 1093 1094 scoped_refptr<FakePicturePileImpl> pending_pile = 1095 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1096 scoped_refptr<FakePicturePileImpl> active_pile = 1097 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1098 1099 float result_scale_x, result_scale_y; 1100 gfx::Size result_bounds; 1101 1102 SetupTrees(pending_pile, active_pile); 1103 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 1104 1105 pending_layer_->CalculateContentsScale( 1106 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 1107 ASSERT_LE(1u, pending_layer_->tilings()->num_tilings()); 1108 1109 pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 1110 1111 // The default value. The layer is smaller than this. 1112 EXPECT_EQ(gfx::Size(512, 512).ToString(), 1113 host_impl_.settings().max_untiled_layer_size.ToString()); 1114 1115 // There should be a single tile since the layer is small. 1116 PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0); 1117 EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size()); 1118 1119 pending_layer_->ReleaseResources(); 1120 1121 // Change the max texture size on the output surface context. 1122 scoped_ptr<TestWebGraphicsContext3D> context = 1123 TestWebGraphicsContext3D::Create(); 1124 context->set_max_texture_size(140); 1125 host_impl_.DidLoseOutputSurface(); 1126 host_impl_.InitializeRenderer(FakeOutputSurface::Create3d( 1127 context.Pass()).PassAs<OutputSurface>()); 1128 1129 pending_layer_->CalculateContentsScale( 1130 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 1131 ASSERT_LE(1u, pending_layer_->tilings()->num_tilings()); 1132 1133 pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting(); 1134 1135 // There should be more than one tile since the max texture size won't cover 1136 // the layer. 1137 high_res_tiling = pending_layer_->tilings()->tiling_at(0); 1138 EXPECT_LT(1u, high_res_tiling->AllTilesForTesting().size()); 1139 1140 // Verify the tiles are not larger than the context's max texture size. 1141 Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0]; 1142 EXPECT_GE(140, tile->content_rect().width()); 1143 EXPECT_GE(140, tile->content_rect().height()); 1144} 1145 1146TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) { 1147 MockQuadCuller quad_culler; 1148 1149 gfx::Size tile_size(400, 400); 1150 gfx::Size layer_bounds(1300, 1900); 1151 1152 scoped_refptr<FakePicturePileImpl> pending_pile = 1153 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1154 scoped_refptr<FakePicturePileImpl> active_pile = 1155 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1156 1157 SetupTrees(pending_pile, active_pile); 1158 1159 active_layer_->SetContentBounds(layer_bounds); 1160 active_layer_->draw_properties().visible_content_rect = 1161 gfx::Rect(layer_bounds); 1162 1163 gfx::Rect layer_invalidation(150, 200, 30, 180); 1164 Region invalidation(layer_invalidation); 1165 AddDefaultTilingsWithInvalidation(invalidation); 1166 1167 AppendQuadsData data; 1168 active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, NULL); 1169 active_layer_->AppendQuads(&quad_culler, &data); 1170 active_layer_->DidDraw(NULL); 1171 1172 ASSERT_EQ(1U, quad_culler.quad_list().size()); 1173 EXPECT_EQ(DrawQuad::PICTURE_CONTENT, quad_culler.quad_list()[0]->material); 1174} 1175 1176TEST_F(PictureLayerImplTest, MarkRequiredNullTiles) { 1177 gfx::Size tile_size(100, 100); 1178 gfx::Size layer_bounds(1000, 1000); 1179 1180 scoped_refptr<FakePicturePileImpl> pending_pile = 1181 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 1182 // Layers with entirely empty piles can't get tilings. 1183 pending_pile->AddRecordingAt(0, 0); 1184 1185 SetupPendingTree(pending_pile); 1186 1187 ASSERT_TRUE(pending_layer_->CanHaveTilings()); 1188 pending_layer_->AddTiling(1.0f); 1189 pending_layer_->AddTiling(2.0f); 1190 1191 // It should be safe to call this (and MarkVisibleResourcesAsRequired) 1192 // on a layer with no recordings. 1193 host_impl_.pending_tree()->UpdateDrawProperties(); 1194 pending_layer_->MarkVisibleResourcesAsRequired(); 1195} 1196 1197TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) { 1198 gfx::Size tile_size(100, 100); 1199 gfx::Size layer_bounds(200, 200); 1200 1201 scoped_refptr<FakePicturePileImpl> pending_pile = 1202 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1203 SetupPendingTree(pending_pile); 1204 1205 pending_layer_->set_fixed_tile_size(tile_size); 1206 ASSERT_TRUE(pending_layer_->CanHaveTilings()); 1207 PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f); 1208 host_impl_.pending_tree()->UpdateDrawProperties(); 1209 EXPECT_EQ(tiling->resolution(), HIGH_RESOLUTION); 1210 1211 pending_layer_->draw_properties().visible_content_rect = 1212 gfx::Rect(0, 0, 100, 200); 1213 1214 // Fake set priorities. 1215 for (PictureLayerTiling::CoverageIterator iter( 1216 tiling, pending_layer_->contents_scale_x(), gfx::Rect(layer_bounds)); 1217 iter; 1218 ++iter) { 1219 if (!*iter) 1220 continue; 1221 Tile* tile = *iter; 1222 TilePriority priority; 1223 priority.resolution = HIGH_RESOLUTION; 1224 gfx::Rect tile_bounds = iter.geometry_rect(); 1225 if (pending_layer_->visible_content_rect().Intersects(tile_bounds)) { 1226 priority.priority_bin = TilePriority::NOW; 1227 priority.distance_to_visible = 0.f; 1228 } else { 1229 priority.priority_bin = TilePriority::SOON; 1230 priority.distance_to_visible = 1.f; 1231 } 1232 tile->SetPriority(PENDING_TREE, priority); 1233 } 1234 1235 pending_layer_->MarkVisibleResourcesAsRequired(); 1236 1237 int num_visible = 0; 1238 int num_offscreen = 0; 1239 1240 for (PictureLayerTiling::CoverageIterator iter( 1241 tiling, pending_layer_->contents_scale_x(), gfx::Rect(layer_bounds)); 1242 iter; 1243 ++iter) { 1244 if (!*iter) 1245 continue; 1246 const Tile* tile = *iter; 1247 if (tile->priority(PENDING_TREE).distance_to_visible == 0.f) { 1248 EXPECT_TRUE(tile->required_for_activation()); 1249 num_visible++; 1250 } else { 1251 EXPECT_FALSE(tile->required_for_activation()); 1252 num_offscreen++; 1253 } 1254 } 1255 1256 EXPECT_GT(num_visible, 0); 1257 EXPECT_GT(num_offscreen, 0); 1258} 1259 1260TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) { 1261 gfx::Size layer_bounds(400, 400); 1262 gfx::Size tile_size(100, 100); 1263 SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size); 1264 1265 // No tiles shared. 1266 pending_layer_->set_invalidation(gfx::Rect(layer_bounds)); 1267 1268 CreateHighLowResAndSetAllTilesVisible(); 1269 1270 active_layer_->SetAllTilesReady(); 1271 1272 // No shared tiles and all active tiles ready, so pending can only 1273 // activate with all high res tiles. 1274 pending_layer_->MarkVisibleResourcesAsRequired(); 1275 AssertAllTilesRequired(pending_layer_->HighResTiling()); 1276 AssertNoTilesRequired(pending_layer_->LowResTiling()); 1277} 1278 1279TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) { 1280 gfx::Size layer_bounds(400, 400); 1281 gfx::Size tile_size(100, 100); 1282 SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size); 1283 1284 // All tiles shared (no invalidation). 1285 CreateHighLowResAndSetAllTilesVisible(); 1286 1287 // Verify active tree not ready. 1288 Tile* some_active_tile = 1289 active_layer_->HighResTiling()->AllTilesForTesting()[0]; 1290 EXPECT_FALSE(some_active_tile->IsReadyToDraw()); 1291 1292 // When high res are required, even if the active tree is not ready, 1293 // the high res tiles must be ready. 1294 host_impl_.active_tree()->SetRequiresHighResToDraw(); 1295 pending_layer_->MarkVisibleResourcesAsRequired(); 1296 AssertAllTilesRequired(pending_layer_->HighResTiling()); 1297 AssertNoTilesRequired(pending_layer_->LowResTiling()); 1298} 1299 1300TEST_F(PictureLayerImplTest, NothingRequiredIfAllHighResTilesShared) { 1301 gfx::Size layer_bounds(400, 400); 1302 gfx::Size tile_size(100, 100); 1303 SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size); 1304 1305 CreateHighLowResAndSetAllTilesVisible(); 1306 1307 Tile* some_active_tile = 1308 active_layer_->HighResTiling()->AllTilesForTesting()[0]; 1309 EXPECT_FALSE(some_active_tile->IsReadyToDraw()); 1310 1311 // All tiles shared (no invalidation), so even though the active tree's 1312 // tiles aren't ready, there is nothing required. 1313 pending_layer_->MarkVisibleResourcesAsRequired(); 1314 AssertNoTilesRequired(pending_layer_->HighResTiling()); 1315 AssertNoTilesRequired(pending_layer_->LowResTiling()); 1316} 1317 1318TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) { 1319 gfx::Size layer_bounds(400, 400); 1320 gfx::Size tile_size(100, 100); 1321 scoped_refptr<FakePicturePileImpl> pending_pile = 1322 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1323 // An arbitrary bogus outside the layer recording. Enough for the layer to 1324 // think it can create tiles, but not in bounds so all tiles are null. 1325 Region active_recorded_region; 1326 active_recorded_region.Union(gfx::Rect(1000, 1000, 1, 1)); 1327 scoped_refptr<FakePicturePileImpl> active_pile = 1328 FakePicturePileImpl::CreatePileWithRecordedRegion( 1329 tile_size, layer_bounds, active_recorded_region); 1330 SetupTrees(pending_pile, active_pile); 1331 pending_layer_->set_fixed_tile_size(tile_size); 1332 active_layer_->set_fixed_tile_size(tile_size); 1333 1334 CreateHighLowResAndSetAllTilesVisible(); 1335 1336 // Active layer has tilings, but no tiles due to missing recordings. 1337 EXPECT_TRUE(active_layer_->CanHaveTilings()); 1338 EXPECT_EQ(active_layer_->tilings()->num_tilings(), 2u); 1339 EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u); 1340 1341 // Since the active layer has no tiles at all, the pending layer doesn't 1342 // need content in order to activate. This is attempting to simulate 1343 // scrolling past the end of recorded content on the active layer. 1344 pending_layer_->MarkVisibleResourcesAsRequired(); 1345 AssertNoTilesRequired(pending_layer_->HighResTiling()); 1346 AssertNoTilesRequired(pending_layer_->LowResTiling()); 1347} 1348 1349TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) { 1350 gfx::Size layer_bounds(400, 400); 1351 gfx::Size tile_size(100, 100); 1352 scoped_refptr<FakePicturePileImpl> pending_pile = 1353 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1354 scoped_refptr<FakePicturePileImpl> active_pile = 1355 FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds); 1356 SetupTrees(pending_pile, active_pile); 1357 pending_layer_->set_fixed_tile_size(tile_size); 1358 active_layer_->set_fixed_tile_size(tile_size); 1359 1360 CreateHighLowResAndSetAllTilesVisible(); 1361 1362 // Active layer can't have tiles. 1363 EXPECT_FALSE(active_layer_->CanHaveTilings()); 1364 1365 // All high res tiles required. This should be considered identical 1366 // to the case where there is no active layer, to avoid flashing content. 1367 // This can happen if a layer exists for a while and switches from 1368 // not being able to have content to having content. 1369 pending_layer_->MarkVisibleResourcesAsRequired(); 1370 AssertAllTilesRequired(pending_layer_->HighResTiling()); 1371 AssertNoTilesRequired(pending_layer_->LowResTiling()); 1372} 1373 1374TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) { 1375 gfx::Size tile_size(100, 100); 1376 gfx::Size layer_bounds(400, 400); 1377 scoped_refptr<FakePicturePileImpl> pending_pile = 1378 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1379 1380 host_impl_.CreatePendingTree(); 1381 LayerTreeImpl* pending_tree = host_impl_.pending_tree(); 1382 1383 scoped_ptr<FakePictureLayerImpl> pending_layer = 1384 FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pending_pile); 1385 pending_layer->SetDrawsContent(true); 1386 pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>()); 1387 1388 pending_layer_ = static_cast<FakePictureLayerImpl*>( 1389 host_impl_.pending_tree()->LayerById(id_)); 1390 1391 // Set some state on the pending layer, make sure it is not clobbered 1392 // by a sync from the active layer. This could happen because if the 1393 // pending layer has not been post-commit initialized it will attempt 1394 // to sync from the active layer. 1395 bool default_lcd_text_setting = pending_layer_->is_using_lcd_text(); 1396 pending_layer_->force_set_lcd_text(!default_lcd_text_setting); 1397 EXPECT_TRUE(pending_layer_->needs_post_commit_initialization()); 1398 1399 host_impl_.ActivatePendingTree(); 1400 1401 active_layer_ = static_cast<FakePictureLayerImpl*>( 1402 host_impl_.active_tree()->LayerById(id_)); 1403 1404 EXPECT_EQ(0u, active_layer_->num_tilings()); 1405 EXPECT_EQ(!default_lcd_text_setting, active_layer_->is_using_lcd_text()); 1406 EXPECT_FALSE(active_layer_->needs_post_commit_initialization()); 1407} 1408 1409TEST_F(PictureLayerImplTest, SyncTilingAfterReleaseResource) { 1410 SetupDefaultTrees(gfx::Size(10, 10)); 1411 host_impl_.active_tree()->UpdateDrawProperties(); 1412 EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties()); 1413 1414 // Contrived unit test of a real crash. A layer is transparent during a 1415 // context loss, and later becomes opaque, causing active layer SyncTiling to 1416 // be called. 1417 const float tile_scale = 2.f; 1418 active_layer_->ReleaseResources(); 1419 EXPECT_FALSE(active_layer_->tilings()->TilingAtScale(tile_scale)); 1420 pending_layer_->AddTiling(2.f); 1421 EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(tile_scale)); 1422} 1423 1424TEST_F(PictureLayerImplTest, TilingGpuRasterization) { 1425 gfx::Size default_tile_size(host_impl_.settings().default_tile_size); 1426 gfx::Size layer_bounds(default_tile_size.width() * 4, 1427 default_tile_size.height() * 4); 1428 float result_scale_x, result_scale_y; 1429 gfx::Size result_bounds; 1430 1431 // Layers without GPU rasterization (default). 1432 SetupDefaultTrees(layer_bounds); 1433 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 1434 pending_layer_->CalculateContentsScale( 1435 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 1436 // Should have a low-res and a high-res tiling. 1437 ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings()); 1438 1439 // Tell the layer to use GPU rasterization. 1440 pending_layer_->SetShouldUseGpuRasterization(true); 1441 EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings()); 1442 pending_layer_->CalculateContentsScale( 1443 1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds); 1444 // Should only have the high-res tiling. 1445 ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings()); 1446} 1447 1448TEST_F(PictureLayerImplTest, NoTilingIfDoesNotDrawContent) { 1449 // Set up layers with tilings. 1450 SetupDefaultTrees(gfx::Size(10, 10)); 1451 SetContentsScaleOnBothLayers(1.f, 1.f, 1.f, false); 1452 pending_layer_->PushPropertiesTo(active_layer_); 1453 EXPECT_TRUE(pending_layer_->DrawsContent()); 1454 EXPECT_TRUE(pending_layer_->CanHaveTilings()); 1455 EXPECT_GE(pending_layer_->num_tilings(), 0u); 1456 EXPECT_GE(active_layer_->num_tilings(), 0u); 1457 1458 // Set content to false, which should make CanHaveTilings return false. 1459 pending_layer_->SetDrawsContent(false); 1460 EXPECT_FALSE(pending_layer_->DrawsContent()); 1461 EXPECT_FALSE(pending_layer_->CanHaveTilings()); 1462 1463 // No tilings should be pushed to active layer. 1464 pending_layer_->PushPropertiesTo(active_layer_); 1465 EXPECT_EQ(0u, active_layer_->num_tilings()); 1466} 1467 1468TEST_F(PictureLayerImplTest, FirstTilingDuringPinch) { 1469 SetupDefaultTrees(gfx::Size(10, 10)); 1470 host_impl_.PinchGestureBegin(); 1471 float high_res_scale = 2.3f; 1472 SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, false); 1473 1474 ASSERT_GE(pending_layer_->num_tilings(), 0u); 1475 EXPECT_FLOAT_EQ(high_res_scale, 1476 pending_layer_->HighResTiling()->contents_scale()); 1477} 1478 1479TEST_F(PictureLayerImplTest, FirstTilingTooSmall) { 1480 SetupDefaultTrees(gfx::Size(10, 10)); 1481 host_impl_.PinchGestureBegin(); 1482 float high_res_scale = 0.0001f; 1483 EXPECT_GT(pending_layer_->MinimumContentsScale(), high_res_scale); 1484 1485 SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, false); 1486 1487 ASSERT_GE(pending_layer_->num_tilings(), 0u); 1488 EXPECT_FLOAT_EQ(pending_layer_->MinimumContentsScale(), 1489 pending_layer_->HighResTiling()->contents_scale()); 1490} 1491 1492TEST_F(PictureLayerImplTest, PinchingTooSmall) { 1493 SetupDefaultTrees(gfx::Size(10, 10)); 1494 1495 float contents_scale = 0.15f; 1496 SetContentsScaleOnBothLayers(contents_scale, 1.f, 1.f, false); 1497 1498 ASSERT_GE(pending_layer_->num_tilings(), 0u); 1499 EXPECT_FLOAT_EQ(contents_scale, 1500 pending_layer_->HighResTiling()->contents_scale()); 1501 1502 host_impl_.PinchGestureBegin(); 1503 1504 float page_scale = 0.0001f; 1505 EXPECT_LT(page_scale * contents_scale, 1506 pending_layer_->MinimumContentsScale()); 1507 1508 1509 SetContentsScaleOnBothLayers(contents_scale, 1.f, page_scale, false); 1510 ASSERT_GE(pending_layer_->num_tilings(), 0u); 1511 EXPECT_FLOAT_EQ(pending_layer_->MinimumContentsScale(), 1512 pending_layer_->HighResTiling()->contents_scale()); 1513} 1514 1515class DeferredInitPictureLayerImplTest : public PictureLayerImplTest { 1516 public: 1517 DeferredInitPictureLayerImplTest() 1518 : PictureLayerImplTest(ImplSidePaintingSettings()) {} 1519 1520 virtual void InitializeRenderer() OVERRIDE { 1521 host_impl_.InitializeRenderer(FakeOutputSurface::CreateDeferredGL( 1522 scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice)) 1523 .PassAs<OutputSurface>()); 1524 } 1525 1526 virtual void SetUp() OVERRIDE { 1527 PictureLayerImplTest::SetUp(); 1528 1529 // Create some default active and pending trees. 1530 gfx::Size tile_size(100, 100); 1531 gfx::Size layer_bounds(400, 400); 1532 1533 scoped_refptr<FakePicturePileImpl> pending_pile = 1534 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1535 scoped_refptr<FakePicturePileImpl> active_pile = 1536 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); 1537 1538 SetupTrees(pending_pile, active_pile); 1539 } 1540}; 1541 1542// This test is really a LayerTreeHostImpl test, in that it makes sure 1543// that trees need update draw properties after deferred initialization. 1544// However, this is also a regression test for PictureLayerImpl in that 1545// not having this update will cause a crash. 1546TEST_F(DeferredInitPictureLayerImplTest, 1547 PreventUpdateTilePrioritiesDuringLostContext) { 1548 host_impl_.pending_tree()->UpdateDrawProperties(); 1549 host_impl_.active_tree()->UpdateDrawProperties(); 1550 EXPECT_FALSE(host_impl_.pending_tree()->needs_update_draw_properties()); 1551 EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties()); 1552 1553 FakeOutputSurface* fake_output_surface = 1554 static_cast<FakeOutputSurface*>(host_impl_.output_surface()); 1555 ASSERT_TRUE(fake_output_surface->InitializeAndSetContext3d( 1556 TestContextProvider::Create(), NULL)); 1557 1558 // These will crash PictureLayerImpl if this is not true. 1559 ASSERT_TRUE(host_impl_.pending_tree()->needs_update_draw_properties()); 1560 ASSERT_TRUE(host_impl_.active_tree()->needs_update_draw_properties()); 1561 host_impl_.active_tree()->UpdateDrawProperties(); 1562} 1563 1564} // namespace 1565} // namespace cc 1566