src/cc/resources/tile_manager_unittest.cc

   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/resources/eviction_tile_priority_queue.h"
   6 #include "cc/resources/raster_tile_priority_queue.h"
   7 #include "cc/resources/tile.h"
   8 #include "cc/resources/tile_priority.h"
   9 #include "cc/test/fake_impl_proxy.h"
  10 #include "cc/test/fake_layer_tree_host_impl.h"
  11 #include "cc/test/fake_output_surface.h"
  12 #include "cc/test/fake_output_surface_client.h"
  13 #include "cc/test/fake_picture_layer_impl.h"
  14 #include "cc/test/fake_picture_pile_impl.h"
  15 #include "cc/test/fake_tile_manager.h"
  16 #include "cc/test/impl_side_painting_settings.h"
  17 #include "cc/test/test_shared_bitmap_manager.h"
  18 #include "cc/test/test_tile_priorities.h"
  19 #include "cc/trees/layer_tree_impl.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 namespace cc {
  23 namespace {
  24
  25 class TileManagerTest : public testing::TestWithParam<bool>,
  26                         public TileManagerClient {
  27  public:
  28   typedef std::vector<scoped_refptr<Tile> > TileVector;
  29
  30   TileManagerTest()
  31       : memory_limit_policy_(ALLOW_ANYTHING),
  32         max_tiles_(0),
  33         ready_to_activate_(false) {}
  34
  35   void Initialize(int max_tiles,
  36                   TileMemoryLimitPolicy memory_limit_policy,
  37                   TreePriority tree_priority) {
  38     output_surface_ = FakeOutputSurface::Create3d();
  39     CHECK(output_surface_->BindToClient(&output_surface_client_));
  40
  41     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
  42     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
  43                                                   shared_bitmap_manager_.get(),
  44                                                   NULL,
  45                                                   0,
  46                                                   false,
  47                                                   1,
  48                                                   false);
  49     resource_pool_ = ResourcePool::Create(
  50         resource_provider_.get(), GL_TEXTURE_2D, RGBA_8888);
  51     tile_manager_ =
  52         make_scoped_ptr(new FakeTileManager(this, resource_pool_.get()));
  53
  54     memory_limit_policy_ = memory_limit_policy;
  55     max_tiles_ = max_tiles;
  56     picture_pile_ = FakePicturePileImpl::CreateInfiniteFilledPile();
  57
  58     SetTreePriority(tree_priority);
  59   }
  60
  61   void SetTreePriority(TreePriority tree_priority) {
  62     GlobalStateThatImpactsTilePriority state;
  63     gfx::Size tile_size = settings_.default_tile_size;
  64
  65     if (UsingMemoryLimit()) {
  66       state.soft_memory_limit_in_bytes =
  67           max_tiles_ * 4 * tile_size.width() * tile_size.height();
  68       state.num_resources_limit = 100;
  69     } else {
  70       state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
  71       state.num_resources_limit = max_tiles_;
  72     }
  73     state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
  74     state.memory_limit_policy = memory_limit_policy_;
  75     state.tree_priority = tree_priority;
  76
  77     global_state_ = state;
  78     resource_pool_->SetResourceUsageLimits(state.soft_memory_limit_in_bytes,
  79                                            state.soft_memory_limit_in_bytes,
  80                                            state.num_resources_limit);
  81     tile_manager_->SetGlobalStateForTesting(state);
  82   }
  83
  84   virtual void TearDown() OVERRIDE {
  85     tile_manager_.reset(NULL);
  86     picture_pile_ = NULL;
  87
  88     testing::Test::TearDown();
  89   }
  90
  91   // TileManagerClient implementation.
  92   virtual const std::vector<PictureLayerImpl*>& GetPictureLayers()
  93       const OVERRIDE {
  94     return picture_layers_;
  95   }
  96   virtual void NotifyReadyToActivate() OVERRIDE { ready_to_activate_ = true; }
  97   virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE {}
  98   virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
  99                                 TreePriority priority) OVERRIDE {}
 100   virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
 101                                   TreePriority priority) OVERRIDE {}
 102
 103   TileVector CreateTilesWithSize(int count,
 104                                  TilePriority active_priority,
 105                                  TilePriority pending_priority,
 106                                  const gfx::Size& tile_size) {
 107     TileVector tiles;
 108     for (int i = 0; i < count; ++i) {
 109       scoped_refptr<Tile> tile = tile_manager_->CreateTile(picture_pile_.get(),
 110                                                            tile_size,
 111                                                            gfx::Rect(),
 112                                                            1.0,
 113                                                            0,
 114                                                            0,
 115                                                            0);
 116       tile->SetPriority(ACTIVE_TREE, active_priority);
 117       tile->SetPriority(PENDING_TREE, pending_priority);
 118       tiles.push_back(tile);
 119     }
 120     return tiles;
 121   }
 122
 123   TileVector CreateTiles(int count,
 124                          TilePriority active_priority,
 125                          TilePriority pending_priority) {
 126     return CreateTilesWithSize(
 127         count, active_priority, pending_priority, settings_.default_tile_size);
 128   }
 129
 130   void ReleaseTiles(TileVector* tiles) {
 131     for (TileVector::iterator it = tiles->begin(); it != tiles->end(); it++) {
 132       Tile* tile = it->get();
 133       tile->SetPriority(ACTIVE_TREE, TilePriority());
 134       tile->SetPriority(PENDING_TREE, TilePriority());
 135     }
 136   }
 137
 138   FakeTileManager* tile_manager() { return tile_manager_.get(); }
 139
 140   int AssignedMemoryCount(const TileVector& tiles) {
 141     int has_memory_count = 0;
 142     for (TileVector::const_iterator it = tiles.begin(); it != tiles.end();
 143          ++it) {
 144       if (tile_manager_->HasBeenAssignedMemory(it->get()))
 145         ++has_memory_count;
 146     }
 147     return has_memory_count;
 148   }
 149
 150   bool ready_to_activate() const { return ready_to_activate_; }
 151
 152   // The parametrization specifies whether the max tile limit should
 153   // be applied to memory or resources.
 154   bool UsingResourceLimit() { return !GetParam(); }
 155   bool UsingMemoryLimit() { return GetParam(); }
 156
 157  protected:
 158   GlobalStateThatImpactsTilePriority global_state_;
 159
 160  private:
 161   LayerTreeSettings settings_;
 162   scoped_ptr<FakeTileManager> tile_manager_;
 163   scoped_refptr<FakePicturePileImpl> picture_pile_;
 164   FakeOutputSurfaceClient output_surface_client_;
 165   scoped_ptr<FakeOutputSurface> output_surface_;
 166   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
 167   scoped_ptr<ResourceProvider> resource_provider_;
 168   scoped_ptr<ResourcePool> resource_pool_;
 169   TileMemoryLimitPolicy memory_limit_policy_;
 170   int max_tiles_;
 171   bool ready_to_activate_;
 172   std::vector<PictureLayerImpl*> picture_layers_;
 173 };
 174
 175 TEST_P(TileManagerTest, EnoughMemoryAllowAnything) {
 176   // A few tiles of each type of priority, with enough memory for all tiles.
 177
 178   Initialize(10, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
 179   TileVector active_now =
 180       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
 181   TileVector pending_now =
 182       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
 183   TileVector active_pending_soon =
 184       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
 185   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 186
 187   tile_manager()->AssignMemoryToTiles(global_state_);
 188
 189   EXPECT_EQ(3, AssignedMemoryCount(active_now));
 190   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
 191   EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
 192   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
 193
 194   ReleaseTiles(&active_now);
 195   ReleaseTiles(&pending_now);
 196   ReleaseTiles(&active_pending_soon);
 197   ReleaseTiles(&never_bin);
 198 }
 199
 200 TEST_P(TileManagerTest, EnoughMemoryAllowPrepaintOnly) {
 201   // A few tiles of each type of priority, with enough memory for all tiles,
 202   // with the exception of never bin.
 203
 204   Initialize(10, ALLOW_PREPAINT_ONLY, SMOOTHNESS_TAKES_PRIORITY);
 205   TileVector active_now =
 206       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
 207   TileVector pending_now =
 208       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
 209   TileVector active_pending_soon =
 210       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
 211   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 212
 213   tile_manager()->AssignMemoryToTiles(global_state_);
 214
 215   EXPECT_EQ(3, AssignedMemoryCount(active_now));
 216   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
 217   EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
 218   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
 219
 220   ReleaseTiles(&active_now);
 221   ReleaseTiles(&pending_now);
 222   ReleaseTiles(&active_pending_soon);
 223   ReleaseTiles(&never_bin);
 224 }
 225
 226 TEST_P(TileManagerTest, EnoughMemoryPendingLowResAllowAbsoluteMinimum) {
 227   // A few low-res tiles required for activation, with enough memory for all
 228   // tiles.
 229
 230   Initialize(5, ALLOW_ABSOLUTE_MINIMUM, SAME_PRIORITY_FOR_BOTH_TREES);
 231   TileVector pending_low_res =
 232       CreateTiles(5, TilePriority(), TilePriorityLowRes());
 233
 234   tile_manager()->AssignMemoryToTiles(global_state_);
 235
 236   EXPECT_EQ(5, AssignedMemoryCount(pending_low_res));
 237   ReleaseTiles(&pending_low_res);
 238 }
 239
 240 TEST_P(TileManagerTest, EnoughMemoryAllowAbsoluteMinimum) {
 241   // A few tiles of each type of priority, with enough memory for all tiles,
 242   // with the exception of never and soon bins.
 243
 244   Initialize(10, ALLOW_ABSOLUTE_MINIMUM, SMOOTHNESS_TAKES_PRIORITY);
 245   TileVector active_now =
 246       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
 247   TileVector pending_now =
 248       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
 249   TileVector active_pending_soon =
 250       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
 251   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 252
 253   tile_manager()->AssignMemoryToTiles(global_state_);
 254
 255   EXPECT_EQ(3, AssignedMemoryCount(active_now));
 256   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
 257   EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
 258   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
 259
 260   ReleaseTiles(&active_now);
 261   ReleaseTiles(&pending_now);
 262   ReleaseTiles(&active_pending_soon);
 263   ReleaseTiles(&never_bin);
 264 }
 265
 266 TEST_P(TileManagerTest, EnoughMemoryAllowNothing) {
 267   // A few tiles of each type of priority, with enough memory for all tiles,
 268   // but allow nothing should not assign any memory.
 269
 270   Initialize(10, ALLOW_NOTHING, SMOOTHNESS_TAKES_PRIORITY);
 271   TileVector active_now =
 272       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
 273   TileVector pending_now =
 274       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
 275   TileVector active_pending_soon =
 276       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
 277   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 278
 279   tile_manager()->AssignMemoryToTiles(global_state_);
 280
 281   EXPECT_EQ(0, AssignedMemoryCount(active_now));
 282   EXPECT_EQ(0, AssignedMemoryCount(pending_now));
 283   EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
 284   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
 285
 286   ReleaseTiles(&active_now);
 287   ReleaseTiles(&pending_now);
 288   ReleaseTiles(&active_pending_soon);
 289   ReleaseTiles(&never_bin);
 290 }
 291
 292 TEST_P(TileManagerTest, PartialOOMMemoryToPending) {
 293   // 5 tiles on active tree eventually bin, 5 tiles on pending tree that are
 294   // required for activation, but only enough memory for 8 tiles. The result
 295   // is all pending tree tiles get memory, and 3 of the active tree tiles
 296   // get memory. None of these tiles is needed to avoid calimity (flickering or
 297   // raster-on-demand) so the soft memory limit is used.
 298
 299   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
 300   TileVector active_tree_tiles =
 301       CreateTiles(5, TilePriorityForEventualBin(), TilePriority());
 302   TileVector pending_tree_tiles =
 303       CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
 304   tile_manager()->AssignMemoryToTiles(global_state_);
 305
 306   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
 307   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
 308
 309   SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
 310   tile_manager()->AssignMemoryToTiles(global_state_);
 311
 312   EXPECT_EQ(3, AssignedMemoryCount(active_tree_tiles));
 313   EXPECT_EQ(5, AssignedMemoryCount(pending_tree_tiles));
 314
 315   ReleaseTiles(&active_tree_tiles);
 316   ReleaseTiles(&pending_tree_tiles);
 317 }
 318
 319 TEST_P(TileManagerTest, PartialOOMMemoryToActive) {
 320   // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin,
 321   // but only enough memory for 8 tiles. The result is all active tree tiles
 322   // get memory, and 3 of the pending tree tiles get memory.
 323   // The pending tiles are not needed to avoid calimity (flickering or
 324   // raster-on-demand) and the active tiles fit, so the soft limit is used.
 325
 326   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
 327   TileVector active_tree_tiles =
 328       CreateTiles(5, TilePriorityForNowBin(), TilePriority());
 329   TileVector pending_tree_tiles =
 330       CreateTiles(5, TilePriority(), TilePriorityForNowBin());
 331
 332   tile_manager()->AssignMemoryToTiles(global_state_);
 333
 334   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
 335   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
 336
 337   ReleaseTiles(&active_tree_tiles);
 338   ReleaseTiles(&pending_tree_tiles);
 339 }
 340
 341 TEST_P(TileManagerTest, TotalOOMMemoryToPending) {
 342   // 10 tiles on active tree eventually bin, 10 tiles on pending tree that are
 343   // required for activation, but only enough tiles for 4 tiles. The result
 344   // is 4 pending tree tiles get memory, and none of the active tree tiles
 345   // get memory.
 346
 347   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
 348   TileVector active_tree_tiles =
 349       CreateTiles(10, TilePriorityForEventualBin(), TilePriority());
 350   TileVector pending_tree_tiles =
 351       CreateTiles(10, TilePriority(), TilePriorityRequiredForActivation());
 352
 353   tile_manager()->AssignMemoryToTiles(global_state_);
 354
 355   EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
 356   EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
 357
 358   SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
 359   tile_manager()->AssignMemoryToTiles(global_state_);
 360
 361   if (UsingResourceLimit()) {
 362     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
 363     EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
 364   } else {
 365     // Pending tiles are now required to avoid calimity (flickering or
 366     // raster-on-demand). Hard-limit is used and double the tiles fit.
 367     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
 368     EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
 369   }
 370
 371   ReleaseTiles(&active_tree_tiles);
 372   ReleaseTiles(&pending_tree_tiles);
 373 }
 374
 375 TEST_P(TileManagerTest, TotalOOMActiveSoonMemoryToPending) {
 376   // 10 tiles on active tree soon bin, 10 tiles on pending tree that are
 377   // required for activation, but only enough tiles for 4 tiles. The result
 378   // is 4 pending tree tiles get memory, and none of the active tree tiles
 379   // get memory.
 380
 381   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
 382   TileVector active_tree_tiles =
 383       CreateTiles(10, TilePriorityForSoonBin(), TilePriority());
 384   TileVector pending_tree_tiles =
 385       CreateTiles(10, TilePriority(), TilePriorityRequiredForActivation());
 386
 387   tile_manager()->AssignMemoryToTiles(global_state_);
 388
 389   EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
 390   EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
 391
 392   SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
 393   tile_manager()->AssignMemoryToTiles(global_state_);
 394
 395   if (UsingResourceLimit()) {
 396     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
 397     EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
 398   } else {
 399     // Pending tiles are now required to avoid calimity (flickering or
 400     // raster-on-demand). Hard-limit is used and double the tiles fit.
 401     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
 402     EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
 403   }
 404
 405   ReleaseTiles(&active_tree_tiles);
 406   ReleaseTiles(&pending_tree_tiles);
 407 }
 408
 409 TEST_P(TileManagerTest, TotalOOMMemoryToActive) {
 410   // 10 tiles on active tree eventually bin, 10 tiles on pending tree now bin,
 411   // but only enough memory for 4 tiles. The result is 4 active tree tiles
 412   // get memory, and none of the pending tree tiles get memory.
 413
 414   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
 415   TileVector active_tree_tiles =
 416       CreateTiles(10, TilePriorityForNowBin(), TilePriority());
 417   TileVector pending_tree_tiles =
 418       CreateTiles(10, TilePriority(), TilePriorityForNowBin());
 419
 420   tile_manager()->AssignMemoryToTiles(global_state_);
 421
 422   if (UsingResourceLimit()) {
 423     EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
 424     EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
 425   } else {
 426     // Active tiles are required to avoid calimity (flickering or
 427     // raster-on-demand). Hard-limit is used and double the tiles fit.
 428     EXPECT_EQ(8, AssignedMemoryCount(active_tree_tiles));
 429     EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
 430   }
 431
 432   ReleaseTiles(&active_tree_tiles);
 433   ReleaseTiles(&pending_tree_tiles);
 434 }
 435
 436 TEST_P(TileManagerTest, TotalOOMMemoryToNewContent) {
 437   // 10 tiles on active tree now bin, 10 tiles on pending tree now bin,
 438   // but only enough memory for 8 tiles. Any tile missing would cause
 439   // a calamity (flickering or raster-on-demand). Depending on mode,
 440   // we should use varying amounts of the higher hard memory limit.
 441   if (UsingResourceLimit())
 442     return;
 443
 444   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
 445   TileVector active_tree_tiles =
 446       CreateTiles(10, TilePriorityForNowBin(), TilePriority());
 447   TileVector pending_tree_tiles =
 448       CreateTiles(10, TilePriority(), TilePriorityForNowBin());
 449
 450   // Active tiles are required to avoid calimity. The hard-limit is used and all
 451   // active-tiles fit. No pending tiles are needed to avoid calamity so only 10
 452   // tiles total are used.
 453   tile_manager()->AssignMemoryToTiles(global_state_);
 454   EXPECT_EQ(10, AssignedMemoryCount(active_tree_tiles));
 455   EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
 456
 457   // Even the hard-limit won't save us now. All tiles are required to avoid
 458   // a clamity but we only have 16. The tiles will be distribted randomly
 459   // given they are identical, in practice depending on their screen location.
 460   SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
 461   tile_manager()->AssignMemoryToTiles(global_state_);
 462   EXPECT_EQ(16,
 463             AssignedMemoryCount(active_tree_tiles) +
 464                 AssignedMemoryCount(pending_tree_tiles));
 465
 466   // The pending tree is now more important. Active tiles will take higher
 467   // priority if they are ready-to-draw in practice. Importantly though,
 468   // pending tiles also utilize the hard-limit.
 469   SetTreePriority(NEW_CONTENT_TAKES_PRIORITY);
 470   tile_manager()->AssignMemoryToTiles(global_state_);
 471   EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
 472   EXPECT_EQ(10, AssignedMemoryCount(pending_tree_tiles));
 473
 474   ReleaseTiles(&active_tree_tiles);
 475   ReleaseTiles(&pending_tree_tiles);
 476 }
 477
 478 // If true, the max tile limit should be applied as bytes; if false,
 479 // as num_resources_limit.
 480 INSTANTIATE_TEST_CASE_P(TileManagerTests,
 481                         TileManagerTest,
 482                         ::testing::Values(true, false));
 483
 484 class LowResTilingsSettings : public ImplSidePaintingSettings {
 485  public:
 486   LowResTilingsSettings() { create_low_res_tiling = true; }
 487 };
 488
 489 class TileManagerTilePriorityQueueTest : public testing::Test {
 490  public:
 491   TileManagerTilePriorityQueueTest()
 492       : memory_limit_policy_(ALLOW_ANYTHING),
 493         max_tiles_(10000),
 494         ready_to_activate_(false),
 495         id_(7),
 496         proxy_(base::MessageLoopProxy::current()),
 497         host_impl_(LowResTilingsSettings(), &proxy_, &shared_bitmap_manager_) {}
 498
 499   void SetTreePriority(TreePriority tree_priority) {
 500     GlobalStateThatImpactsTilePriority state;
 501     gfx::Size tile_size(256, 256);
 502
 503     state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
 504     state.num_resources_limit = max_tiles_;
 505     state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
 506     state.memory_limit_policy = memory_limit_policy_;
 507     state.tree_priority = tree_priority;
 508
 509     global_state_ = state;
 510     host_impl_.resource_pool()->SetResourceUsageLimits(
 511         state.soft_memory_limit_in_bytes,
 512         state.soft_memory_limit_in_bytes,
 513         state.num_resources_limit);
 514     host_impl_.tile_manager()->SetGlobalStateForTesting(state);
 515   }
 516
 517   virtual void SetUp() OVERRIDE {
 518     InitializeRenderer();
 519     SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
 520   }
 521
 522   virtual void InitializeRenderer() {
 523     host_impl_.InitializeRenderer(
 524         FakeOutputSurface::Create3d().PassAs<OutputSurface>());
 525   }
 526
 527   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
 528     gfx::Size tile_size(100, 100);
 529
 530     scoped_refptr<FakePicturePileImpl> pending_pile =
 531         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 532     scoped_refptr<FakePicturePileImpl> active_pile =
 533         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 534
 535     SetupTrees(pending_pile, active_pile);
 536   }
 537
 538   void ActivateTree() {
 539     host_impl_.ActivateSyncTree();
 540     CHECK(!host_impl_.pending_tree());
 541     pending_layer_ = NULL;
 542     active_layer_ = static_cast<FakePictureLayerImpl*>(
 543         host_impl_.active_tree()->LayerById(id_));
 544   }
 545
 546   void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
 547                                           const gfx::Size& tile_size) {
 548     SetupDefaultTrees(layer_bounds);
 549     pending_layer_->set_fixed_tile_size(tile_size);
 550     active_layer_->set_fixed_tile_size(tile_size);
 551   }
 552
 553   void SetupTrees(scoped_refptr<PicturePileImpl> pending_pile,
 554                   scoped_refptr<PicturePileImpl> active_pile) {
 555     SetupPendingTree(active_pile);
 556     ActivateTree();
 557     SetupPendingTree(pending_pile);
 558   }
 559
 560   void SetupPendingTree(scoped_refptr<PicturePileImpl> pile) {
 561     host_impl_.CreatePendingTree();
 562     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 563     // Clear recycled tree.
 564     pending_tree->DetachLayerTree();
 565
 566     scoped_ptr<FakePictureLayerImpl> pending_layer =
 567         FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
 568     pending_layer->SetDrawsContent(true);
 569     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 570
 571     pending_layer_ = static_cast<FakePictureLayerImpl*>(
 572         host_impl_.pending_tree()->LayerById(id_));
 573     pending_layer_->DoPostCommitInitializationIfNeeded();
 574   }
 575
 576   void CreateHighLowResAndSetAllTilesVisible() {
 577     // Active layer must get updated first so pending layer can share from it.
 578     active_layer_->CreateDefaultTilingsAndTiles();
 579     active_layer_->SetAllTilesVisible();
 580     pending_layer_->CreateDefaultTilingsAndTiles();
 581     pending_layer_->SetAllTilesVisible();
 582   }
 583
 584   TileManager* tile_manager() { return host_impl_.tile_manager(); }
 585
 586  protected:
 587   GlobalStateThatImpactsTilePriority global_state_;
 588
 589   TestSharedBitmapManager shared_bitmap_manager_;
 590   TileMemoryLimitPolicy memory_limit_policy_;
 591   int max_tiles_;
 592   bool ready_to_activate_;
 593   int id_;
 594   FakeImplProxy proxy_;
 595   FakeLayerTreeHostImpl host_impl_;
 596   FakePictureLayerImpl* pending_layer_;
 597   FakePictureLayerImpl* active_layer_;
 598 };
 599
 600 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
 601   SetupDefaultTrees(gfx::Size(1000, 1000));
 602
 603   active_layer_->CreateDefaultTilingsAndTiles();
 604   pending_layer_->CreateDefaultTilingsAndTiles();
 605
 606   RasterTilePriorityQueue queue;
 607   host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
 608   EXPECT_FALSE(queue.IsEmpty());
 609
 610   size_t tile_count = 0;
 611   std::set<Tile*> all_tiles;
 612   while (!queue.IsEmpty()) {
 613     EXPECT_TRUE(queue.Top());
 614     all_tiles.insert(queue.Top());
 615     ++tile_count;
 616     queue.Pop();
 617   }
 618
 619   EXPECT_EQ(tile_count, all_tiles.size());
 620   EXPECT_EQ(17u, tile_count);
 621
 622   // Sanity check, all tiles should be visible.
 623   std::set<Tile*> smoothness_tiles;
 624   queue.Reset();
 625   host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
 626   while (!queue.IsEmpty()) {
 627     Tile* tile = queue.Top();
 628     EXPECT_TRUE(tile);
 629     EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
 630     EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
 631     smoothness_tiles.insert(tile);
 632     queue.Pop();
 633   }
 634   EXPECT_EQ(all_tiles, smoothness_tiles);
 635
 636   Region invalidation(gfx::Rect(0, 0, 500, 500));
 637
 638   // Invalidate the pending tree.
 639   pending_layer_->set_invalidation(invalidation);
 640   pending_layer_->HighResTiling()->UpdateTilesToCurrentPile(
 641       invalidation, gfx::Size(1000, 1000));
 642   pending_layer_->LowResTiling()->UpdateTilesToCurrentPile(
 643       invalidation, gfx::Size(1000, 1000));
 644
 645   active_layer_->ResetAllTilesPriorities();
 646   pending_layer_->ResetAllTilesPriorities();
 647
 648   // Renew all of the tile priorities.
 649   gfx::Rect viewport(50, 50, 100, 100);
 650   pending_layer_->HighResTiling()->UpdateTilePriorities(
 651       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
 652   pending_layer_->LowResTiling()->UpdateTilePriorities(
 653       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
 654   active_layer_->HighResTiling()->UpdateTilePriorities(
 655       ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
 656   active_layer_->LowResTiling()->UpdateTilePriorities(
 657       ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
 658
 659   // Populate all tiles directly from the tilings.
 660   all_tiles.clear();
 661   std::vector<Tile*> pending_high_res_tiles =
 662       pending_layer_->HighResTiling()->AllTilesForTesting();
 663   for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
 664     all_tiles.insert(pending_high_res_tiles[i]);
 665
 666   std::vector<Tile*> pending_low_res_tiles =
 667       pending_layer_->LowResTiling()->AllTilesForTesting();
 668   for (size_t i = 0; i < pending_low_res_tiles.size(); ++i)
 669     all_tiles.insert(pending_low_res_tiles[i]);
 670
 671   std::vector<Tile*> active_high_res_tiles =
 672       active_layer_->HighResTiling()->AllTilesForTesting();
 673   for (size_t i = 0; i < active_high_res_tiles.size(); ++i)
 674     all_tiles.insert(active_high_res_tiles[i]);
 675
 676   std::vector<Tile*> active_low_res_tiles =
 677       active_layer_->LowResTiling()->AllTilesForTesting();
 678   for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
 679     all_tiles.insert(active_low_res_tiles[i]);
 680
 681   Tile* last_tile = NULL;
 682   smoothness_tiles.clear();
 683   tile_count = 0;
 684   size_t increasing_distance_tiles = 0u;
 685   // Here we expect to get increasing ACTIVE_TREE priority_bin.
 686   queue.Reset();
 687   host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
 688   while (!queue.IsEmpty()) {
 689     Tile* tile = queue.Top();
 690     EXPECT_TRUE(tile);
 691
 692     if (!last_tile)
 693       last_tile = tile;
 694
 695     EXPECT_LE(last_tile->priority(ACTIVE_TREE).priority_bin,
 696               tile->priority(ACTIVE_TREE).priority_bin);
 697     if (last_tile->priority(ACTIVE_TREE).priority_bin ==
 698         tile->priority(ACTIVE_TREE).priority_bin) {
 699       increasing_distance_tiles +=
 700           last_tile->priority(ACTIVE_TREE).distance_to_visible <=
 701           tile->priority(ACTIVE_TREE).distance_to_visible;
 702     }
 703
 704     if (tile->priority(ACTIVE_TREE).priority_bin == TilePriority::NOW &&
 705         last_tile->priority(ACTIVE_TREE).resolution !=
 706             tile->priority(ACTIVE_TREE).resolution) {
 707       // Low resolution should come first.
 708       EXPECT_EQ(LOW_RESOLUTION, last_tile->priority(ACTIVE_TREE).resolution);
 709     }
 710
 711     last_tile = tile;
 712     ++tile_count;
 713     smoothness_tiles.insert(tile);
 714     queue.Pop();
 715   }
 716
 717   EXPECT_EQ(tile_count, smoothness_tiles.size());
 718   EXPECT_EQ(all_tiles, smoothness_tiles);
 719   // Since we don't guarantee increasing distance due to spiral iterator, we
 720   // should check that we're _mostly_ right.
 721   EXPECT_GT(increasing_distance_tiles, 3 * tile_count / 4);
 722
 723   std::set<Tile*> new_content_tiles;
 724   last_tile = NULL;
 725   increasing_distance_tiles = 0u;
 726   // Here we expect to get increasing PENDING_TREE priority_bin.
 727   queue.Reset();
 728   host_impl_.BuildRasterQueue(&queue, NEW_CONTENT_TAKES_PRIORITY);
 729   while (!queue.IsEmpty()) {
 730     Tile* tile = queue.Top();
 731     EXPECT_TRUE(tile);
 732
 733     if (!last_tile)
 734       last_tile = tile;
 735
 736     EXPECT_LE(last_tile->priority(PENDING_TREE).priority_bin,
 737               tile->priority(PENDING_TREE).priority_bin);
 738     if (last_tile->priority(PENDING_TREE).priority_bin ==
 739         tile->priority(PENDING_TREE).priority_bin) {
 740       increasing_distance_tiles +=
 741           last_tile->priority(PENDING_TREE).distance_to_visible <=
 742           tile->priority(PENDING_TREE).distance_to_visible;
 743     }
 744
 745     if (tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW &&
 746         last_tile->priority(PENDING_TREE).resolution !=
 747             tile->priority(PENDING_TREE).resolution) {
 748       // High resolution should come first.
 749       EXPECT_EQ(HIGH_RESOLUTION, last_tile->priority(PENDING_TREE).resolution);
 750     }
 751
 752     last_tile = tile;
 753     new_content_tiles.insert(tile);
 754     queue.Pop();
 755   }
 756
 757   EXPECT_EQ(tile_count, new_content_tiles.size());
 758   EXPECT_EQ(all_tiles, new_content_tiles);
 759   // Since we don't guarantee increasing distance due to spiral iterator, we
 760   // should check that we're _mostly_ right.
 761   EXPECT_GT(increasing_distance_tiles, 3 * tile_count / 4);
 762 }
 763
 764 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
 765   SetupDefaultTrees(gfx::Size(1000, 1000));
 766
 767   active_layer_->CreateDefaultTilingsAndTiles();
 768   pending_layer_->CreateDefaultTilingsAndTiles();
 769
 770   EvictionTilePriorityQueue empty_queue;
 771   host_impl_.BuildEvictionQueue(&empty_queue, SAME_PRIORITY_FOR_BOTH_TREES);
 772   EXPECT_TRUE(empty_queue.IsEmpty());
 773   std::set<Tile*> all_tiles;
 774   size_t tile_count = 0;
 775
 776   RasterTilePriorityQueue raster_queue;
 777   host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES);
 778   while (!raster_queue.IsEmpty()) {
 779     ++tile_count;
 780     EXPECT_TRUE(raster_queue.Top());
 781     all_tiles.insert(raster_queue.Top());
 782     raster_queue.Pop();
 783   }
 784
 785   EXPECT_EQ(tile_count, all_tiles.size());
 786   EXPECT_EQ(17u, tile_count);
 787
 788   tile_manager()->InitializeTilesWithResourcesForTesting(
 789       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 790
 791   EvictionTilePriorityQueue queue;
 792   host_impl_.BuildEvictionQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
 793   EXPECT_FALSE(queue.IsEmpty());
 794
 795   // Sanity check, all tiles should be visible.
 796   std::set<Tile*> smoothness_tiles;
 797   while (!queue.IsEmpty()) {
 798     Tile* tile = queue.Top();
 799     EXPECT_TRUE(tile);
 800     EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
 801     EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
 802     EXPECT_TRUE(tile->HasResources());
 803     smoothness_tiles.insert(tile);
 804     queue.Pop();
 805   }
 806   EXPECT_EQ(all_tiles, smoothness_tiles);
 807
 808   tile_manager()->ReleaseTileResourcesForTesting(
 809       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 810
 811   Region invalidation(gfx::Rect(0, 0, 500, 500));
 812
 813   // Invalidate the pending tree.
 814   pending_layer_->set_invalidation(invalidation);
 815   pending_layer_->HighResTiling()->UpdateTilesToCurrentPile(
 816       invalidation, gfx::Size(1000, 1000));
 817   pending_layer_->LowResTiling()->UpdateTilesToCurrentPile(
 818       invalidation, gfx::Size(1000, 1000));
 819
 820   active_layer_->ResetAllTilesPriorities();
 821   pending_layer_->ResetAllTilesPriorities();
 822
 823   // Renew all of the tile priorities.
 824   gfx::Rect viewport(50, 50, 100, 100);
 825   pending_layer_->HighResTiling()->UpdateTilePriorities(
 826       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
 827   pending_layer_->LowResTiling()->UpdateTilePriorities(
 828       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
 829   active_layer_->HighResTiling()->UpdateTilePriorities(
 830       ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
 831   active_layer_->LowResTiling()->UpdateTilePriorities(
 832       ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
 833
 834   // Populate all tiles directly from the tilings.
 835   all_tiles.clear();
 836   std::vector<Tile*> pending_high_res_tiles =
 837       pending_layer_->HighResTiling()->AllTilesForTesting();
 838   for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
 839     all_tiles.insert(pending_high_res_tiles[i]);
 840
 841   std::vector<Tile*> pending_low_res_tiles =
 842       pending_layer_->LowResTiling()->AllTilesForTesting();
 843   for (size_t i = 0; i < pending_low_res_tiles.size(); ++i)
 844     all_tiles.insert(pending_low_res_tiles[i]);
 845
 846   std::vector<Tile*> active_high_res_tiles =
 847       active_layer_->HighResTiling()->AllTilesForTesting();
 848   for (size_t i = 0; i < active_high_res_tiles.size(); ++i)
 849     all_tiles.insert(active_high_res_tiles[i]);
 850
 851   std::vector<Tile*> active_low_res_tiles =
 852       active_layer_->LowResTiling()->AllTilesForTesting();
 853   for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
 854     all_tiles.insert(active_low_res_tiles[i]);
 855
 856   tile_manager()->InitializeTilesWithResourcesForTesting(
 857       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 858
 859   pending_layer_->MarkVisibleResourcesAsRequired();
 860
 861   Tile* last_tile = NULL;
 862   smoothness_tiles.clear();
 863   tile_count = 0;
 864   // Here we expect to get increasing ACTIVE_TREE priority_bin.
 865   queue.Reset();
 866   host_impl_.BuildEvictionQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
 867   while (!queue.IsEmpty()) {
 868     Tile* tile = queue.Top();
 869     EXPECT_TRUE(tile);
 870     EXPECT_TRUE(tile->HasResources());
 871
 872     if (!last_tile)
 873       last_tile = tile;
 874
 875     EXPECT_GE(last_tile->priority(ACTIVE_TREE).priority_bin,
 876               tile->priority(ACTIVE_TREE).priority_bin);
 877     if (last_tile->priority(ACTIVE_TREE).priority_bin ==
 878         tile->priority(ACTIVE_TREE).priority_bin) {
 879       EXPECT_LE(last_tile->required_for_activation(),
 880                 tile->required_for_activation());
 881       if (last_tile->required_for_activation() ==
 882           tile->required_for_activation()) {
 883         EXPECT_GE(last_tile->priority(ACTIVE_TREE).distance_to_visible,
 884                   tile->priority(ACTIVE_TREE).distance_to_visible);
 885       }
 886     }
 887
 888     last_tile = tile;
 889     ++tile_count;
 890     smoothness_tiles.insert(tile);
 891     queue.Pop();
 892   }
 893
 894   EXPECT_EQ(tile_count, smoothness_tiles.size());
 895   EXPECT_EQ(all_tiles, smoothness_tiles);
 896
 897   std::set<Tile*> new_content_tiles;
 898   last_tile = NULL;
 899   // Here we expect to get increasing PENDING_TREE priority_bin.
 900   queue.Reset();
 901   host_impl_.BuildEvictionQueue(&queue, NEW_CONTENT_TAKES_PRIORITY);
 902   while (!queue.IsEmpty()) {
 903     Tile* tile = queue.Top();
 904     EXPECT_TRUE(tile);
 905
 906     if (!last_tile)
 907       last_tile = tile;
 908
 909     EXPECT_GE(last_tile->priority(PENDING_TREE).priority_bin,
 910               tile->priority(PENDING_TREE).priority_bin);
 911     if (last_tile->priority(PENDING_TREE).priority_bin ==
 912         tile->priority(PENDING_TREE).priority_bin) {
 913       EXPECT_LE(last_tile->required_for_activation(),
 914                 tile->required_for_activation());
 915       if (last_tile->required_for_activation() ==
 916           tile->required_for_activation()) {
 917         EXPECT_GE(last_tile->priority(PENDING_TREE).distance_to_visible,
 918                   tile->priority(PENDING_TREE).distance_to_visible);
 919       }
 920     }
 921
 922     last_tile = tile;
 923     new_content_tiles.insert(tile);
 924     queue.Pop();
 925   }
 926
 927   EXPECT_EQ(tile_count, new_content_tiles.size());
 928   EXPECT_EQ(all_tiles, new_content_tiles);
 929 }
 930
 931 TEST_F(TileManagerTilePriorityQueueTest,
 932        EvictionTilePriorityQueueWithOcclusion) {
 933   gfx::Size tile_size(102, 102);
 934   gfx::Size layer_bounds(1000, 1000);
 935
 936   scoped_refptr<FakePicturePileImpl> pending_pile =
 937       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 938   SetupPendingTree(pending_pile);
 939   pending_layer_->CreateDefaultTilingsAndTiles();
 940
 941   scoped_ptr<FakePictureLayerImpl> pending_child =
 942       FakePictureLayerImpl::CreateWithPile(
 943           host_impl_.pending_tree(), 2, pending_pile);
 944   pending_layer_->AddChild(pending_child.PassAs<LayerImpl>());
 945
 946   FakePictureLayerImpl* pending_child_layer =
 947       static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
 948   pending_child_layer->SetDrawsContent(true);
 949   pending_child_layer->DoPostCommitInitializationIfNeeded();
 950   pending_child_layer->CreateDefaultTilingsAndTiles();
 951
 952   std::set<Tile*> all_tiles;
 953   size_t tile_count = 0;
 954   RasterTilePriorityQueue raster_queue;
 955   host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES);
 956   while (!raster_queue.IsEmpty()) {
 957     ++tile_count;
 958     EXPECT_TRUE(raster_queue.Top());
 959     all_tiles.insert(raster_queue.Top());
 960     raster_queue.Pop();
 961   }
 962   EXPECT_EQ(tile_count, all_tiles.size());
 963   EXPECT_EQ(34u, tile_count);
 964
 965   pending_layer_->ResetAllTilesPriorities();
 966
 967   // Renew all of the tile priorities.
 968   gfx::Rect viewport(layer_bounds);
 969   pending_layer_->HighResTiling()->UpdateTilePriorities(
 970       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
 971   pending_layer_->LowResTiling()->UpdateTilePriorities(
 972       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
 973   pending_child_layer->HighResTiling()->UpdateTilePriorities(
 974       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
 975   pending_child_layer->LowResTiling()->UpdateTilePriorities(
 976       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
 977
 978   // Populate all tiles directly from the tilings.
 979   all_tiles.clear();
 980   std::vector<Tile*> pending_high_res_tiles =
 981       pending_layer_->HighResTiling()->AllTilesForTesting();
 982   for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
 983     all_tiles.insert(pending_high_res_tiles[i]);
 984
 985   std::vector<Tile*> pending_low_res_tiles =
 986       pending_layer_->LowResTiling()->AllTilesForTesting();
 987   for (size_t i = 0; i < pending_low_res_tiles.size(); ++i)
 988     all_tiles.insert(pending_low_res_tiles[i]);
 989
 990   // Set all tiles on the pending_child_layer as occluded on the pending tree.
 991   std::vector<Tile*> pending_child_high_res_tiles =
 992       pending_child_layer->HighResTiling()->AllTilesForTesting();
 993   for (size_t i = 0; i < pending_child_high_res_tiles.size(); ++i) {
 994     pending_child_high_res_tiles[i]->set_is_occluded(PENDING_TREE, true);
 995     all_tiles.insert(pending_child_high_res_tiles[i]);
 996   }
 997
 998   std::vector<Tile*> pending_child_low_res_tiles =
 999       pending_child_layer->LowResTiling()->AllTilesForTesting();
1000   for (size_t i = 0; i < pending_child_low_res_tiles.size(); ++i) {
1001     pending_child_low_res_tiles[i]->set_is_occluded(PENDING_TREE, true);
1002     all_tiles.insert(pending_child_low_res_tiles[i]);
1003   }
1004
1005   tile_manager()->InitializeTilesWithResourcesForTesting(
1006       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
1007
1008   // Verify occlusion is considered by EvictionTilePriorityQueue.
1009   TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
1010   size_t occluded_count = 0u;
1011   Tile* last_tile = NULL;
1012   EvictionTilePriorityQueue queue;
1013   host_impl_.BuildEvictionQueue(&queue, tree_priority);
1014   while (!queue.IsEmpty()) {
1015     Tile* tile = queue.Top();
1016     if (!last_tile)
1017       last_tile = tile;
1018
1019     bool tile_is_occluded = tile->is_occluded_for_tree_priority(tree_priority);
1020
1021     // The only way we will encounter an occluded tile after an unoccluded
1022     // tile is if the priorty bin decreased, the tile is required for
1023     // activation, or the scale changed.
1024     if (tile_is_occluded) {
1025       occluded_count++;
1026
1027       bool last_tile_is_occluded =
1028           last_tile->is_occluded_for_tree_priority(tree_priority);
1029       if (!last_tile_is_occluded) {
1030         TilePriority::PriorityBin tile_priority_bin =
1031             tile->priority_for_tree_priority(tree_priority).priority_bin;
1032         TilePriority::PriorityBin last_tile_priority_bin =
1033             last_tile->priority_for_tree_priority(tree_priority).priority_bin;
1034
1035         EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) ||
1036                     tile->required_for_activation() ||
1037                     (tile->contents_scale() != last_tile->contents_scale()));
1038       }
1039     }
1040     last_tile = tile;
1041     queue.Pop();
1042   }
1043   size_t expected_occluded_count =
1044       pending_child_high_res_tiles.size() + pending_child_low_res_tiles.size();
1045   EXPECT_EQ(expected_occluded_count, occluded_count);
1046 }
1047
1048 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
1049   SetupDefaultTrees(gfx::Size(1000, 1000));
1050
1051   active_layer_->CreateDefaultTilingsAndTiles();
1052   pending_layer_->CreateDefaultTilingsAndTiles();
1053
1054   RasterTilePriorityQueue queue;
1055   host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
1056   EXPECT_FALSE(queue.IsEmpty());
1057
1058   size_t tile_count = 0;
1059   std::set<Tile*> all_tiles;
1060   while (!queue.IsEmpty()) {
1061     EXPECT_TRUE(queue.Top());
1062     all_tiles.insert(queue.Top());
1063     ++tile_count;
1064     queue.Pop();
1065   }
1066
1067   EXPECT_EQ(tile_count, all_tiles.size());
1068   EXPECT_EQ(17u, tile_count);
1069
1070   queue.Reset();
1071   for (int i = 1; i < 10; ++i) {
1072     scoped_ptr<FakePictureLayerImpl> pending_layer =
1073         FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
1074     pending_layer->SetDrawsContent(true);
1075     pending_layer->DoPostCommitInitializationIfNeeded();
1076     pending_layer->set_has_valid_tile_priorities(true);
1077     pending_layer_->AddChild(pending_layer.PassAs<LayerImpl>());
1078   }
1079
1080   host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
1081   EXPECT_FALSE(queue.IsEmpty());
1082
1083   tile_count = 0;
1084   all_tiles.clear();
1085   while (!queue.IsEmpty()) {
1086     EXPECT_TRUE(queue.Top());
1087     all_tiles.insert(queue.Top());
1088     ++tile_count;
1089     queue.Pop();
1090   }
1091   EXPECT_EQ(tile_count, all_tiles.size());
1092   EXPECT_EQ(17u, tile_count);
1093 }
1094
1095 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
1096   SetupDefaultTrees(gfx::Size(1000, 1000));
1097
1098   active_layer_->CreateDefaultTilingsAndTiles();
1099   pending_layer_->CreateDefaultTilingsAndTiles();
1100
1101   RasterTilePriorityQueue raster_queue;
1102   host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES);
1103   EXPECT_FALSE(raster_queue.IsEmpty());
1104
1105   size_t tile_count = 0;
1106   std::set<Tile*> all_tiles;
1107   while (!raster_queue.IsEmpty()) {
1108     EXPECT_TRUE(raster_queue.Top());
1109     all_tiles.insert(raster_queue.Top());
1110     ++tile_count;
1111     raster_queue.Pop();
1112   }
1113   EXPECT_EQ(tile_count, all_tiles.size());
1114   EXPECT_EQ(17u, tile_count);
1115
1116   std::vector<Tile*> tiles(all_tiles.begin(), all_tiles.end());
1117   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
1118
1119   EvictionTilePriorityQueue queue;
1120   for (int i = 1; i < 10; ++i) {
1121     scoped_ptr<FakePictureLayerImpl> pending_layer =
1122         FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
1123     pending_layer->SetDrawsContent(true);
1124     pending_layer->DoPostCommitInitializationIfNeeded();
1125     pending_layer->set_has_valid_tile_priorities(true);
1126     pending_layer_->AddChild(pending_layer.PassAs<LayerImpl>());
1127   }
1128
1129   host_impl_.BuildEvictionQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
1130   EXPECT_FALSE(queue.IsEmpty());
1131
1132   tile_count = 0;
1133   all_tiles.clear();
1134   while (!queue.IsEmpty()) {
1135     EXPECT_TRUE(queue.Top());
1136     all_tiles.insert(queue.Top());
1137     ++tile_count;
1138     queue.Pop();
1139   }
1140   EXPECT_EQ(tile_count, all_tiles.size());
1141   EXPECT_EQ(17u, tile_count);
1142 }
1143
1144 }  // namespace
1145 }  // namespace cc