cc: Remove tile sharing from tilings.

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 165 matching lines @@
   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(ACTIVE_TREE).priority_bin);
-    EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
-    if (tile->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION)
+    EXPECT_EQ(TilePriority::NOW, tile->priority().priority_bin);
+    if (tile->priority().resolution == LOW_RESOLUTION)
       had_low_res = true;
     else
       smoothness_tiles.insert(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(
@@ skipping 78 matching lines @@
                                       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);
 
     if (!last_tile)
       last_tile = tile;
 
-    EXPECT_LE(last_tile->priority(ACTIVE_TREE).priority_bin,
-              tile->priority(ACTIVE_TREE).priority_bin);
+    EXPECT_LE(last_tile->priority().priority_bin,
+              tile->priority().priority_bin);
     bool skip_updating_last_tile = false;
-    if (last_tile->priority(ACTIVE_TREE).priority_bin ==
-        tile->priority(ACTIVE_TREE).priority_bin) {
-      correct_order_tiles +=
-          last_tile->priority(ACTIVE_TREE).distance_to_visible <=
-          tile->priority(ACTIVE_TREE).distance_to_visible;
-    } else if (tile->priority(ACTIVE_TREE).priority_bin ==
-                   TilePriority::EVENTUALLY &&
-               tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW) {
+    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) {
       // 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(ACTIVE_TREE).priority_bin == TilePriority::NOW &&
-        last_tile->priority(ACTIVE_TREE).resolution !=
-            tile->priority(ACTIVE_TREE).resolution) {
+    if (tile->priority().priority_bin == TilePriority::NOW &&
+        last_tile->priority().resolution != tile->priority().resolution) {
       // Low resolution should come first.
-      EXPECT_EQ(LOW_RESOLUTION, last_tile->priority(ACTIVE_TREE).resolution);
+      EXPECT_EQ(LOW_RESOLUTION, last_tile->priority().resolution);
     }
 
     if (!skip_updating_last_tile)
       last_tile = 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);
@@ skipping 42 matching lines @@
   queue = host_impl_.BuildRasterQueue(NEW_CONTENT_TAKES_PRIORITY,
                                       RasterTilePriorityQueue::Type::ALL);
   tile_count = 0;
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
     EXPECT_TRUE(tile);
 
     if (!last_tile)
       last_tile = tile;
 
-    EXPECT_LE(last_tile->priority(PENDING_TREE).priority_bin,
-              tile->priority(PENDING_TREE).priority_bin);
-    if (last_tile->priority(PENDING_TREE).priority_bin ==
-        tile->priority(PENDING_TREE).priority_bin) {
-      increasing_distance_tiles +=
-          last_tile->priority(PENDING_TREE).distance_to_visible <=
-          tile->priority(PENDING_TREE).distance_to_visible;
+    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;
     }
 
-    if (tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW &&
-        last_tile->priority(PENDING_TREE).resolution !=
-            tile->priority(PENDING_TREE).resolution) {
+    if (tile->priority().priority_bin == TilePriority::NOW &&
+        last_tile->priority().resolution != tile->priority().resolution) {
       // High resolution should come first.
-      EXPECT_EQ(HIGH_RESOLUTION, last_tile->priority(PENDING_TREE).resolution);
+      EXPECT_EQ(HIGH_RESOLUTION, last_tile->priority().resolution);
     }
 
     last_tile = tile;
     new_content_tiles.insert(tile);
     ++tile_count;
     queue->Pop();
   }
 
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(high_res_tiles, new_content_tiles);
@@ skipping 33 matching lines @@
 
 TEST_F(TileManagerTilePriorityQueueTest,
        RasterTilePriorityQueueHighNonIdealTilings) {
   const gfx::Size layer_bounds(1000, 1000);
   const gfx::Size viewport(800, 800);
   host_impl_.SetViewportSize(viewport);
   SetupDefaultTrees(layer_bounds);
 
   pending_layer_->tilings()->AddTiling(1.5f, pending_layer_->raster_source());
   active_layer_->tilings()->AddTiling(1.5f, active_layer_->raster_source());
+  pending_layer_->tilings()->AddTiling(1.7f, pending_layer_->raster_source());
+  active_layer_->tilings()->AddTiling(1.7f, active_layer_->raster_source());
 
   pending_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
                                                   Occlusion(), true);
   active_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
                                                  Occlusion(), true);
 
   std::set<Tile*> all_expected_tiles;
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
-    tiling->CreateAllTilesForTesting();
     if (tiling->contents_scale() == 1.f) {
       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);
     }
   }
 
   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
