cc: Separate the priority from the tile and put in new PrioritizedTile

cc/resources/tile_manager_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/thread_task_runner_handle.h"
 #include "cc/resources/eviction_tile_priority_queue.h"
 #include "cc/resources/raster_tile_priority_queue.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_priority.h"
@@ skipping 148 matching lines @@
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
 
   size_t tile_count = 0;
   std::set<Tile*> all_tiles;
   while (!queue->IsEmpty()) {
-    EXPECT_TRUE(queue->Top());
-    all_tiles.insert(queue->Top());
+    EXPECT_TRUE(queue->Top().tile());
+    all_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 
   // Sanity check, all tiles should be visible.
   std::set<Tile*> smoothness_tiles;
   queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
                                       RasterTilePriorityQueue::Type::ALL);
   bool had_low_res = false;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile);
-    EXPECT_EQ(TilePriority::NOW, tile->priority().priority_bin);
-    if (tile->priority().resolution == LOW_RESOLUTION)
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile());
+    EXPECT_EQ(TilePriority::NOW, prioritized_tile.priority().priority_bin);
+    if (prioritized_tile.priority().resolution == LOW_RESOLUTION)
       had_low_res = true;
     else
-      smoothness_tiles.insert(tile);
+      smoothness_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(all_tiles, smoothness_tiles);
   EXPECT_TRUE(had_low_res);
 
   // Check that everything is required for activation.
   queue = host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
   std::set<Tile*> required_for_activation_tiles;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile->required_for_activation());
-    required_for_activation_tiles.insert(tile);
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
+    required_for_activation_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(all_tiles, required_for_activation_tiles);
 
   // Check that everything is required for draw.
   queue = host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
   std::set<Tile*> required_for_draw_tiles;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile->required_for_draw());
-    required_for_draw_tiles.insert(tile);
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
+    required_for_draw_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(all_tiles, required_for_draw_tiles);
 
   Region invalidation(gfx::Rect(0, 0, 500, 500));
 
   // Invalidate the pending tree.
   pending_layer_->set_invalidation(invalidation);
   pending_layer_->HighResTiling()->Invalidate(invalidation);
   pending_layer_->LowResTiling()->Invalidate(invalidation);
 
-  active_layer_->ResetAllTilesPriorities();
-  pending_layer_->ResetAllTilesPriorities();
-
   // Renew all of the tile priorities.
   gfx::Rect viewport(50, 50, 100, 100);
   pending_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                             Occlusion());
   pending_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                            Occlusion());
   active_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                            Occlusion());
   active_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                           Occlusion());
@@ skipping 18 matching lines @@
   for (size_t i = 0; i < active_high_res_tiles.size(); ++i) {
     all_tiles.insert(active_high_res_tiles[i]);
     high_res_tiles.insert(active_high_res_tiles[i]);
   }
 
   std::vector<Tile*> active_low_res_tiles =
       active_layer_->LowResTiling()->AllTilesForTesting();
   for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
     all_tiles.insert(active_low_res_tiles[i]);
 
-  Tile* last_tile = NULL;
+  PrioritizedTile last_tile;
   smoothness_tiles.clear();
   tile_count = 0;
   size_t correct_order_tiles = 0u;
   // Here we expect to get increasing ACTIVE_TREE priority_bin.
   queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
                                       RasterTilePriorityQueue::Type::ALL);
   std::set<Tile*> expected_required_for_draw_tiles;
   std::set<Tile*> expected_required_for_activation_tiles;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile);
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile());
 
-    if (!last_tile)
-      last_tile = tile;
+    if (!last_tile.tile())
+      last_tile = prioritized_tile;
 
-    EXPECT_LE(last_tile->priority().priority_bin,
-              tile->priority().priority_bin);
+    EXPECT_LE(last_tile.priority().priority_bin,
+              prioritized_tile.priority().priority_bin);
     bool skip_updating_last_tile = false;
