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