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 "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"
 #include "cc/resources/tiling_set_raster_queue_all.h"
@@ skipping 165 matching lines @@
 
   // 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)
       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.
@@ skipping 229 matching lines @@
 }
 
 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));
@@ skipping 114 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_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));
@@ skipping 74 matching lines @@
     }
 
     last_tile = 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(12, distance_decreasing);

[enne (OOO), 2015/04/13 22:36:02]

What's up with this change?

[vmpstr, 2015/04/13 23:52:13]

Oops. This was a wrong fix for the test. Changed.

   EXPECT_EQ(tile_count, smoothness_tiles.size());
   EXPECT_EQ(all_tiles, smoothness_tiles);
 
   std::set<Tile*> new_content_tiles;
   last_tile = NULL;
   // 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()) {
@@ skipping 19 matching lines @@
       }
     }
 
     last_tile = 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(12, distance_decreasing);
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(all_tiles, new_content_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        EvictionTilePriorityQueueWithOcclusion) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
@@ skipping 588 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