cc/tiles/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 "base/run_loop.h"
   6 #include "base/thread_task_runner_handle.h"
   7 #include "cc/resources/resource_pool.h"
   8 #include "cc/test/begin_frame_args_test.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_layer_tiling_client.h"
  15 #include "cc/test/fake_picture_pile_impl.h"
  16 #include "cc/test/fake_tile_manager.h"
  17 #include "cc/test/test_shared_bitmap_manager.h"
  18 #include "cc/test/test_task_graph_runner.h"
  19 #include "cc/test/test_tile_priorities.h"
  20 #include "cc/tiles/eviction_tile_priority_queue.h"
  21 #include "cc/tiles/raster_tile_priority_queue.h"
  22 #include "cc/tiles/tile.h"
  23 #include "cc/tiles/tile_priority.h"
  24 #include "cc/tiles/tiling_set_raster_queue_all.h"
  25 #include "cc/trees/layer_tree_impl.h"
  26 #include "testing/gmock/include/gmock/gmock.h"
  27 #include "testing/gtest/include/gtest/gtest.h"
  28
  29 namespace cc {
  30 namespace {
  31
  32 class LowResTilingsSettings : public LayerTreeSettings {
  33  public:
  34   LowResTilingsSettings() { create_low_res_tiling = true; }
  35 };
  36
  37 class TileManagerTilePriorityQueueTest : public testing::Test {
  38  public:
  39   TileManagerTilePriorityQueueTest()
  40       : memory_limit_policy_(ALLOW_ANYTHING),
  41         max_tiles_(10000),
  42         ready_to_activate_(false),
  43         id_(7),
  44         proxy_(base::ThreadTaskRunnerHandle::Get()),
  45         host_impl_(LowResTilingsSettings(),
  46                    &proxy_,
  47                    &shared_bitmap_manager_,
  48                    &task_graph_runner_) {}
  49
  50   void SetTreePriority(TreePriority tree_priority) {
  51     GlobalStateThatImpactsTilePriority state;
  52     gfx::Size tile_size(256, 256);
  53
  54     state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
  55     state.num_resources_limit = max_tiles_;
  56     state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
  57     state.memory_limit_policy = memory_limit_policy_;
  58     state.tree_priority = tree_priority;
  59
  60     global_state_ = state;
  61     host_impl_.resource_pool()->SetResourceUsageLimits(
  62         state.soft_memory_limit_in_bytes,
  63         state.soft_memory_limit_in_bytes,
  64         state.num_resources_limit);
  65     host_impl_.tile_manager()->SetGlobalStateForTesting(state);
  66   }
  67
  68   void SetUp() override {
  69     InitializeRenderer();
  70     SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
  71   }
  72
  73   virtual void InitializeRenderer() {
  74     host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
  75   }
  76
  77   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
  78     gfx::Size tile_size(100, 100);
  79
  80     scoped_refptr<FakePicturePileImpl> pending_pile =
  81         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
  82     scoped_refptr<FakePicturePileImpl> active_pile =
  83         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
  84
  85     SetupTrees(pending_pile, active_pile);
  86   }
  87
  88   void ActivateTree() {
  89     host_impl_.ActivateSyncTree();
  90     CHECK(!host_impl_.pending_tree());
  91     pending_layer_ = NULL;
  92     active_layer_ = static_cast<FakePictureLayerImpl*>(
  93         host_impl_.active_tree()->LayerById(id_));
  94   }
  95
  96   void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
  97                                           const gfx::Size& tile_size) {
  98     SetupDefaultTrees(layer_bounds);
  99     pending_layer_->set_fixed_tile_size(tile_size);
 100     active_layer_->set_fixed_tile_size(tile_size);
 101   }
 102
 103   void SetupTrees(scoped_refptr<PicturePileImpl> pending_pile,
 104                   scoped_refptr<PicturePileImpl> active_pile) {
 105     SetupPendingTree(active_pile);
 106     ActivateTree();
 107     SetupPendingTree(pending_pile);
 108   }
 109
 110   void SetupPendingTree(scoped_refptr<PicturePileImpl> pile) {
 111     host_impl_.CreatePendingTree();
 112     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 113
 114     // Steal from the recycled tree.
 115     scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
 116     DCHECK_IMPLIES(old_pending_root, old_pending_root->id() == id_);
 117
 118     scoped_ptr<FakePictureLayerImpl> pending_layer;
 119     if (old_pending_root) {
 120       pending_layer.reset(
 121           static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
 122       pending_layer->SetRasterSourceOnPending(pile, Region());
 123     } else {
 124       pending_layer =
 125           FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_, pile);
 126       pending_layer->SetDrawsContent(true);
 127       pending_layer->SetHasRenderSurface(true);
 128     }
 129     // The bounds() just mirror the pile size.
 130     pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
 131     pending_tree->SetRootLayer(pending_layer.Pass());
 132
 133     pending_layer_ = static_cast<FakePictureLayerImpl*>(
 134         host_impl_.pending_tree()->LayerById(id_));
 135
 136     // Add tilings/tiles for the layer.
 137     bool update_lcd_text = false;
 138     host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 139   }
 140
 141   TileManager* tile_manager() { return host_impl_.tile_manager(); }
 142
 143  protected:
 144   GlobalStateThatImpactsTilePriority global_state_;
 145
 146   TestSharedBitmapManager shared_bitmap_manager_;
 147   TestTaskGraphRunner task_graph_runner_;
 148   TileMemoryLimitPolicy memory_limit_policy_;
 149   int max_tiles_;
 150   bool ready_to_activate_;
 151   int id_;
 152   FakeImplProxy proxy_;
 153   FakeLayerTreeHostImpl host_impl_;
 154   FakePictureLayerImpl* pending_layer_;
 155   FakePictureLayerImpl* active_layer_;
 156 };
 157
 158 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
 159   const gfx::Size layer_bounds(1000, 1000);
 160   host_impl_.SetViewportSize(layer_bounds);
 161   SetupDefaultTrees(layer_bounds);
 162
 163   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
 164       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
 165   EXPECT_FALSE(queue->IsEmpty());
 166
 167   size_t tile_count = 0;
 168   std::set<Tile*> all_tiles;
 169   while (!queue->IsEmpty()) {
 170     EXPECT_TRUE(queue->Top().tile());
 171     all_tiles.insert(queue->Top().tile());
 172     ++tile_count;
 173     queue->Pop();
 174   }
 175
 176   EXPECT_EQ(tile_count, all_tiles.size());
 177   EXPECT_EQ(16u, tile_count);
 178
 179   // Sanity check, all tiles should be visible.
 180   std::set<Tile*> smoothness_tiles;
 181   queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
 182                                       RasterTilePriorityQueue::Type::ALL);
 183   bool had_low_res = false;
 184   while (!queue->IsEmpty()) {
 185     PrioritizedTile prioritized_tile = queue->Top();
 186     EXPECT_TRUE(prioritized_tile.tile());
 187     EXPECT_EQ(TilePriority::NOW, prioritized_tile.priority().priority_bin);
 188     if (prioritized_tile.priority().resolution == LOW_RESOLUTION)
 189       had_low_res = true;
 190     else
 191       smoothness_tiles.insert(prioritized_tile.tile());
 192     queue->Pop();
 193   }
 194   EXPECT_EQ(all_tiles, smoothness_tiles);
 195   EXPECT_TRUE(had_low_res);
 196
 197   // Check that everything is required for activation.
 198   queue = host_impl_.BuildRasterQueue(
 199       SMOOTHNESS_TAKES_PRIORITY,
 200       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 201   std::set<Tile*> required_for_activation_tiles;
 202   while (!queue->IsEmpty()) {
 203     PrioritizedTile prioritized_tile = queue->Top();
 204     EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
 205     required_for_activation_tiles.insert(prioritized_tile.tile());
 206     queue->Pop();
 207   }
 208   EXPECT_EQ(all_tiles, required_for_activation_tiles);
 209
 210   // Check that everything is required for draw.
 211   queue = host_impl_.BuildRasterQueue(
 212       SMOOTHNESS_TAKES_PRIORITY,
 213       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
 214   std::set<Tile*> required_for_draw_tiles;
 215   while (!queue->IsEmpty()) {
 216     PrioritizedTile prioritized_tile = queue->Top();
 217     EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
 218     required_for_draw_tiles.insert(prioritized_tile.tile());
 219     queue->Pop();
 220   }
 221   EXPECT_EQ(all_tiles, required_for_draw_tiles);
 222
 223   Region invalidation(gfx::Rect(0, 0, 500, 500));
 224
 225   // Invalidate the pending tree.
 226   pending_layer_->set_invalidation(invalidation);
 227   pending_layer_->HighResTiling()->Invalidate(invalidation);
 228   pending_layer_->LowResTiling()->Invalidate(invalidation);
 229
 230   // Renew all of the tile priorities.
 231   gfx::Rect viewport(50, 50, 100, 100);
 232   pending_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 233                                                             Occlusion());
 234   pending_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 235                                                            Occlusion());
 236   active_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 237                                                            Occlusion());
 238   active_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 239                                                           Occlusion());
 240
 241   // Populate all tiles directly from the tilings.
 242   all_tiles.clear();
 243   std::set<Tile*> high_res_tiles;
 244   std::vector<Tile*> pending_high_res_tiles =
 245       pending_layer_->HighResTiling()->AllTilesForTesting();
 246   for (size_t i = 0; i < pending_high_res_tiles.size(); ++i) {
 247     all_tiles.insert(pending_high_res_tiles[i]);
 248     high_res_tiles.insert(pending_high_res_tiles[i]);
 249   }
 250
 251   std::vector<Tile*> pending_low_res_tiles =
 252       pending_layer_->LowResTiling()->AllTilesForTesting();
 253   for (size_t i = 0; i < pending_low_res_tiles.size(); ++i)
 254     all_tiles.insert(pending_low_res_tiles[i]);
 255
 256   std::vector<Tile*> active_high_res_tiles =
 257       active_layer_->HighResTiling()->AllTilesForTesting();
 258   for (size_t i = 0; i < active_high_res_tiles.size(); ++i) {
 259     all_tiles.insert(active_high_res_tiles[i]);
 260     high_res_tiles.insert(active_high_res_tiles[i]);
 261   }
 262
 263   std::vector<Tile*> active_low_res_tiles =
 264       active_layer_->LowResTiling()->AllTilesForTesting();
 265   for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
 266     all_tiles.insert(active_low_res_tiles[i]);
 267
 268   PrioritizedTile last_tile;
 269   smoothness_tiles.clear();
 270   tile_count = 0;
 271   size_t correct_order_tiles = 0u;
 272   // Here we expect to get increasing ACTIVE_TREE priority_bin.
 273   queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
 274                                       RasterTilePriorityQueue::Type::ALL);
 275   std::set<Tile*> expected_required_for_draw_tiles;
 276   std::set<Tile*> expected_required_for_activation_tiles;
 277   while (!queue->IsEmpty()) {
 278     PrioritizedTile prioritized_tile = queue->Top();
 279     EXPECT_TRUE(prioritized_tile.tile());
 280
 281     if (!last_tile.tile())
 282       last_tile = prioritized_tile;
 283
 284     EXPECT_LE(last_tile.priority().priority_bin,
 285               prioritized_tile.priority().priority_bin);
 286     bool skip_updating_last_tile = false;
 287     if (last_tile.priority().priority_bin ==
 288         prioritized_tile.priority().priority_bin) {
 289       correct_order_tiles += last_tile.priority().distance_to_visible <=
 290                              prioritized_tile.priority().distance_to_visible;
 291     } else if (prioritized_tile.priority().priority_bin == TilePriority::NOW) {
 292       // Since we'd return pending tree now tiles before the eventually tiles on
 293       // the active tree, update the value.
 294       ++correct_order_tiles;
 295       skip_updating_last_tile = true;
 296     }
 297
 298     if (prioritized_tile.priority().priority_bin == TilePriority::NOW &&
 299         last_tile.priority().resolution !=
 300             prioritized_tile.priority().resolution) {
 301       // Low resolution should come first.
 302       EXPECT_EQ(LOW_RESOLUTION, last_tile.priority().resolution);
 303     }
 304
 305     if (!skip_updating_last_tile)
 306       last_tile = prioritized_tile;
 307     ++tile_count;
 308     smoothness_tiles.insert(prioritized_tile.tile());
 309     if (prioritized_tile.tile()->required_for_draw())
 310       expected_required_for_draw_tiles.insert(prioritized_tile.tile());
 311     if (prioritized_tile.tile()->required_for_activation())
 312       expected_required_for_activation_tiles.insert(prioritized_tile.tile());
 313     queue->Pop();
 314   }
 315
 316   EXPECT_EQ(tile_count, smoothness_tiles.size());
 317   EXPECT_EQ(all_tiles, smoothness_tiles);
 318   // Since we don't guarantee increasing distance due to spiral iterator, we
 319   // should check that we're _mostly_ right.
 320   EXPECT_GT(correct_order_tiles, 3 * tile_count / 4);
 321
 322   // Check that we have consistent required_for_activation tiles.
 323   queue = host_impl_.BuildRasterQueue(
 324       SMOOTHNESS_TAKES_PRIORITY,
 325       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 326   required_for_activation_tiles.clear();
 327   while (!queue->IsEmpty()) {
 328     PrioritizedTile prioritized_tile = queue->Top();
 329     EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
 330     required_for_activation_tiles.insert(prioritized_tile.tile());
 331     queue->Pop();
 332   }
 333   EXPECT_EQ(expected_required_for_activation_tiles,
 334             required_for_activation_tiles);
 335   EXPECT_NE(all_tiles, required_for_activation_tiles);
 336
 337   // Check that we have consistent required_for_draw tiles.
 338   queue = host_impl_.BuildRasterQueue(
 339       SMOOTHNESS_TAKES_PRIORITY,
 340       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
 341   required_for_draw_tiles.clear();
 342   while (!queue->IsEmpty()) {
 343     PrioritizedTile prioritized_tile = queue->Top();
 344     EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
 345     required_for_draw_tiles.insert(prioritized_tile.tile());
 346     queue->Pop();
 347   }
 348   EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
 349   EXPECT_NE(all_tiles, required_for_draw_tiles);
 350
 351   std::set<Tile*> new_content_tiles;
 352   last_tile = PrioritizedTile();
 353   size_t increasing_distance_tiles = 0u;
 354   // Here we expect to get increasing PENDING_TREE priority_bin.
 355   queue = host_impl_.BuildRasterQueue(NEW_CONTENT_TAKES_PRIORITY,
 356                                       RasterTilePriorityQueue::Type::ALL);
 357   tile_count = 0;
 358   while (!queue->IsEmpty()) {
 359     PrioritizedTile prioritized_tile = queue->Top();
 360     EXPECT_TRUE(prioritized_tile.tile());
 361
 362     if (!last_tile.tile())
 363       last_tile = prioritized_tile;
 364
 365     EXPECT_LE(last_tile.priority().priority_bin,
 366               prioritized_tile.priority().priority_bin);
 367     if (last_tile.priority().priority_bin ==
 368         prioritized_tile.priority().priority_bin) {
 369       increasing_distance_tiles +=
 370           last_tile.priority().distance_to_visible <=
 371           prioritized_tile.priority().distance_to_visible;
 372     }
 373
 374     if (prioritized_tile.priority().priority_bin == TilePriority::NOW &&
 375         last_tile.priority().resolution !=
 376             prioritized_tile.priority().resolution) {
 377       // High resolution should come first.
 378       EXPECT_EQ(HIGH_RESOLUTION, last_tile.priority().resolution);
 379     }
 380
 381     last_tile = prioritized_tile;
 382     new_content_tiles.insert(prioritized_tile.tile());
 383     ++tile_count;
 384     queue->Pop();
 385   }
 386
 387   EXPECT_EQ(tile_count, new_content_tiles.size());
 388   EXPECT_EQ(high_res_tiles, new_content_tiles);
 389   // Since we don't guarantee increasing distance due to spiral iterator, we
 390   // should check that we're _mostly_ right.
 391   EXPECT_GE(increasing_distance_tiles, 3 * tile_count / 4);
 392
 393   // Check that we have consistent required_for_activation tiles.
 394   queue = host_impl_.BuildRasterQueue(
 395       NEW_CONTENT_TAKES_PRIORITY,
 396       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 397   required_for_activation_tiles.clear();
 398   while (!queue->IsEmpty()) {
 399     PrioritizedTile prioritized_tile = queue->Top();
 400     EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
 401     required_for_activation_tiles.insert(prioritized_tile.tile());
 402     queue->Pop();
 403   }
 404   EXPECT_EQ(expected_required_for_activation_tiles,
 405             required_for_activation_tiles);
 406   EXPECT_NE(new_content_tiles, required_for_activation_tiles);
 407
 408   // Check that we have consistent required_for_draw tiles.
 409   queue = host_impl_.BuildRasterQueue(
 410       NEW_CONTENT_TAKES_PRIORITY,
 411       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
 412   required_for_draw_tiles.clear();
 413   while (!queue->IsEmpty()) {
 414     PrioritizedTile prioritized_tile = queue->Top();
 415     EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
 416     required_for_draw_tiles.insert(prioritized_tile.tile());
 417     queue->Pop();
 418   }
 419   EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
 420   EXPECT_NE(new_content_tiles, required_for_draw_tiles);
 421 }
 422
 423 TEST_F(TileManagerTilePriorityQueueTest,
 424        RasterTilePriorityQueueHighNonIdealTilings) {
 425   const gfx::Size layer_bounds(1000, 1000);
 426   const gfx::Size viewport(800, 800);
 427   host_impl_.SetViewportSize(viewport);
 428   SetupDefaultTrees(layer_bounds);
 429
 430   pending_layer_->tilings()->AddTiling(1.5f, pending_layer_->raster_source());
 431   active_layer_->tilings()->AddTiling(1.5f, active_layer_->raster_source());
 432   pending_layer_->tilings()->AddTiling(1.7f, pending_layer_->raster_source());
 433   active_layer_->tilings()->AddTiling(1.7f, active_layer_->raster_source());
 434
 435   pending_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
 436                                                   Occlusion(), true);
 437   active_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
 438                                                  Occlusion(), true);
 439
 440   std::set<Tile*> all_expected_tiles;
 441   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
 442     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
 443     if (tiling->contents_scale() == 1.f) {
 444       tiling->set_resolution(HIGH_RESOLUTION);
 445       const auto& all_tiles = tiling->AllTilesForTesting();
 446       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
 447     } else {
 448       tiling->set_resolution(NON_IDEAL_RESOLUTION);
 449     }
 450   }
 451
 452   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
 453     PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
 454     if (tiling->contents_scale() == 1.5f) {
 455       tiling->set_resolution(HIGH_RESOLUTION);
 456       const auto& all_tiles = tiling->AllTilesForTesting();
 457       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
 458     } else {
 459       tiling->set_resolution(NON_IDEAL_RESOLUTION);
 460       // Non ideal tilings with a high res pending twin have to be processed
 461       // because of possible activation tiles.
 462       if (tiling->contents_scale() == 1.f) {
 463         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 464         const auto& all_tiles = tiling->AllTilesForTesting();
 465         for (auto* tile : all_tiles)
 466           EXPECT_TRUE(tile->required_for_activation());
 467         all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
 468       }
 469     }
 470   }
 471
 472   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
 473       SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
 474   EXPECT_FALSE(queue->IsEmpty());
 475
 476   size_t tile_count = 0;
 477   std::set<Tile*> all_actual_tiles;
 478   while (!queue->IsEmpty()) {
 479     EXPECT_TRUE(queue->Top().tile());
 480     all_actual_tiles.insert(queue->Top().tile());
 481     ++tile_count;
 482     queue->Pop();
 483   }
 484
 485   EXPECT_EQ(tile_count, all_actual_tiles.size());
 486   EXPECT_EQ(all_expected_tiles.size(), all_actual_tiles.size());
 487   EXPECT_EQ(all_expected_tiles, all_actual_tiles);
 488 }
 489
 490 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueInvalidation) {
 491   const gfx::Size layer_bounds(1000, 1000);
 492   host_impl_.SetViewportSize(gfx::Size(500, 500));
 493   SetupDefaultTrees(layer_bounds);
 494
 495   // Use a tile's content rect as an invalidation. We should inset it a bit to
 496   // ensure that border math doesn't invalidate neighbouring tiles.
 497   gfx::Rect invalidation =
 498       active_layer_->HighResTiling()->TileAt(1, 0)->content_rect();
 499   invalidation.Inset(2, 2);
 500
 501   pending_layer_->set_invalidation(invalidation);
 502   pending_layer_->HighResTiling()->Invalidate(invalidation);
 503   pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
 504   pending_layer_->LowResTiling()->Invalidate(invalidation);
 505   pending_layer_->LowResTiling()->CreateMissingTilesInLiveTilesRect();
 506
 507   // Sanity checks: Tile at 0, 0 not exist on the pending tree (it's not
 508   // invalidated). Tile 1, 0 should exist on both.
 509   EXPECT_FALSE(pending_layer_->HighResTiling()->TileAt(0, 0));
 510   EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(0, 0));
 511   EXPECT_TRUE(pending_layer_->HighResTiling()->TileAt(1, 0));
 512   EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(1, 0));
 513   EXPECT_NE(pending_layer_->HighResTiling()->TileAt(1, 0),
 514             active_layer_->HighResTiling()->TileAt(1, 0));
 515
 516   std::set<Tile*> expected_now_tiles;
 517   std::set<Tile*> expected_required_for_draw_tiles;
 518   std::set<Tile*> expected_required_for_activation_tiles;
 519   for (int i = 0; i <= 1; ++i) {
 520     for (int j = 0; j <= 1; ++j) {
 521       bool have_pending_tile = false;
 522       if (pending_layer_->HighResTiling()->TileAt(i, j)) {
 523         expected_now_tiles.insert(
 524             pending_layer_->HighResTiling()->TileAt(i, j));
 525         expected_required_for_activation_tiles.insert(
 526             pending_layer_->HighResTiling()->TileAt(i, j));
 527         have_pending_tile = true;
 528       }
 529       Tile* active_tile = active_layer_->HighResTiling()->TileAt(i, j);
 530       EXPECT_TRUE(active_tile);
 531       expected_now_tiles.insert(active_tile);
 532       expected_required_for_draw_tiles.insert(active_tile);
 533       if (!have_pending_tile)
 534         expected_required_for_activation_tiles.insert(active_tile);
 535     }
 536   }
 537   // Expect 3 shared tiles and 1 unshared tile in total.
 538   EXPECT_EQ(5u, expected_now_tiles.size());
 539   // Expect 4 tiles for each draw and activation, but not all the same.
 540   EXPECT_EQ(4u, expected_required_for_activation_tiles.size());
 541   EXPECT_EQ(4u, expected_required_for_draw_tiles.size());
 542   EXPECT_NE(expected_required_for_draw_tiles,
 543             expected_required_for_activation_tiles);
 544
 545   std::set<Tile*> expected_all_tiles;
 546   for (int i = 0; i <= 3; ++i) {
 547     for (int j = 0; j <= 3; ++j) {
 548       if (pending_layer_->HighResTiling()->TileAt(i, j))
 549         expected_all_tiles.insert(
 550             pending_layer_->HighResTiling()->TileAt(i, j));
 551       EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(i, j));
 552       expected_all_tiles.insert(active_layer_->HighResTiling()->TileAt(i, j));
 553     }
 554   }
 555   // Expect 15 shared tiles and 1 unshared tile.
 556   EXPECT_EQ(17u, expected_all_tiles.size());
 557
 558   // The actual test will now build different queues and verify that the queues
 559   // return the same information as computed manually above.
 560   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
 561       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
 562   std::set<Tile*> actual_now_tiles;
 563   std::set<Tile*> actual_all_tiles;
 564   while (!queue->IsEmpty()) {
 565     PrioritizedTile prioritized_tile = queue->Top();
 566     queue->Pop();
 567     if (prioritized_tile.priority().priority_bin == TilePriority::NOW)
 568       actual_now_tiles.insert(prioritized_tile.tile());
 569     actual_all_tiles.insert(prioritized_tile.tile());
 570   }
 571   EXPECT_EQ(expected_now_tiles, actual_now_tiles);
 572   EXPECT_EQ(expected_all_tiles, actual_all_tiles);
 573
 574   queue = host_impl_.BuildRasterQueue(
 575       SAME_PRIORITY_FOR_BOTH_TREES,
 576       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
 577   std::set<Tile*> actual_required_for_draw_tiles;
 578   while (!queue->IsEmpty()) {
 579     PrioritizedTile prioritized_tile = queue->Top();
 580     queue->Pop();
 581     actual_required_for_draw_tiles.insert(prioritized_tile.tile());
 582   }
 583   EXPECT_EQ(expected_required_for_draw_tiles, actual_required_for_draw_tiles);
 584
 585   queue = host_impl_.BuildRasterQueue(
 586       SAME_PRIORITY_FOR_BOTH_TREES,
 587       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 588   std::set<Tile*> actual_required_for_activation_tiles;
 589   while (!queue->IsEmpty()) {
 590     Tile* tile = queue->Top().tile();
 591     queue->Pop();
 592     actual_required_for_activation_tiles.insert(tile);
 593   }
 594   EXPECT_EQ(expected_required_for_activation_tiles,
 595             actual_required_for_activation_tiles);
 596 }
 597
 598 TEST_F(TileManagerTilePriorityQueueTest, ActivationComesBeforeEventually) {
 599   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 600
 601   gfx::Size layer_bounds(1000, 1000);
 602   SetupDefaultTrees(layer_bounds);
 603
 604   // Create a pending child layer.
 605   gfx::Size tile_size(256, 256);
 606   scoped_refptr<FakePicturePileImpl> pending_pile =
 607       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 608   scoped_ptr<FakePictureLayerImpl> pending_child =
 609       FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(),
 610                                                    id_ + 1, pending_pile);
 611   FakePictureLayerImpl* pending_child_raw = pending_child.get();
 612   pending_child_raw->SetDrawsContent(true);
 613   pending_layer_->AddChild(pending_child.Pass());
 614
 615   // Set a small viewport, so we have soon and eventually tiles.
 616   host_impl_.SetViewportSize(gfx::Size(200, 200));
 617   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 618   bool update_lcd_text = false;
 619   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 620
 621   host_impl_.SetRequiresHighResToDraw();
 622   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
 623       SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
 624   EXPECT_FALSE(queue->IsEmpty());
 625
 626   // Get all the tiles that are NOW or SOON and make sure they are ready to
 627   // draw.
 628   std::vector<Tile*> all_tiles;
 629   while (!queue->IsEmpty()) {
 630     PrioritizedTile prioritized_tile = queue->Top();
 631     if (prioritized_tile.priority().priority_bin >= TilePriority::EVENTUALLY)
 632       break;
 633
 634     all_tiles.push_back(prioritized_tile.tile());
 635     queue->Pop();
 636   }
 637
 638   tile_manager()->InitializeTilesWithResourcesForTesting(
 639       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 640
 641   // Ensure we can activate.
 642   EXPECT_TRUE(tile_manager()->IsReadyToActivate());
 643 }
 644
 645 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
 646   const gfx::Size layer_bounds(1000, 1000);
 647   host_impl_.SetViewportSize(layer_bounds);
 648   SetupDefaultTrees(layer_bounds);
 649
 650   scoped_ptr<EvictionTilePriorityQueue> empty_queue(
 651       host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
 652   EXPECT_TRUE(empty_queue->IsEmpty());
 653   std::set<Tile*> all_tiles;
 654   size_t tile_count = 0;
 655
 656   scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
 657       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
 658   while (!raster_queue->IsEmpty()) {
 659     ++tile_count;
 660     EXPECT_TRUE(raster_queue->Top().tile());
 661     all_tiles.insert(raster_queue->Top().tile());
 662     raster_queue->Pop();
 663   }
 664
 665   EXPECT_EQ(tile_count, all_tiles.size());
 666   EXPECT_EQ(16u, tile_count);
 667
 668   tile_manager()->InitializeTilesWithResourcesForTesting(
 669       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 670
 671   scoped_ptr<EvictionTilePriorityQueue> queue(
 672       host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY));
 673   EXPECT_FALSE(queue->IsEmpty());
 674
 675   // Sanity check, all tiles should be visible.
 676   std::set<Tile*> smoothness_tiles;
 677   while (!queue->IsEmpty()) {
 678     PrioritizedTile prioritized_tile = queue->Top();
 679     EXPECT_TRUE(prioritized_tile.tile());
 680     EXPECT_EQ(TilePriority::NOW, prioritized_tile.priority().priority_bin);
 681     EXPECT_TRUE(prioritized_tile.tile()->draw_info().has_resource());
 682     smoothness_tiles.insert(prioritized_tile.tile());
 683     queue->Pop();
 684   }
 685   EXPECT_EQ(all_tiles, smoothness_tiles);
 686
 687   tile_manager()->ReleaseTileResourcesForTesting(
 688       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 689
 690   Region invalidation(gfx::Rect(0, 0, 500, 500));
 691
 692   // Invalidate the pending tree.
 693   pending_layer_->set_invalidation(invalidation);
 694   pending_layer_->HighResTiling()->Invalidate(invalidation);
 695   pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
 696   pending_layer_->LowResTiling()->Invalidate(invalidation);
 697   pending_layer_->LowResTiling()->CreateMissingTilesInLiveTilesRect();
 698
 699   // Renew all of the tile priorities.
 700   gfx::Rect viewport(50, 50, 100, 100);
 701   pending_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 702                                                             Occlusion());
 703   pending_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 704                                                            Occlusion());
 705   active_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 706                                                            Occlusion());
 707   active_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 708                                                           Occlusion());
 709
 710   // Populate all tiles directly from the tilings.
 711   all_tiles.clear();
 712   std::vector<Tile*> pending_high_res_tiles =
 713       pending_layer_->HighResTiling()->AllTilesForTesting();
 714   for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
 715     all_tiles.insert(pending_high_res_tiles[i]);
 716
 717   std::vector<Tile*> pending_low_res_tiles =
 718       pending_layer_->LowResTiling()->AllTilesForTesting();
 719   for (size_t i = 0; i < pending_low_res_tiles.size(); ++i)
 720     all_tiles.insert(pending_low_res_tiles[i]);
 721
 722   std::vector<Tile*> active_high_res_tiles =
 723       active_layer_->HighResTiling()->AllTilesForTesting();
 724   for (size_t i = 0; i < active_high_res_tiles.size(); ++i)
 725     all_tiles.insert(active_high_res_tiles[i]);
 726
 727   std::vector<Tile*> active_low_res_tiles =
 728       active_layer_->LowResTiling()->AllTilesForTesting();
 729   for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
 730     all_tiles.insert(active_low_res_tiles[i]);
 731
 732   tile_manager()->InitializeTilesWithResourcesForTesting(
 733       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 734
 735   PrioritizedTile last_tile;
 736   smoothness_tiles.clear();
 737   tile_count = 0;
 738   // Here we expect to get increasing combined priority_bin.
 739   queue = host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY);
 740   int distance_increasing = 0;
 741   int distance_decreasing = 0;
 742   while (!queue->IsEmpty()) {
 743     PrioritizedTile prioritized_tile = queue->Top();
 744     Tile* tile = prioritized_tile.tile();
 745     EXPECT_TRUE(tile);
 746     EXPECT_TRUE(tile->draw_info().has_resource());
 747
 748     if (!last_tile.tile())
 749       last_tile = prioritized_tile;
 750
 751     const TilePriority& last_priority = last_tile.priority();
 752     const TilePriority& priority = prioritized_tile.priority();
 753
 754     EXPECT_GE(last_priority.priority_bin, priority.priority_bin);
 755     if (last_priority.priority_bin == priority.priority_bin) {
 756       EXPECT_LE(last_tile.tile()->required_for_activation(),
 757                 tile->required_for_activation());
 758       if (last_tile.tile()->required_for_activation() ==
 759           tile->required_for_activation()) {
 760         if (last_priority.distance_to_visible >= priority.distance_to_visible)
 761           ++distance_decreasing;
 762         else
 763           ++distance_increasing;
 764       }
 765     }
 766
 767     last_tile = prioritized_tile;
 768     ++tile_count;
 769     smoothness_tiles.insert(tile);
 770     queue->Pop();
 771   }
 772
 773   // Ensure that the distance is decreasing many more times than increasing.
 774   EXPECT_EQ(3, distance_increasing);
 775   EXPECT_EQ(17, distance_decreasing);
 776   EXPECT_EQ(tile_count, smoothness_tiles.size());
 777   EXPECT_EQ(all_tiles, smoothness_tiles);
 778
 779   std::set<Tile*> new_content_tiles;
 780   last_tile = PrioritizedTile();
 781   // Again, we expect to get increasing combined priority_bin.
 782   queue = host_impl_.BuildEvictionQueue(NEW_CONTENT_TAKES_PRIORITY);
 783   distance_decreasing = 0;
 784   distance_increasing = 0;
 785   while (!queue->IsEmpty()) {
 786     PrioritizedTile prioritized_tile = queue->Top();
 787     Tile* tile = prioritized_tile.tile();
 788     EXPECT_TRUE(tile);
 789
 790     if (!last_tile.tile())
 791       last_tile = prioritized_tile;
 792
 793     const TilePriority& last_priority = last_tile.priority();
 794     const TilePriority& priority = prioritized_tile.priority();
 795
 796     EXPECT_GE(last_priority.priority_bin, priority.priority_bin);
 797     if (last_priority.priority_bin == priority.priority_bin) {
 798       EXPECT_LE(last_tile.tile()->required_for_activation(),
 799                 tile->required_for_activation());
 800       if (last_tile.tile()->required_for_activation() ==
 801           tile->required_for_activation()) {
 802         if (last_priority.distance_to_visible >= priority.distance_to_visible)
 803           ++distance_decreasing;
 804         else
 805           ++distance_increasing;
 806       }
 807     }
 808
 809     last_tile = prioritized_tile;
 810     new_content_tiles.insert(tile);
 811     queue->Pop();
 812   }
 813
 814   // Ensure that the distance is decreasing many more times than increasing.
 815   EXPECT_EQ(3, distance_increasing);
 816   EXPECT_EQ(17, distance_decreasing);
 817   EXPECT_EQ(tile_count, new_content_tiles.size());
 818   EXPECT_EQ(all_tiles, new_content_tiles);
 819 }
 820
 821 TEST_F(TileManagerTilePriorityQueueTest,
 822        EvictionTilePriorityQueueWithOcclusion) {
 823   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 824
 825   gfx::Size tile_size(102, 102);
 826   gfx::Size layer_bounds(1000, 1000);
 827
 828   host_impl_.SetViewportSize(layer_bounds);
 829
 830   scoped_refptr<FakePicturePileImpl> pending_pile =
 831       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 832   SetupPendingTree(pending_pile);
 833
 834   scoped_ptr<FakePictureLayerImpl> pending_child =
 835       FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
 836                                                    pending_pile);
 837   pending_layer_->AddChild(pending_child.Pass());
 838
 839   FakePictureLayerImpl* pending_child_layer =
 840       static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
 841   pending_child_layer->SetDrawsContent(true);
 842
 843   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 844   bool update_lcd_text = false;
 845   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 846
 847   ActivateTree();
 848   SetupPendingTree(pending_pile);
 849
 850   FakePictureLayerImpl* active_child_layer =
 851       static_cast<FakePictureLayerImpl*>(active_layer_->children()[0]);
 852
 853   std::set<Tile*> all_tiles;
 854   size_t tile_count = 0;
 855   scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
 856       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
 857   while (!raster_queue->IsEmpty()) {
 858     ++tile_count;
 859     EXPECT_TRUE(raster_queue->Top().tile());
 860     all_tiles.insert(raster_queue->Top().tile());
 861     raster_queue->Pop();
 862   }
 863   EXPECT_EQ(tile_count, all_tiles.size());
 864   EXPECT_EQ(32u, tile_count);
 865
 866   // Renew all of the tile priorities.
 867   gfx::Rect viewport(layer_bounds);
 868   pending_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 869                                                             Occlusion());
 870   pending_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 871                                                            Occlusion());
 872   pending_child_layer->HighResTiling()->ComputeTilePriorityRects(
 873       viewport, 1.0f, 1.0, Occlusion());
 874   pending_child_layer->LowResTiling()->ComputeTilePriorityRects(
 875       viewport, 1.0f, 1.0, Occlusion());
 876
 877   active_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 878                                                            Occlusion());
 879   active_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 880                                                           Occlusion());
 881   active_child_layer->HighResTiling()->ComputeTilePriorityRects(
 882       viewport, 1.0f, 1.0, Occlusion());
 883   active_child_layer->LowResTiling()->ComputeTilePriorityRects(
 884       viewport, 1.0f, 1.0, Occlusion());
 885
 886   // Populate all tiles directly from the tilings.
 887   all_tiles.clear();
 888   std::vector<Tile*> pending_high_res_tiles =
 889       pending_layer_->HighResTiling()->AllTilesForTesting();
 890   all_tiles.insert(pending_high_res_tiles.begin(),
 891                    pending_high_res_tiles.end());
 892
 893   std::vector<Tile*> pending_low_res_tiles =
 894       pending_layer_->LowResTiling()->AllTilesForTesting();
 895   all_tiles.insert(pending_low_res_tiles.begin(), pending_low_res_tiles.end());
 896
 897   // Set all tiles on the pending_child_layer as occluded on the pending tree.
 898   std::vector<Tile*> pending_child_high_res_tiles =
 899       pending_child_layer->HighResTiling()->AllTilesForTesting();
 900   pending_child_layer->HighResTiling()->SetAllTilesOccludedForTesting();
 901   active_child_layer->HighResTiling()->SetAllTilesOccludedForTesting();
 902   all_tiles.insert(pending_child_high_res_tiles.begin(),
 903                    pending_child_high_res_tiles.end());
 904
 905   std::vector<Tile*> pending_child_low_res_tiles =
 906       pending_child_layer->LowResTiling()->AllTilesForTesting();
 907   pending_child_layer->LowResTiling()->SetAllTilesOccludedForTesting();
 908   active_child_layer->LowResTiling()->SetAllTilesOccludedForTesting();
 909   all_tiles.insert(pending_child_low_res_tiles.begin(),
 910                    pending_child_low_res_tiles.end());
 911
 912   tile_manager()->InitializeTilesWithResourcesForTesting(
 913       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 914
 915   // Verify occlusion is considered by EvictionTilePriorityQueue.
 916   TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
 917   size_t occluded_count = 0u;
 918   PrioritizedTile last_tile;
 919   scoped_ptr<EvictionTilePriorityQueue> queue(
 920       host_impl_.BuildEvictionQueue(tree_priority));
 921   while (!queue->IsEmpty()) {
 922     PrioritizedTile prioritized_tile = queue->Top();
 923     if (!last_tile.tile())
 924       last_tile = prioritized_tile;
 925
 926     bool tile_is_occluded = prioritized_tile.is_occluded();
 927
 928     // The only way we will encounter an occluded tile after an unoccluded
 929     // tile is if the priorty bin decreased, the tile is required for
 930     // activation, or the scale changed.
 931     if (tile_is_occluded) {
 932       occluded_count++;
 933
 934       bool last_tile_is_occluded = last_tile.is_occluded();
 935       if (!last_tile_is_occluded) {
 936         TilePriority::PriorityBin tile_priority_bin =
 937             prioritized_tile.priority().priority_bin;
 938         TilePriority::PriorityBin last_tile_priority_bin =
 939             last_tile.priority().priority_bin;
 940
 941         EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) ||
 942                     prioritized_tile.tile()->required_for_activation() ||
 943                     (prioritized_tile.tile()->contents_scale() !=
 944                      last_tile.tile()->contents_scale()));
 945       }
 946     }
 947     last_tile = prioritized_tile;
 948     queue->Pop();
 949   }
 950   size_t expected_occluded_count =
 951       pending_child_high_res_tiles.size() + pending_child_low_res_tiles.size();
 952   EXPECT_EQ(expected_occluded_count, occluded_count);
 953 }
 954
 955 TEST_F(TileManagerTilePriorityQueueTest,
 956        EvictionTilePriorityQueueWithTransparentLayer) {
 957   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 958
 959   gfx::Size tile_size(102, 102);
 960   gfx::Size layer_bounds(1000, 1000);
 961
 962   scoped_refptr<FakePicturePileImpl> pending_pile =
 963       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 964   SetupPendingTree(pending_pile);
 965
 966   scoped_ptr<FakePictureLayerImpl> pending_child =
 967       FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
 968                                                    pending_pile);
 969   FakePictureLayerImpl* pending_child_layer = pending_child.get();
 970   pending_layer_->AddChild(pending_child.Pass());
 971
 972   // Create a fully transparent child layer so that its tile priorities are not
 973   // considered to be valid.
 974   pending_child_layer->SetDrawsContent(true);
 975
 976   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 977   bool update_lcd_text = false;
 978   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 979
 980   pending_child_layer->SetOpacity(0.0);
 981
 982   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 983   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 984
 985   // Renew all of the tile priorities.
 986   gfx::Rect viewport(layer_bounds);
 987   pending_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 988                                                             Occlusion());
 989   pending_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
 990                                                            Occlusion());
 991   pending_child_layer->HighResTiling()->ComputeTilePriorityRects(
 992       viewport, 1.0f, 1.0, Occlusion());
 993   pending_child_layer->LowResTiling()->ComputeTilePriorityRects(
 994       viewport, 1.0f, 1.0, Occlusion());
 995
 996   // Populate all tiles directly from the tilings.
 997   std::set<Tile*> all_pending_tiles;
 998   std::vector<Tile*> pending_high_res_tiles =
 999       pending_layer_->HighResTiling()->AllTilesForTesting();