-    if (last_tile->priority().priority_bin == tile->priority().priority_bin) {
-      correct_order_tiles += last_tile->priority().distance_to_visible <=
-                             tile->priority().distance_to_visible;
-    } else if (tile->priority().priority_bin == TilePriority::NOW) {
+    if (last_tile.priority().priority_bin ==
+        prioritized_tile.priority().priority_bin) {
+      correct_order_tiles += last_tile.priority().distance_to_visible <=
+                             prioritized_tile.priority().distance_to_visible;
+    } else if (prioritized_tile.priority().priority_bin == TilePriority::NOW) {
       // Since we'd return pending tree now tiles before the eventually tiles on
       // the active tree, update the value.
       ++correct_order_tiles;
       skip_updating_last_tile = true;
     }
 
-    if (tile->priority().priority_bin == TilePriority::NOW &&
-        last_tile->priority().resolution != tile->priority().resolution) {
+    if (prioritized_tile.priority().priority_bin == TilePriority::NOW &&
+        last_tile.priority().resolution !=
+            prioritized_tile.priority().resolution) {
       // Low resolution should come first.
-      EXPECT_EQ(LOW_RESOLUTION, last_tile->priority().resolution);
+      EXPECT_EQ(LOW_RESOLUTION, last_tile.priority().resolution);
     }
 
     if (!skip_updating_last_tile)
-      last_tile = tile;
+      last_tile = prioritized_tile;
     ++tile_count;
-    smoothness_tiles.insert(tile);
-    if (tile->required_for_draw())
-      expected_required_for_draw_tiles.insert(tile);
-    if (tile->required_for_activation())
-      expected_required_for_activation_tiles.insert(tile);
+    smoothness_tiles.insert(prioritized_tile.tile());
+    if (prioritized_tile.tile()->required_for_draw())
+      expected_required_for_draw_tiles.insert(prioritized_tile.tile());
+    if (prioritized_tile.tile()->required_for_activation())
+      expected_required_for_activation_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, smoothness_tiles.size());
   EXPECT_EQ(all_tiles, smoothness_tiles);
   // Since we don't guarantee increasing distance due to spiral iterator, we
   // should check that we're _mostly_ right.
   EXPECT_GT(correct_order_tiles, 3 * tile_count / 4);
 
   // Check that we have consistent required_for_activation tiles.
   queue = host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
   required_for_activation_tiles.clear();
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile->required_for_activation());
-    required_for_activation_tiles.insert(tile);
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
+    required_for_activation_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(expected_required_for_activation_tiles,
             required_for_activation_tiles);
   EXPECT_NE(all_tiles, required_for_activation_tiles);
 
   // Check that we have consistent required_for_draw tiles.
   queue = host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
   required_for_draw_tiles.clear();
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile->required_for_draw());
-    required_for_draw_tiles.insert(tile);
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
+    required_for_draw_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
   EXPECT_NE(all_tiles, required_for_draw_tiles);
 
   std::set<Tile*> new_content_tiles;
-  last_tile = NULL;
+  last_tile = PrioritizedTile();
   size_t increasing_distance_tiles = 0u;
   // Here we expect to get increasing PENDING_TREE priority_bin.
   queue = host_impl_.BuildRasterQueue(NEW_CONTENT_TAKES_PRIORITY,
                                       RasterTilePriorityQueue::Type::ALL);
   tile_count = 0;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile);
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile());
 
-    if (!last_tile)
-      last_tile = tile;
+    if (!last_tile.tile())
+      last_tile = prioritized_tile;
 