-    tiling->CreateAllTilesForTesting();
     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();
+        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());
     ++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) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(gfx::Size(500, 500));
   SetupDefaultTrees(layer_bounds);
 
   // Use a tile's content rect as an invalidation. We should inset it a bit to
   // ensure that border math doesn't invalidate neighbouring tiles.
   gfx::Rect invalidation =
-      pending_layer_->HighResTiling()->TileAt(1, 0)->content_rect();
+      active_layer_->HighResTiling()->TileAt(1, 0)->content_rect();
   invalidation.Inset(2, 2);
 
   pending_layer_->set_invalidation(invalidation);
   pending_layer_->HighResTiling()->Invalidate(invalidation);
+  pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
   pending_layer_->LowResTiling()->Invalidate(invalidation);
+  pending_layer_->LowResTiling()->CreateMissingTilesInLiveTilesRect();
 
-  // Sanity checks: Tile at 0, 0 should be the same on both trees, tile at 1, 0
-  // should be different.
-  EXPECT_TRUE(pending_layer_->HighResTiling()->TileAt(0, 0));
+  // Sanity checks: Tile at 0, 0 not exist on the pending tree (it's not
+  // invalidated). Tile 1, 0 should exist on both.
+  EXPECT_FALSE(pending_layer_->HighResTiling()->TileAt(0, 0));
   EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(0, 0));
-  EXPECT_EQ(pending_layer_->HighResTiling()->TileAt(0, 0),
-            active_layer_->HighResTiling()->TileAt(0, 0));
   EXPECT_TRUE(pending_layer_->HighResTiling()->TileAt(1, 0));
   EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(1, 0));
   EXPECT_NE(pending_layer_->HighResTiling()->TileAt(1, 0),
             active_layer_->HighResTiling()->TileAt(1, 0));
 
   std::set<Tile*> expected_now_tiles;
   std::set<Tile*> expected_required_for_draw_tiles;
   std::set<Tile*> expected_required_for_activation_tiles;
   for (int i = 0; i <= 1; ++i) {
     for (int j = 0; j <= 1; ++j) {
-      expected_now_tiles.insert(pending_layer_->HighResTiling()->TileAt(i, j));
-      expected_now_tiles.insert(active_layer_->HighResTiling()->TileAt(i, j));
-
-      expected_required_for_activation_tiles.insert(
-          pending_layer_->HighResTiling()->TileAt(i, j));
-      expected_required_for_draw_tiles.insert(
-          active_layer_->HighResTiling()->TileAt(i, j));
+      bool have_pending_tile = false;
+      if (pending_layer_->HighResTiling()->TileAt(i, j)) {
+        expected_now_tiles.insert(
+            pending_layer_->HighResTiling()->TileAt(i, j));
+        expected_required_for_activation_tiles.insert(
+            pending_layer_->HighResTiling()->TileAt(i, j));
+        have_pending_tile = true;
+      }
+      Tile* active_tile = active_layer_->HighResTiling()->TileAt(i, j);
+      EXPECT_TRUE(active_tile);
+      expected_now_tiles.insert(active_tile);
+      expected_required_for_draw_tiles.insert(active_tile);
+      if (!have_pending_tile)
+        expected_required_for_activation_tiles.insert(active_tile);
     }
   }
   // Expect 3 shared tiles and 1 unshared tile in total.
   EXPECT_EQ(5u, expected_now_tiles.size());
   // Expect 4 tiles for each draw and activation, but not all the same.
   EXPECT_EQ(4u, expected_required_for_activation_tiles.size());
   EXPECT_EQ(4u, expected_required_for_draw_tiles.size());
   EXPECT_NE(expected_required_for_draw_tiles,
             expected_required_for_activation_tiles);
 
   std::set<Tile*> expected_all_tiles;
   for (int i = 0; i <= 3; ++i) {
     for (int j = 0; j <= 3; ++j) {
-      expected_all_tiles.insert(pending_layer_->HighResTiling()->TileAt(i, j));
+      if (pending_layer_->HighResTiling()->TileAt(i, j))
+        expected_all_tiles.insert(
+            pending_layer_->HighResTiling()->TileAt(i, j));
+      EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(i, j));
       expected_all_tiles.insert(active_layer_->HighResTiling()->TileAt(i, j));
     }
   }
   // 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();
     queue->Pop();