1000   all_pending_tiles.insert(pending_high_res_tiles.begin(),
1001                            pending_high_res_tiles.end());
1002   EXPECT_EQ(16u, pending_high_res_tiles.size());
1003
1004   std::vector<Tile*> pending_low_res_tiles =
1005       pending_layer_->LowResTiling()->AllTilesForTesting();
1006   all_pending_tiles.insert(pending_low_res_tiles.begin(),
1007                            pending_low_res_tiles.end());
1008   EXPECT_EQ(1u, pending_low_res_tiles.size());
1009
1010   std::set<Tile*> all_pending_child_tiles;
1011   std::vector<Tile*> pending_child_high_res_tiles =
1012       pending_child_layer->HighResTiling()->AllTilesForTesting();
1013   all_pending_child_tiles.insert(pending_child_high_res_tiles.begin(),
1014                                  pending_child_high_res_tiles.end());
1015   EXPECT_EQ(16u, pending_child_high_res_tiles.size());
1016
1017   std::vector<Tile*> pending_child_low_res_tiles =
1018       pending_child_layer->LowResTiling()->AllTilesForTesting();
1019   all_pending_child_tiles.insert(pending_child_low_res_tiles.begin(),
1020                                  pending_child_low_res_tiles.end());
1021   EXPECT_EQ(1u, pending_child_low_res_tiles.size());
1022
1023   std::set<Tile*> all_tiles = all_pending_tiles;
1024   all_tiles.insert(all_pending_child_tiles.begin(),
1025                    all_pending_child_tiles.end());
1026
1027   tile_manager()->InitializeTilesWithResourcesForTesting(
1028       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
1029
1030   EXPECT_TRUE(pending_layer_->HasValidTilePriorities());
1031   EXPECT_FALSE(pending_child_layer->HasValidTilePriorities());
1032
1033   // Verify that eviction queue returns tiles also from layers without valid
1034   // tile priorities and that the tile priority bin of those tiles is (at most)
1035   // EVENTUALLY.
1036   TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
1037   std::set<Tile*> new_content_tiles;
1038   size_t tile_count = 0;
1039   scoped_ptr<EvictionTilePriorityQueue> queue(
1040       host_impl_.BuildEvictionQueue(tree_priority));
1041   while (!queue->IsEmpty()) {
1042     PrioritizedTile prioritized_tile = queue->Top();
1043     Tile* tile = prioritized_tile.tile();
1044     const TilePriority& pending_priority = prioritized_tile.priority();
1045     EXPECT_NE(std::numeric_limits<float>::infinity(),
1046               pending_priority.distance_to_visible);
1047     if (all_pending_child_tiles.find(tile) != all_pending_child_tiles.end())
1048       EXPECT_EQ(TilePriority::EVENTUALLY, pending_priority.priority_bin);
1049     else
1050       EXPECT_EQ(TilePriority::NOW, pending_priority.priority_bin);
1051     new_content_tiles.insert(tile);
1052     ++tile_count;
1053     queue->Pop();
1054   }
1055   EXPECT_EQ(tile_count, new_content_tiles.size());
1056   EXPECT_EQ(all_tiles, new_content_tiles);
1057 }
1058
1059 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
1060   const gfx::Size layer_bounds(1000, 1000);
1061   host_impl_.SetViewportSize(layer_bounds);
1062   SetupDefaultTrees(layer_bounds);
1063
1064   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
1065       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
1066   EXPECT_FALSE(queue->IsEmpty());
1067
1068   size_t tile_count = 0;
1069   std::set<Tile*> all_tiles;
1070   while (!queue->IsEmpty()) {
1071     EXPECT_TRUE(queue->Top().tile());
1072     all_tiles.insert(queue->Top().tile());
1073     ++tile_count;
1074     queue->Pop();
1075   }
1076
1077   EXPECT_EQ(tile_count, all_tiles.size());
1078   EXPECT_EQ(16u, tile_count);
1079
1080   for (int i = 1; i < 10; ++i) {
1081     scoped_ptr<FakePictureLayerImpl> pending_layer =
1082         FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
1083     pending_layer->SetDrawsContent(true);
1084     pending_layer->set_has_valid_tile_priorities(true);
1085     pending_layer_->AddChild(pending_layer.Pass());
1086   }
1087
1088   queue = host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
1089                                       RasterTilePriorityQueue::Type::ALL);
1090   EXPECT_FALSE(queue->IsEmpty());
1091
1092   tile_count = 0;
1093   all_tiles.clear();
1094   while (!queue->IsEmpty()) {
1095     EXPECT_TRUE(queue->Top().tile());
1096     all_tiles.insert(queue->Top().tile());
1097     ++tile_count;
1098     queue->Pop();
1099   }
1100   EXPECT_EQ(tile_count, all_tiles.size());
1101   EXPECT_EQ(16u, tile_count);
1102 }
1103
1104 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
1105   const gfx::Size layer_bounds(1000, 1000);
1106   host_impl_.SetViewportSize(layer_bounds);
1107   SetupDefaultTrees(layer_bounds);
1108
1109   scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
1110       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
1111   EXPECT_FALSE(raster_queue->IsEmpty());
1112
1113   size_t tile_count = 0;
1114   std::set<Tile*> all_tiles;
1115   while (!raster_queue->IsEmpty()) {
1116     EXPECT_TRUE(raster_queue->Top().tile());
1117     all_tiles.insert(raster_queue->Top().tile());
1118     ++tile_count;
1119     raster_queue->Pop();
1120   }
1121   EXPECT_EQ(tile_count, all_tiles.size());
1122   EXPECT_EQ(16u, tile_count);
1123
1124   std::vector<Tile*> tiles(all_tiles.begin(), all_tiles.end());
1125   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
1126
1127   for (int i = 1; i < 10; ++i) {
1128     scoped_ptr<FakePictureLayerImpl> pending_layer =
1129         FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
1130     pending_layer->SetDrawsContent(true);
1131     pending_layer->set_has_valid_tile_priorities(true);
1132     pending_layer_->AddChild(pending_layer.Pass());
1133   }
1134
1135   scoped_ptr<EvictionTilePriorityQueue> queue(
1136       host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
1137   EXPECT_FALSE(queue->IsEmpty());
1138
1139   tile_count = 0;
1140   all_tiles.clear();
1141   while (!queue->IsEmpty()) {
1142     EXPECT_TRUE(queue->Top().tile());
1143     all_tiles.insert(queue->Top().tile());
1144     ++tile_count;
1145     queue->Pop();
1146   }
1147   EXPECT_EQ(tile_count, all_tiles.size());
1148   EXPECT_EQ(16u, tile_count);
1149 }
1150
1151 TEST_F(TileManagerTilePriorityQueueTest,
1152        RasterTilePriorityQueueStaticViewport) {
1153   FakePictureLayerTilingClient client;
1154
1155   gfx::Rect viewport(50, 50, 500, 500);
1156   gfx::Size layer_bounds(1600, 1600);
1157
1158   float inset = PictureLayerTiling::CalculateSoonBorderDistance(viewport, 1.0f);
1159   gfx::Rect soon_rect = viewport;
1160   soon_rect.Inset(-inset, -inset);
1161
1162   client.SetTileSize(gfx::Size(30, 30));
1163   LayerTreeSettings settings;
1164   settings.max_tiles_for_interest_area = 10000;
1165
1166   scoped_ptr<PictureLayerTilingSet> tiling_set = PictureLayerTilingSet::Create(
1167       ACTIVE_TREE, &client, settings.max_tiles_for_interest_area,
1168       settings.skewport_target_time_in_seconds,
1169       settings.skewport_extrapolation_limit_in_content_pixels);
1170
1171   scoped_refptr<FakePicturePileImpl> pile =
1172       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
1173   PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, pile);
1174   tiling->set_resolution(HIGH_RESOLUTION);
1175
1176   tiling_set->UpdateTilePriorities(viewport, 1.0f, 1.0, Occlusion(), true);
1177   std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
1178   // Sanity check.
1179   EXPECT_EQ(3364u, all_tiles.size());
1180
1181   // The explanation of each iteration is as follows:
1182   // 1. First iteration tests that we can get all of the tiles correctly.
1183   // 2. Second iteration ensures that we can get all of the tiles again (first
1184   //    iteration didn't change any tiles), as well set all tiles to be ready to
1185   //    draw.
1186   // 3. Third iteration ensures that no tiles are returned, since they were all
1187   //    marked as ready to draw.
1188   for (int i = 0; i < 3; ++i) {
1189     scoped_ptr<TilingSetRasterQueueAll> queue(
1190         new TilingSetRasterQueueAll(tiling_set.get(), false));
1191
1192     // There are 3 bins in TilePriority.
1193     bool have_tiles[3] = {};
1194
1195     // On the third iteration, we should get no tiles since everything was
1196     // marked as ready to draw.
1197     if (i == 2) {
1198       EXPECT_TRUE(queue->IsEmpty());
1199       continue;
1200     }
1201
1202     EXPECT_FALSE(queue->IsEmpty());
1203     std::set<Tile*> unique_tiles;
1204     unique_tiles.insert(queue->Top().tile());
1205     PrioritizedTile last_tile = queue->Top();
1206     have_tiles[last_tile.priority().priority_bin] = true;
1207
1208     // On the second iteration, mark everything as ready to draw (solid color).
1209     if (i == 1) {
1210       TileDrawInfo& draw_info = last_tile.tile()->draw_info();
1211       draw_info.SetSolidColorForTesting(SK_ColorRED);
1212     }
1213     queue->Pop();
1214     int eventually_bin_order_correct_count = 0;
1215     int eventually_bin_order_incorrect_count = 0;
1216     while (!queue->IsEmpty()) {
1217       PrioritizedTile new_tile = queue->Top();
1218       queue->Pop();
1219       unique_tiles.insert(new_tile.tile());
1220
1221       TilePriority last_priority = last_tile.priority();
1222       TilePriority new_priority = new_tile.priority();
1223       EXPECT_LE(last_priority.priority_bin, new_priority.priority_bin);
1224       if (last_priority.priority_bin == new_priority.priority_bin) {
1225         if (last_priority.priority_bin == TilePriority::EVENTUALLY) {
1226           bool order_correct = last_priority.distance_to_visible <=
1227                                new_priority.distance_to_visible;
1228           eventually_bin_order_correct_count += order_correct;
1229           eventually_bin_order_incorrect_count += !order_correct;
1230         } else if (!soon_rect.Intersects(new_tile.tile()->content_rect()) &&
1231                    !soon_rect.Intersects(last_tile.tile()->content_rect())) {
1232           EXPECT_LE(last_priority.distance_to_visible,
1233                     new_priority.distance_to_visible);
1234           EXPECT_EQ(TilePriority::NOW, new_priority.priority_bin);
1235         } else if (new_priority.distance_to_visible > 0.f) {
1236           EXPECT_EQ(TilePriority::SOON, new_priority.priority_bin);
1237         }
1238       }
1239       have_tiles[new_priority.priority_bin] = true;
1240
1241       last_tile = new_tile;
1242
1243       // On the second iteration, mark everything as ready to draw (solid
1244       // color).
1245       if (i == 1) {
1246         TileDrawInfo& draw_info = last_tile.tile()->draw_info();
1247         draw_info.SetSolidColorForTesting(SK_ColorRED);
1248       }
1249     }
1250
1251     EXPECT_GT(eventually_bin_order_correct_count,
1252               eventually_bin_order_incorrect_count);
1253
1254     // We should have now and eventually tiles, as well as soon tiles from
1255     // the border region.
1256     EXPECT_TRUE(have_tiles[TilePriority::NOW]);
1257     EXPECT_TRUE(have_tiles[TilePriority::SOON]);
1258     EXPECT_TRUE(have_tiles[TilePriority::EVENTUALLY]);
1259
1260     EXPECT_EQ(unique_tiles.size(), all_tiles.size());
1261   }
1262 }
1263
1264 TEST_F(TileManagerTilePriorityQueueTest,
1265        RasterTilePriorityQueueMovingViewport) {
1266   FakePictureLayerTilingClient client;
1267
1268   gfx::Rect viewport(50, 0, 100, 100);
1269   gfx::Rect moved_viewport(50, 0, 100, 500);
1270   gfx::Size layer_bounds(1000, 1000);
1271
1272   client.SetTileSize(gfx::Size(30, 30));
1273   LayerTreeSettings settings;
1274   settings.max_tiles_for_interest_area = 10000;
1275
1276   scoped_ptr<PictureLayerTilingSet> tiling_set = PictureLayerTilingSet::Create(
1277       ACTIVE_TREE, &client, settings.max_tiles_for_interest_area,
1278       settings.skewport_target_time_in_seconds,
1279       settings.skewport_extrapolation_limit_in_content_pixels);
1280
1281   scoped_refptr<FakePicturePileImpl> pile =
1282       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
1283   PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, pile);
1284   tiling->set_resolution(HIGH_RESOLUTION);
1285
1286   tiling_set->UpdateTilePriorities(viewport, 1.0f, 1.0, Occlusion(), true);
1287   tiling_set->UpdateTilePriorities(moved_viewport, 1.0f, 2.0, Occlusion(),
1288                                    true);
1289
1290   float inset =
1291       PictureLayerTiling::CalculateSoonBorderDistance(moved_viewport, 1.0f);
1292   gfx::Rect soon_rect = moved_viewport;
1293   soon_rect.Inset(-inset, -inset);
1294
1295   // There are 3 bins in TilePriority.
1296   bool have_tiles[3] = {};
1297   PrioritizedTile last_tile;
1298   int eventually_bin_order_correct_count = 0;
1299   int eventually_bin_order_incorrect_count = 0;
1300   scoped_ptr<TilingSetRasterQueueAll> queue(
1301       new TilingSetRasterQueueAll(tiling_set.get(), false));
1302   for (; !queue->IsEmpty(); queue->Pop()) {
1303     if (!last_tile.tile())
1304       last_tile = queue->Top();
1305
1306     const PrioritizedTile& new_tile = queue->Top();
1307
1308     TilePriority last_priority = last_tile.priority();
1309     TilePriority new_priority = new_tile.priority();
1310
1311     have_tiles[new_priority.priority_bin] = true;
1312
1313     EXPECT_LE(last_priority.priority_bin, new_priority.priority_bin);
1314     if (last_priority.priority_bin == new_priority.priority_bin) {
1315       if (last_priority.priority_bin == TilePriority::EVENTUALLY) {
1316         bool order_correct = last_priority.distance_to_visible <=
1317                              new_priority.distance_to_visible;
1318         eventually_bin_order_correct_count += order_correct;
1319         eventually_bin_order_incorrect_count += !order_correct;
1320       } else if (!soon_rect.Intersects(new_tile.tile()->content_rect()) &&
1321                  !soon_rect.Intersects(last_tile.tile()->content_rect())) {
1322         EXPECT_LE(last_priority.distance_to_visible,
1323                   new_priority.distance_to_visible);
1324       } else if (new_priority.distance_to_visible > 0.f) {
1325         EXPECT_EQ(TilePriority::SOON, new_priority.priority_bin);
1326       }
1327     }
1328     last_tile = new_tile;
1329   }
1330
1331   EXPECT_GT(eventually_bin_order_correct_count,
1332             eventually_bin_order_incorrect_count);
1333
1334   EXPECT_TRUE(have_tiles[TilePriority::NOW]);
1335   EXPECT_TRUE(have_tiles[TilePriority::SOON]);
1336   EXPECT_TRUE(have_tiles[TilePriority::EVENTUALLY]);
1337 }
1338
1339 TEST_F(TileManagerTilePriorityQueueTest, SetIsLikelyToRequireADraw) {
1340   const gfx::Size layer_bounds(1000, 1000);
1341   host_impl_.SetViewportSize(layer_bounds);
1342   SetupDefaultTrees(layer_bounds);
1343
1344   // Verify that the queue has a required for draw tile at Top.
1345   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
1346       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
1347   EXPECT_FALSE(queue->IsEmpty());
1348   EXPECT_TRUE(queue->Top().tile()->required_for_draw());
1349
1350   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
1351   host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
1352   EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
1353 }
1354
1355 TEST_F(TileManagerTilePriorityQueueTest,
1356        SetIsLikelyToRequireADrawOnZeroMemoryBudget) {
1357   const gfx::Size layer_bounds(1000, 1000);
1358   host_impl_.SetViewportSize(layer_bounds);
1359   SetupDefaultTrees(layer_bounds);
1360
1361   // Verify that the queue has a required for draw tile at Top.
1362   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
1363       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
1364   EXPECT_FALSE(queue->IsEmpty());
1365   EXPECT_TRUE(queue->Top().tile()->required_for_draw());
1366
1367   ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
1368   policy.bytes_limit_when_visible = 0;
1369   host_impl_.SetMemoryPolicy(policy);
1370
1371   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
1372   host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
1373   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
1374 }
1375
1376 TEST_F(TileManagerTilePriorityQueueTest,
1377        SetIsLikelyToRequireADrawOnLimitedMemoryBudget) {
1378   const gfx::Size layer_bounds(1000, 1000);
1379   host_impl_.SetViewportSize(layer_bounds);
1380   SetupDefaultTrees(layer_bounds);
1381
1382   // Verify that the queue has a required for draw tile at Top.
1383   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
1384       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
1385   EXPECT_FALSE(queue->IsEmpty());
1386   EXPECT_TRUE(queue->Top().tile()->required_for_draw());
1387   EXPECT_EQ(gfx::Size(256, 256), queue->Top().tile()->desired_texture_size());
1388   EXPECT_EQ(RGBA_8888, host_impl_.resource_provider()->best_texture_format());
1389
1390   ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
1391   policy.bytes_limit_when_visible =
1392       Resource::UncheckedMemorySizeBytes(gfx::Size(256, 256), RGBA_8888);
1393   host_impl_.SetMemoryPolicy(policy);
1394
1395   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
1396   host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
1397   EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
1398
1399   scoped_ptr<ScopedResource> resource =
1400       host_impl_.resource_pool()->AcquireResource(gfx::Size(256, 256),
1401                                                   RGBA_8888);
1402
1403   host_impl_.tile_manager()->CheckIfMoreTilesNeedToBePreparedForTesting();
1404   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
1405
1406   host_impl_.resource_pool()->ReleaseResource(resource.Pass(), 0);
1407 }
1408
1409 TEST_F(TileManagerTilePriorityQueueTest, RasterQueueAllUsesCorrectTileBounds) {
1410   // Verify that we use the real tile bounds when advancing phases during the
1411   // tile iteration.
1412   gfx::Size layer_bounds(1, 1);
1413
1414   scoped_refptr<FakePicturePileImpl> pile =
1415       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
1416
1417   FakePictureLayerTilingClient pending_client;
1418   pending_client.SetTileSize(gfx::Size(64, 64));
1419
1420   auto tiling_set = PictureLayerTilingSet::Create(
1421       WhichTree::ACTIVE_TREE, &pending_client, 1.0f, 1.0f, 1000);
1422   pending_client.set_twin_tiling_set(tiling_set.get());
1423
1424   auto tiling = tiling_set->AddTiling(1.0f, pile);
1425
1426   tiling->CreateAllTilesForTesting();
1427   tiling->set_resolution(HIGH_RESOLUTION);
1428
1429   // The tile is (0, 0, 1, 1), create an intersecting and non-intersecting
1430   // rectangle to test the advance phase with. The tile size is (64, 64), so
1431   // both rectangles intersect the tile content size, but only one should
1432   // intersect the actual size.
1433   gfx::Rect non_intersecting_rect(2, 2, 10, 10);
1434   gfx::Rect intersecting_rect(0, 0, 10, 10);
1435   {
1436     tiling->SetTilePriorityRectsForTesting(
1437         non_intersecting_rect,  // Visible rect.
1438         intersecting_rect,      // Skewport rect.
1439         intersecting_rect,      // Soon rect.
1440         intersecting_rect);     // Eventually rect.
1441     scoped_ptr<TilingSetRasterQueueAll> queue(
1442         new TilingSetRasterQueueAll(tiling_set.get(), false));
1443     EXPECT_FALSE(queue->IsEmpty());
1444   }
1445   {
1446     tiling->SetTilePriorityRectsForTesting(
1447         non_intersecting_rect,  // Visible rect.
1448         non_intersecting_rect,  // Skewport rect.
1449         intersecting_rect,      // Soon rect.
1450         intersecting_rect);     // Eventually rect.
1451     scoped_ptr<TilingSetRasterQueueAll> queue(
1452         new TilingSetRasterQueueAll(tiling_set.get(), false));
1453     EXPECT_FALSE(queue->IsEmpty());
1454   }
1455   {
1456     tiling->SetTilePriorityRectsForTesting(
1457         non_intersecting_rect,  // Visible rect.
1458         non_intersecting_rect,  // Skewport rect.
1459         non_intersecting_rect,  // Soon rect.
1460         intersecting_rect);     // Eventually rect.
1461     scoped_ptr<TilingSetRasterQueueAll> queue(
1462         new TilingSetRasterQueueAll(tiling_set.get(), false));
1463     EXPECT_FALSE(queue->IsEmpty());
1464   }
1465 }
1466
1467 class TileManagerTest : public testing::Test {
1468  public:
1469   TileManagerTest()
1470       : host_impl_(&proxy_, &shared_bitmap_manager_, &task_graph_runner_) {}
1471
1472  protected:
1473   // MockLayerTreeHostImpl allows us to intercept tile manager callbacks.
1474   class MockLayerTreeHostImpl : public FakeLayerTreeHostImpl {
1475    public:
1476     MockLayerTreeHostImpl(Proxy* proxy,
1477                           SharedBitmapManager* manager,
1478                           TaskGraphRunner* task_graph_runner)
1479         : FakeLayerTreeHostImpl(proxy, manager, task_graph_runner) {
1480       InitializeRenderer(FakeOutputSurface::Create3d());
1481     }
1482
1483     MOCK_METHOD0(NotifyAllTileTasksCompleted, void());
1484   };
1485
1486   TestSharedBitmapManager shared_bitmap_manager_;
1487   TestTaskGraphRunner task_graph_runner_;
1488   FakeImplProxy proxy_;
1489   MockLayerTreeHostImpl host_impl_;
1490 };
1491
1492 // Test to ensure that we call NotifyAllTileTasksCompleted when PrepareTiles is
1493 // called.
1494 TEST_F(TileManagerTest, AllWorkFinishedTest) {
1495   // Check with no tile work enqueued.
1496   {
1497     base::RunLoop run_loop;
1498     EXPECT_FALSE(host_impl_.tile_manager()->HasScheduledTileTasksForTesting());
1499     EXPECT_CALL(host_impl_, NotifyAllTileTasksCompleted())
1500         .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
1501     host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
1502     EXPECT_TRUE(host_impl_.tile_manager()->HasScheduledTileTasksForTesting());
1503     run_loop.Run();
1504   }
1505
1506   // Check that the "schedule more work" path also triggers the expected
1507   // callback.
1508   {
1509     base::RunLoop run_loop;
1510     EXPECT_FALSE(host_impl_.tile_manager()->HasScheduledTileTasksForTesting());
1511     EXPECT_CALL(host_impl_, NotifyAllTileTasksCompleted())
1512         .WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
1513     host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
1514     host_impl_.tile_manager()->SetMoreTilesNeedToBeRasterizedForTesting();
1515     EXPECT_TRUE(host_impl_.tile_manager()->HasScheduledTileTasksForTesting());
1516     run_loop.Run();
1517   }
1518 }
1519
1520 }  // namespace
1521 }  // namespace cc