-    EXPECT_LE(last_tile->priority().priority_bin,
-              tile->priority().priority_bin);
-    if (last_tile->priority().priority_bin == tile->priority().priority_bin) {
-      increasing_distance_tiles += last_tile->priority().distance_to_visible <=
-                                   tile->priority().distance_to_visible;
+    EXPECT_LE(last_tile.priority().priority_bin,
+              prioritized_tile.priority().priority_bin);
+    if (last_tile.priority().priority_bin ==
+        prioritized_tile.priority().priority_bin) {
+      increasing_distance_tiles +=
+          last_tile.priority().distance_to_visible <=
+          prioritized_tile.priority().distance_to_visible;
     }
 
-    if (tile->priority().priority_bin == TilePriority::NOW &&
-        last_tile->priority().resolution != tile->priority().resolution) {
+    if (prioritized_tile.priority().priority_bin == TilePriority::NOW &&
+        last_tile.priority().resolution !=
+            prioritized_tile.priority().resolution) {
       // High resolution should come first.
-      EXPECT_EQ(HIGH_RESOLUTION, last_tile->priority().resolution);
+      EXPECT_EQ(HIGH_RESOLUTION, last_tile.priority().resolution);
     }
 
-    last_tile = tile;
-    new_content_tiles.insert(tile);
+    last_tile = prioritized_tile;
+    new_content_tiles.insert(prioritized_tile.tile());
     ++tile_count;
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(high_res_tiles, new_content_tiles);
   // Since we don't guarantee increasing distance due to spiral iterator, we
   // should check that we're _mostly_ right.
   EXPECT_GE(increasing_distance_tiles, 3 * tile_count / 4);
 
   // Check that we have consistent required_for_activation tiles.
   queue = host_impl_.BuildRasterQueue(
       NEW_CONTENT_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
   required_for_activation_tiles.clear();
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile->required_for_activation());
-    required_for_activation_tiles.insert(tile);
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
+    required_for_activation_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(expected_required_for_activation_tiles,
             required_for_activation_tiles);
   EXPECT_NE(new_content_tiles, required_for_activation_tiles);
 
   // Check that we have consistent required_for_draw tiles.
   queue = host_impl_.BuildRasterQueue(
       NEW_CONTENT_TAKES_PRIORITY,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
   required_for_draw_tiles.clear();
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile->required_for_draw());
-    required_for_draw_tiles.insert(tile);
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
+    required_for_draw_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
   EXPECT_NE(new_content_tiles, required_for_draw_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        RasterTilePriorityQueueHighNonIdealTilings) {
   const gfx::Size layer_bounds(1000, 1000);
   const gfx::Size viewport(800, 800);
@@ skipping 26 matching lines @@
     PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
     if (tiling->contents_scale() == 1.5f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
       // Non ideal tilings with a high res pending twin have to be processed
       // because of possible activation tiles.
       if (tiling->contents_scale() == 1.f) {
-        tiling->UpdateAllTilePrioritiesForTesting();
+        tiling->UpdateAndGetAllPrioritizedTilesForTesting();
         const auto& all_tiles = tiling->AllTilesForTesting();
         for (auto* tile : all_tiles)
           EXPECT_TRUE(tile->required_for_activation());
         all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
       }
     }
   }
 
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
 
   size_t tile_count = 0;
   std::set<Tile*> all_actual_tiles;
   while (!queue->IsEmpty()) {
-    EXPECT_TRUE(queue->Top());
-    all_actual_tiles.insert(queue->Top());
+    EXPECT_TRUE(queue->Top().tile());
+    all_actual_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, all_actual_tiles.size());
   EXPECT_EQ(all_expected_tiles.size(), all_actual_tiles.size());
   EXPECT_EQ(all_expected_tiles, all_actual_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueInvalidation) {
@@ skipping 64 matching lines @@
   // Expect 15 shared tiles and 1 unshared tile.
   EXPECT_EQ(17u, expected_all_tiles.size());
 
   // The actual test will now build different queues and verify that the queues
   // return the same information as computed manually above.
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   std::set<Tile*> actual_now_tiles;
   std::set<Tile*> actual_all_tiles;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
+    PrioritizedTile prioritized_tile = queue->Top();
     queue->Pop();
-    if (tile->priority().priority_bin == TilePriority::NOW)
-      actual_now_tiles.insert(tile);
-    actual_all_tiles.insert(tile);
+    if (prioritized_tile.priority().priority_bin == TilePriority::NOW)
+      actual_now_tiles.insert(prioritized_tile.tile());
+    actual_all_tiles.insert(prioritized_tile.tile());
   }
   EXPECT_EQ(expected_now_tiles, actual_now_tiles);
   EXPECT_EQ(expected_all_tiles, actual_all_tiles);
 
   queue = host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
   std::set<Tile*> actual_required_for_draw_tiles;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
+    PrioritizedTile prioritized_tile = queue->Top();
     queue->Pop();
-    actual_required_for_draw_tiles.insert(tile);
+    actual_required_for_draw_tiles.insert(prioritized_tile.tile());
   }
   EXPECT_EQ(expected_required_for_draw_tiles, actual_required_for_draw_tiles);
 
   queue = host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
   std::set<Tile*> actual_required_for_activation_tiles;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
+    Tile* tile = queue->Top().tile();
     queue->Pop();
     actual_required_for_activation_tiles.insert(tile);
   }
   EXPECT_EQ(expected_required_for_activation_tiles,
             actual_required_for_activation_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, ActivationComesBeforeEventually) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
@@ skipping 24 matching lines @@
 
   host_impl_.SetRequiresHighResToDraw();
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
 
   // Get all the tiles that are NOW or SOON and make sure they are ready to
   // draw.
   std::vector<Tile*> all_tiles;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    if (tile->priority().priority_bin >= TilePriority::EVENTUALLY)
