cc/resources/tile_manager_unittest.cc

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