Home | History | Annotate | Download | only in resources 
      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
   1146