+    PrioritizedTile prioritized_tile = queue->Top();
+    if (prioritized_tile.priority().priority_bin >= TilePriority::EVENTUALLY)
       break;
 
-    all_tiles.push_back(tile);
+    all_tiles.push_back(prioritized_tile.tile());
     queue->Pop();
   }
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   // Ensure we can activate.
   EXPECT_TRUE(tile_manager()->IsReadyToActivate());
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   scoped_ptr<EvictionTilePriorityQueue> empty_queue(
       host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
   EXPECT_TRUE(empty_queue->IsEmpty());
   std::set<Tile*> all_tiles;
   size_t tile_count = 0;
 
   scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   while (!raster_queue->IsEmpty()) {
     ++tile_count;
-    EXPECT_TRUE(raster_queue->Top());
-    all_tiles.insert(raster_queue->Top());
+    EXPECT_TRUE(raster_queue->Top().tile());
+    all_tiles.insert(raster_queue->Top().tile());
     raster_queue->Pop();
   }
 
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   scoped_ptr<EvictionTilePriorityQueue> queue(
       host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY));
   EXPECT_FALSE(queue->IsEmpty());
 
   // Sanity check, all tiles should be visible.
   std::set<Tile*> smoothness_tiles;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    EXPECT_TRUE(tile);
-    EXPECT_EQ(TilePriority::NOW, tile->priority().priority_bin);
-    EXPECT_TRUE(tile->HasResource());
-    smoothness_tiles.insert(tile);
+    PrioritizedTile prioritized_tile = queue->Top();
+    EXPECT_TRUE(prioritized_tile.tile());
+    EXPECT_EQ(TilePriority::NOW, prioritized_tile.priority().priority_bin);
+    EXPECT_TRUE(prioritized_tile.tile()->HasResource());
+    smoothness_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
   EXPECT_EQ(all_tiles, smoothness_tiles);
 
   tile_manager()->ReleaseTileResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   Region invalidation(gfx::Rect(0, 0, 500, 500));
 
   // Invalidate the pending tree.
   pending_layer_->set_invalidation(invalidation);
   pending_layer_->HighResTiling()->Invalidate(invalidation);
   pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
   pending_layer_->LowResTiling()->Invalidate(invalidation);
   pending_layer_->LowResTiling()->CreateMissingTilesInLiveTilesRect();
 
-  active_layer_->ResetAllTilesPriorities();
-  pending_layer_->ResetAllTilesPriorities();
-
   // Renew all of the tile priorities.
   gfx::Rect viewport(50, 50, 100, 100);
   pending_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                             Occlusion());
   pending_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                            Occlusion());
   active_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                            Occlusion());
   active_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                           Occlusion());
@@ skipping 16 matching lines @@
     all_tiles.insert(active_high_res_tiles[i]);
 
   std::vector<Tile*> active_low_res_tiles =
       active_layer_->LowResTiling()->AllTilesForTesting();
   for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
     all_tiles.insert(active_low_res_tiles[i]);
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
-  Tile* last_tile = NULL;
+  PrioritizedTile last_tile;
   smoothness_tiles.clear();
   tile_count = 0;
   // Here we expect to get increasing combined priority_bin.
   queue = host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY);
   int distance_increasing = 0;
   int distance_decreasing = 0;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
+    PrioritizedTile prioritized_tile = queue->Top();
+    Tile* tile = prioritized_tile.tile();
     EXPECT_TRUE(tile);
     EXPECT_TRUE(tile->HasResource());
 
-    if (!last_tile)
-      last_tile = tile;
+    if (!last_tile.tile())
+      last_tile = prioritized_tile;
 