-    if (tile->combined_priority().priority_bin == TilePriority::NOW)
+    if (tile->priority().priority_bin == TilePriority::NOW)
       actual_now_tiles.insert(tile);
     actual_all_tiles.insert(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;
@@ skipping 48 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->combined_priority().priority_bin >= TilePriority::EVENTUALLY)
+    if (tile->priority().priority_bin >= TilePriority::EVENTUALLY)
       break;
 
     all_tiles.push_back(tile);
     queue->Pop();
   }
 
   tile_manager()->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   // Ensure we can activate.
@@ skipping 28 matching lines @@
 
   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(ACTIVE_TREE).priority_bin);
-    EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
+    EXPECT_EQ(TilePriority::NOW, tile->priority().priority_bin);
     EXPECT_TRUE(tile->HasResource());
     smoothness_tiles.insert(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());
@@ skipping 35 matching lines @@
   int distance_increasing = 0;
   int distance_decreasing = 0;
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
     EXPECT_TRUE(tile);
     EXPECT_TRUE(tile->HasResource());
 
     if (!last_tile)
       last_tile = tile;
 
-    const TilePriority& last_priority = last_tile->combined_priority();
-    const TilePriority& priority = tile->combined_priority();
+    const TilePriority& last_priority = last_tile->priority();
+    const TilePriority& priority = 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(),
                 tile->required_for_activation());
       if (last_tile->required_for_activation() ==
           tile->required_for_activation()) {
         if (last_priority.distance_to_visible >= priority.distance_to_visible)
           ++distance_decreasing;
         else
@@ skipping 19 matching lines @@
   queue = host_impl_.BuildEvictionQueue(NEW_CONTENT_TAKES_PRIORITY);
   distance_decreasing = 0;
   distance_increasing = 0;
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
     EXPECT_TRUE(tile);
 
     if (!last_tile)
       last_tile = tile;
 
-    const TilePriority& last_priority = last_tile->combined_priority();
-    const TilePriority& priority = tile->combined_priority();
+    const TilePriority& last_priority = last_tile->priority();
+    const TilePriority& priority = 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(),
                 tile->required_for_activation());
       if (last_tile->required_for_activation() ==
           tile->required_for_activation()) {
         if (last_priority.distance_to_visible >= priority.distance_to_visible)
           ++distance_decreasing;
         else
@@ skipping 118 matching lines @@
   TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
   size_t occluded_count = 0u;
   Tile* last_tile = NULL;
   scoped_ptr<EvictionTilePriorityQueue> queue(
       host_impl_.BuildEvictionQueue(tree_priority));
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
     if (!last_tile)
       last_tile = tile;
 
-    bool tile_is_occluded = tile->is_occluded_combined();
+    bool tile_is_occluded = 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_combined();
+      bool last_tile_is_occluded = last_tile->is_occluded();
       if (!last_tile_is_occluded) {
         TilePriority::PriorityBin tile_priority_bin =
-            tile->priority_for_tree_priority(tree_priority).priority_bin;
+            tile->priority().priority_bin;
         TilePriority::PriorityBin last_tile_priority_bin =
-            last_tile->priority_for_tree_priority(tree_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()));
       }
     }
     last_tile = tile;
     queue->Pop();
   }
   size_t expected_occluded_count =
@@ skipping 89 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(PENDING_TREE);
+    const TilePriority& pending_priority = 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();
   }
@@ skipping 142 matching lines @@
     // 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(ACTIVE_TREE).priority_bin] = true;
+    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();
       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();
       queue->Pop();
       unique_tiles.insert(new_tile);
 
-      TilePriority last_priority = last_tile->priority(ACTIVE_TREE);
-      TilePriority new_priority = new_tile->priority(ACTIVE_TREE);
+      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())) {
           EXPECT_LE(last_priority.distance_to_visible,
@@ skipping 66 matching lines @@
   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)
       last_tile = queue->Top();
 
     Tile* new_tile = queue->Top();
 
-    TilePriority last_priority = last_tile->priority(ACTIVE_TREE);
-    TilePriority new_priority = new_tile->priority(ACTIVE_TREE);
+    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;
@@ skipping 81 matching lines @@
                                                   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