-    const TilePriority& last_priority = last_tile->priority();
-    const TilePriority& priority = tile->priority();
+    const TilePriority& last_priority = last_tile.priority();
+    const TilePriority& priority = prioritized_tile.priority();
 
     EXPECT_GE(last_priority.priority_bin, priority.priority_bin);
     if (last_priority.priority_bin == priority.priority_bin) {
-      EXPECT_LE(last_tile->required_for_activation(),
+      EXPECT_LE(last_tile.tile()->required_for_activation(),
                 tile->required_for_activation());
-      if (last_tile->required_for_activation() ==
+      if (last_tile.tile()->required_for_activation() ==
           tile->required_for_activation()) {
         if (last_priority.distance_to_visible >= priority.distance_to_visible)
           ++distance_decreasing;
         else
           ++distance_increasing;
       }
     }
 
-    last_tile = tile;
+    last_tile = prioritized_tile;
     ++tile_count;
     smoothness_tiles.insert(tile);
     queue->Pop();
   }
 
   // Ensure that the distance is decreasing many more times than increasing.
   EXPECT_EQ(3, distance_increasing);
   EXPECT_EQ(17, distance_decreasing);
   EXPECT_EQ(tile_count, smoothness_tiles.size());
   EXPECT_EQ(all_tiles, smoothness_tiles);
 
   std::set<Tile*> new_content_tiles;
-  last_tile = NULL;
+  last_tile = PrioritizedTile();
   // Again, we expect to get increasing combined priority_bin.
   queue = host_impl_.BuildEvictionQueue(NEW_CONTENT_TAKES_PRIORITY);
   distance_decreasing = 0;
   distance_increasing = 0;
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
+    PrioritizedTile prioritized_tile = queue->Top();
+    Tile* tile = prioritized_tile.tile();
     EXPECT_TRUE(tile);
 
-    if (!last_tile)
-      last_tile = tile;
+    if (!last_tile.tile())
+      last_tile = prioritized_tile;
 
-    const TilePriority& last_priority = last_tile->priority();
-    const TilePriority& priority = tile->priority();
+    const TilePriority& last_priority = last_tile.priority();
+    const TilePriority& priority = prioritized_tile.priority();
 
     EXPECT_GE(last_priority.priority_bin, priority.priority_bin);
     if (last_priority.priority_bin == priority.priority_bin) {
-      EXPECT_LE(last_tile->required_for_activation(),
+      EXPECT_LE(last_tile.tile()->required_for_activation(),
                 tile->required_for_activation());
-      if (last_tile->required_for_activation() ==
+      if (last_tile.tile()->required_for_activation() ==
           tile->required_for_activation()) {
         if (last_priority.distance_to_visible >= priority.distance_to_visible)
           ++distance_decreasing;
         else
           ++distance_increasing;
       }
     }
 
-    last_tile = tile;
+    last_tile = prioritized_tile;
     new_content_tiles.insert(tile);
     queue->Pop();
   }
 
   // Ensure that the distance is decreasing many more times than increasing.
   EXPECT_EQ(3, distance_increasing);
   EXPECT_EQ(17, distance_decreasing);
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(all_tiles, new_content_tiles);
 }
@@ skipping 34 matching lines @@
 
   FakePictureLayerImpl* active_child_layer =
       static_cast<FakePictureLayerImpl*>(active_layer_->children()[0]);
 
   std::set<Tile*> all_tiles;
   size_t tile_count = 0;
   scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   while (!raster_queue->IsEmpty()) {
     ++tile_count;
-    EXPECT_TRUE(raster_queue->Top());
-    all_tiles.insert(raster_queue->Top());
+    EXPECT_TRUE(raster_queue->Top().tile());
+    all_tiles.insert(raster_queue->Top().tile());
     raster_queue->Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(32u, tile_count);
 
-  pending_layer_->ResetAllTilesPriorities();
-
   // Renew all of the tile priorities.
   gfx::Rect viewport(layer_bounds);
   pending_layer_->HighResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                             Occlusion());
   pending_layer_->LowResTiling()->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                            Occlusion());
   pending_child_layer->HighResTiling()->ComputeTilePriorityRects(
       viewport, 1.0f, 1.0, Occlusion());
   pending_child_layer->LowResTiling()->ComputeTilePriorityRects(
       viewport, 1.0f, 1.0, Occlusion());
@@ skipping 32 matching lines @@
   active_child_layer->LowResTiling()->SetAllTilesOccludedForTesting();
   all_tiles.insert(pending_child_low_res_tiles.begin(),
                    pending_child_low_res_tiles.end());
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   // Verify occlusion is considered by EvictionTilePriorityQueue.
   TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
   size_t occluded_count = 0u;
-  Tile* last_tile = NULL;
+  PrioritizedTile last_tile;
   scoped_ptr<EvictionTilePriorityQueue> queue(
       host_impl_.BuildEvictionQueue(tree_priority));
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    if (!last_tile)
-      last_tile = tile;
+    PrioritizedTile prioritized_tile = queue->Top();
+    if (!last_tile.tile())
+      last_tile = prioritized_tile;
 
-    bool tile_is_occluded = tile->is_occluded();
+    bool tile_is_occluded = prioritized_tile.is_occluded();
 
     // The only way we will encounter an occluded tile after an unoccluded
     // tile is if the priorty bin decreased, the tile is required for
     // activation, or the scale changed.
     if (tile_is_occluded) {
       occluded_count++;
 
-      bool last_tile_is_occluded = last_tile->is_occluded();
+      bool last_tile_is_occluded = last_tile.is_occluded();
       if (!last_tile_is_occluded) {
         TilePriority::PriorityBin tile_priority_bin =
-            tile->priority().priority_bin;
+            prioritized_tile.priority().priority_bin;
         TilePriority::PriorityBin last_tile_priority_bin =
-            last_tile->priority().priority_bin;
+            last_tile.priority().priority_bin;
 
         EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) ||
-                    tile->required_for_activation() ||
-                    (tile->contents_scale() != last_tile->contents_scale()));
+                    prioritized_tile.tile()->required_for_activation() ||
+                    (prioritized_tile.tile()->contents_scale() !=
+                     last_tile.tile()->contents_scale()));
       }
     }
-    last_tile = tile;
+    last_tile = prioritized_tile;
     queue->Pop();
   }
   size_t expected_occluded_count =
       pending_child_high_res_tiles.size() + pending_child_low_res_tiles.size();
   EXPECT_EQ(expected_occluded_count, occluded_count);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        EvictionTilePriorityQueueWithTransparentLayer) {
   base::TimeTicks time_ticks;
@@ skipping 81 matching lines @@
 
   // Verify that eviction queue returns tiles also from layers without valid
   // tile priorities and that the tile priority bin of those tiles is (at most)
   // EVENTUALLY.
   TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
   std::set<Tile*> new_content_tiles;
   size_t tile_count = 0;
   scoped_ptr<EvictionTilePriorityQueue> queue(
       host_impl_.BuildEvictionQueue(tree_priority));
   while (!queue->IsEmpty()) {
-    Tile* tile = queue->Top();
-    const TilePriority& pending_priority = tile->priority();
+    PrioritizedTile prioritized_tile = queue->Top();
+    Tile* tile = prioritized_tile.tile();
+    const TilePriority& pending_priority = prioritized_tile.priority();
     EXPECT_NE(std::numeric_limits<float>::infinity(),
               pending_priority.distance_to_visible);
     if (all_pending_child_tiles.find(tile) != all_pending_child_tiles.end())
       EXPECT_EQ(TilePriority::EVENTUALLY, pending_priority.priority_bin);
     else
       EXPECT_EQ(TilePriority::NOW, pending_priority.priority_bin);
     new_content_tiles.insert(tile);
     ++tile_count;
     queue->Pop();
   }
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(all_tiles, new_content_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
 
   size_t tile_count = 0;
   std::set<Tile*> all_tiles;
   while (!queue->IsEmpty()) {
-    EXPECT_TRUE(queue->Top());
-    all_tiles.insert(queue->Top());
+    EXPECT_TRUE(queue->Top().tile());
+    all_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 
   for (int i = 1; i < 10; ++i) {
     scoped_ptr<FakePictureLayerImpl> pending_layer =
         FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
     pending_layer->SetDrawsContent(true);
     pending_layer->set_has_valid_tile_priorities(true);
     pending_layer_->AddChild(pending_layer.Pass());
   }
 
   queue = host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
                                       RasterTilePriorityQueue::Type::ALL);
   EXPECT_FALSE(queue->IsEmpty());
 
   tile_count = 0;
   all_tiles.clear();
   while (!queue->IsEmpty()) {
-    EXPECT_TRUE(queue->Top());
-    all_tiles.insert(queue->Top());
+    EXPECT_TRUE(queue->Top().tile());
+    all_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(raster_queue->IsEmpty());
 
   size_t tile_count = 0;
   std::set<Tile*> all_tiles;
   while (!raster_queue->IsEmpty()) {
-    EXPECT_TRUE(raster_queue->Top());
-    all_tiles.insert(raster_queue->Top());
+    EXPECT_TRUE(raster_queue->Top().tile());
+    all_tiles.insert(raster_queue->Top().tile());
     ++tile_count;
     raster_queue->Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 
   std::vector<Tile*> tiles(all_tiles.begin(), all_tiles.end());
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 
   for (int i = 1; i < 10; ++i) {
     scoped_ptr<FakePictureLayerImpl> pending_layer =
         FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
     pending_layer->SetDrawsContent(true);
     pending_layer->set_has_valid_tile_priorities(true);
     pending_layer_->AddChild(pending_layer.Pass());
   }
 
   scoped_ptr<EvictionTilePriorityQueue> queue(
       host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
   EXPECT_FALSE(queue->IsEmpty());
 
   tile_count = 0;
   all_tiles.clear();
   while (!queue->IsEmpty()) {
-    EXPECT_TRUE(queue->Top());
-    all_tiles.insert(queue->Top());
+    EXPECT_TRUE(queue->Top().tile());
+    all_tiles.insert(queue->Top().tile());
     ++tile_count;
     queue->Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        RasterTilePriorityQueueStaticViewport) {
   FakePictureLayerTilingClient client;
@@ skipping 40 matching lines @@
 
     // On the third iteration, we should get no tiles since everything was
     // marked as ready to draw.
     if (i == 2) {
       EXPECT_TRUE(queue->IsEmpty());
       continue;
     }
 
     EXPECT_FALSE(queue->IsEmpty());
     std::set<Tile*> unique_tiles;
-    unique_tiles.insert(queue->Top());
-    Tile* last_tile = queue->Top();
-    have_tiles[last_tile->priority().priority_bin] = true;
+    unique_tiles.insert(queue->Top().tile());
+    PrioritizedTile last_tile = queue->Top();
+    have_tiles[last_tile.priority().priority_bin] = true;
 
     // On the second iteration, mark everything as ready to draw (solid color).
     if (i == 1) {
-      TileDrawInfo& draw_info = last_tile->draw_info();
+      TileDrawInfo& draw_info = last_tile.tile()->draw_info();
       draw_info.SetSolidColorForTesting(SK_ColorRED);
     }
     queue->Pop();
     int eventually_bin_order_correct_count = 0;
     int eventually_bin_order_incorrect_count = 0;
     while (!queue->IsEmpty()) {
-      Tile* new_tile = queue->Top();
+      PrioritizedTile new_tile = queue->Top();
       queue->Pop();
-      unique_tiles.insert(new_tile);
+      unique_tiles.insert(new_tile.tile());
 
-      TilePriority last_priority = last_tile->priority();
-      TilePriority new_priority = new_tile->priority();
+      TilePriority last_priority = last_tile.priority();
+      TilePriority new_priority = new_tile.priority();
       EXPECT_LE(last_priority.priority_bin, new_priority.priority_bin);
       if (last_priority.priority_bin == new_priority.priority_bin) {
         if (last_priority.priority_bin == TilePriority::EVENTUALLY) {
           bool order_correct = last_priority.distance_to_visible <=
                                new_priority.distance_to_visible;
           eventually_bin_order_correct_count += order_correct;
           eventually_bin_order_incorrect_count += !order_correct;
-        } else if (!soon_rect.Intersects(new_tile->content_rect()) &&
-                   !soon_rect.Intersects(last_tile->content_rect())) {
+        } else if (!soon_rect.Intersects(new_tile.tile()->content_rect()) &&
+                   !soon_rect.Intersects(last_tile.tile()->content_rect())) {
           EXPECT_LE(last_priority.distance_to_visible,
                     new_priority.distance_to_visible);
           EXPECT_EQ(TilePriority::NOW, new_priority.priority_bin);
         } else if (new_priority.distance_to_visible > 0.f) {
           EXPECT_EQ(TilePriority::SOON, new_priority.priority_bin);
         }
       }
       have_tiles[new_priority.priority_bin] = true;
 
       last_tile = new_tile;
 
       // On the second iteration, mark everything as ready to draw (solid
       // color).
       if (i == 1) {
-        TileDrawInfo& draw_info = last_tile->draw_info();
+        TileDrawInfo& draw_info = last_tile.tile()->draw_info();
         draw_info.SetSolidColorForTesting(SK_ColorRED);
       }
     }
 
     EXPECT_GT(eventually_bin_order_correct_count,
               eventually_bin_order_incorrect_count);
 
     // We should have now and eventually tiles, as well as soon tiles from
     // the border region.
     EXPECT_TRUE(have_tiles[TilePriority::NOW]);
@@ skipping 30 matching lines @@
   tiling_set->UpdateTilePriorities(moved_viewport, 1.0f, 2.0, Occlusion(),
                                    true);
 
   float inset =
       PictureLayerTiling::CalculateSoonBorderDistance(moved_viewport, 1.0f);
   gfx::Rect soon_rect = moved_viewport;
   soon_rect.Inset(-inset, -inset);
 
   // There are 3 bins in TilePriority.
   bool have_tiles[3] = {};
-  Tile* last_tile = NULL;
+  PrioritizedTile last_tile;
   int eventually_bin_order_correct_count = 0;
   int eventually_bin_order_incorrect_count = 0;
   scoped_ptr<TilingSetRasterQueueAll> queue(
       new TilingSetRasterQueueAll(tiling_set.get(), false));
   for (; !queue->IsEmpty(); queue->Pop()) {
-    if (!last_tile)
+    if (!last_tile.tile())
       last_tile = queue->Top();
 
-    Tile* new_tile = queue->Top();
+    const PrioritizedTile& new_tile = queue->Top();
 
-    TilePriority last_priority = last_tile->priority();
-    TilePriority new_priority = new_tile->priority();
+    TilePriority last_priority = last_tile.priority();
+    TilePriority new_priority = new_tile.priority();
 
     have_tiles[new_priority.priority_bin] = true;
 
     EXPECT_LE(last_priority.priority_bin, new_priority.priority_bin);
     if (last_priority.priority_bin == new_priority.priority_bin) {
       if (last_priority.priority_bin == TilePriority::EVENTUALLY) {
         bool order_correct = last_priority.distance_to_visible <=
                              new_priority.distance_to_visible;
         eventually_bin_order_correct_count += order_correct;
         eventually_bin_order_incorrect_count += !order_correct;
-      } else if (!soon_rect.Intersects(new_tile->content_rect()) &&
-                 !soon_rect.Intersects(last_tile->content_rect())) {
+      } else if (!soon_rect.Intersects(new_tile.tile()->content_rect()) &&
+                 !soon_rect.Intersects(last_tile.tile()->content_rect())) {
         EXPECT_LE(last_priority.distance_to_visible,
                   new_priority.distance_to_visible);
       } else if (new_priority.distance_to_visible > 0.f) {
         EXPECT_EQ(TilePriority::SOON, new_priority.priority_bin);
       }
     }
     last_tile = new_tile;
   }
 
   EXPECT_GT(eventually_bin_order_correct_count,
             eventually_bin_order_incorrect_count);
 
   EXPECT_TRUE(have_tiles[TilePriority::NOW]);
   EXPECT_TRUE(have_tiles[TilePriority::SOON]);
   EXPECT_TRUE(have_tiles[TilePriority::EVENTUALLY]);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest, SetIsLikelyToRequireADraw) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
-  EXPECT_TRUE(queue->Top()->required_for_draw());
+  EXPECT_TRUE(queue->Top().tile()->required_for_draw());
 
   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
   host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
   EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        SetIsLikelyToRequireADrawOnZeroMemoryBudget) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
-  EXPECT_TRUE(queue->Top()->required_for_draw());
+  EXPECT_TRUE(queue->Top().tile()->required_for_draw());
 
   ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
   policy.bytes_limit_when_visible = 0;
   host_impl_.SetMemoryPolicy(policy);
 
   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
   host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        SetIsLikelyToRequireADrawOnLimitedMemoryBudget) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
-  EXPECT_TRUE(queue->Top()->required_for_draw());
-  EXPECT_EQ(gfx::Size(256, 256), queue->Top()->desired_texture_size());
+  EXPECT_TRUE(queue->Top().tile()->required_for_draw());
+  EXPECT_EQ(gfx::Size(256, 256), queue->Top().tile()->desired_texture_size());
   EXPECT_EQ(RGBA_8888, host_impl_.resource_provider()->best_texture_format());
 
   ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
   policy.bytes_limit_when_visible =
       Resource::MemorySizeBytes(gfx::Size(256, 256), RGBA_8888);
   host_impl_.SetMemoryPolicy(policy);
 
   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
   host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
   EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
 
   scoped_ptr<ScopedResource> resource =
       host_impl_.resource_pool()->AcquireResource(gfx::Size(256, 256),
                                                   RGBA_8888);
 
   host_impl_.tile_manager()->CheckIfMoreTilesNeedToBePreparedForTesting();
   EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
 
   host_impl_.resource_pool()->ReleaseResource(resource.Pass());
 }
 
 }  // namespace
 }  // namespace cc