cc: Do not cleanup tiles with raster tasks.

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/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
@@ skipping 99 matching lines @@
     return tiles;
   }
 
   TileVector CreateTiles(int count,
                          TilePriority active_priority,
                          TilePriority pending_priority) {
     return CreateTilesWithSize(
         count, active_priority, pending_priority, settings_.default_tile_size);
   }
 
+  void ReleaseTileOnBothTree(TileVector tiles) {

[reveman, 2014/07/30 18:41:39]

ReleaseTiles(TileVector* tiles)

[sohanjg, 2014/07/31 13:42:56]

Done.

+    for (TileVector::iterator it = tiles.begin(); it != tiles.end(); it++) {
+      Tile* tile = *it;
+      tile->SetPriority(ACTIVE_TREE, TilePriority());
+      tile->SetPriority(PENDING_TREE, TilePriority());
+    }
+  }
+
   FakeTileManager* tile_manager() { return tile_manager_.get(); }
 
   int AssignedMemoryCount(const TileVector& tiles) {
     int has_memory_count = 0;
     for (TileVector::const_iterator it = tiles.begin(); it != tiles.end();
          ++it) {
       if (tile_manager_->HasBeenAssignedMemory(*it))
         ++has_memory_count;
     }
     return has_memory_count;
@@ skipping 35 matching lines @@
   TileVector active_pending_soon =
       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(3, AssignedMemoryCount(active_now));
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
   EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
+
+  ReleaseTileOnBothTree(active_now);
+  ReleaseTileOnBothTree(pending_now);
+  ReleaseTileOnBothTree(active_pending_soon);
+  ReleaseTileOnBothTree(never_bin);
 }
 
 TEST_P(TileManagerTest, EnoughMemoryAllowPrepaintOnly) {
   // A few tiles of each type of priority, with enough memory for all tiles,
   // with the exception of never bin.
 
   Initialize(10, ALLOW_PREPAINT_ONLY, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
   TileVector pending_now =
       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
   TileVector active_pending_soon =
       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(3, AssignedMemoryCount(active_now));
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
   EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
+
+  ReleaseTileOnBothTree(active_now);
+  ReleaseTileOnBothTree(pending_now);
+  ReleaseTileOnBothTree(active_pending_soon);
+  ReleaseTileOnBothTree(never_bin);
 }
 
 TEST_P(TileManagerTest, EnoughMemoryPendingLowResAllowAbsoluteMinimum) {
   // A few low-res tiles required for activation, with enough memory for all
   // tiles.
 
   Initialize(5, ALLOW_ABSOLUTE_MINIMUM, SAME_PRIORITY_FOR_BOTH_TREES);
   TileVector pending_low_res =
       CreateTiles(5, TilePriority(), TilePriorityLowRes());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(5, AssignedMemoryCount(pending_low_res));
+  ReleaseTileOnBothTree(pending_low_res);
 }
 
 TEST_P(TileManagerTest, EnoughMemoryAllowAbsoluteMinimum) {
   // A few tiles of each type of priority, with enough memory for all tiles,
   // with the exception of never and soon bins.
 
   Initialize(10, ALLOW_ABSOLUTE_MINIMUM, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
   TileVector pending_now =
       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
   TileVector active_pending_soon =
       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(3, AssignedMemoryCount(active_now));
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
   EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
+
+  ReleaseTileOnBothTree(active_now);
+  ReleaseTileOnBothTree(pending_now);
+  ReleaseTileOnBothTree(active_pending_soon);
+  ReleaseTileOnBothTree(never_bin);
 }
 
 TEST_P(TileManagerTest, EnoughMemoryAllowNothing) {
   // A few tiles of each type of priority, with enough memory for all tiles,
   // but allow nothing should not assign any memory.
 
   Initialize(10, ALLOW_NOTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
   TileVector pending_now =
       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
   TileVector active_pending_soon =
       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(0, AssignedMemoryCount(active_now));
   EXPECT_EQ(0, AssignedMemoryCount(pending_now));
   EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
+
+  ReleaseTileOnBothTree(active_now);
+  ReleaseTileOnBothTree(pending_now);
+  ReleaseTileOnBothTree(active_pending_soon);
+  ReleaseTileOnBothTree(never_bin);
 }
 
 TEST_P(TileManagerTest, PartialOOMMemoryToPending) {
   // 5 tiles on active tree eventually bin, 5 tiles on pending tree that are
   // required for activation, but only enough memory for 8 tiles. The result
   // is all pending tree tiles get memory, and 3 of the active tree tiles
   // get memory. None of these tiles is needed to avoid calimity (flickering or
   // raster-on-demand) so the soft memory limit is used.
 
   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(5, TilePriorityForEventualBin(), TilePriority());
   TileVector pending_tree_tiles =
       CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
 
   SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(3, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(5, AssignedMemoryCount(pending_tree_tiles));
+
+  ReleaseTileOnBothTree(active_tree_tiles);
+  ReleaseTileOnBothTree(pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, PartialOOMMemoryToActive) {
   // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin,
   // but only enough memory for 8 tiles. The result is all active tree tiles
   // get memory, and 3 of the pending tree tiles get memory.
   // The pending tiles are not needed to avoid calimity (flickering or
   // raster-on-demand) and the active tiles fit, so the soft limit is used.
 
   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(5, TilePriorityForNowBin(), TilePriority());
   TileVector pending_tree_tiles =
       CreateTiles(5, TilePriority(), TilePriorityForNowBin());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
+
+  ReleaseTileOnBothTree(active_tree_tiles);
+  ReleaseTileOnBothTree(pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, TotalOOMMemoryToPending) {
   // 10 tiles on active tree eventually bin, 10 tiles on pending tree that are
   // required for activation, but only enough tiles for 4 tiles. The result
   // is 4 pending tree tiles get memory, and none of the active tree tiles
   // get memory.
 
   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
@@ skipping 11 matching lines @@
 
   if (UsingResourceLimit()) {
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
   } else {
     // Pending tiles are now required to avoid calimity (flickering or
     // raster-on-demand). Hard-limit is used and double the tiles fit.
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
   }
+
+  ReleaseTileOnBothTree(active_tree_tiles);
+  ReleaseTileOnBothTree(pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, TotalOOMActiveSoonMemoryToPending) {
   // 10 tiles on active tree soon bin, 10 tiles on pending tree that are
   // required for activation, but only enough tiles for 4 tiles. The result
   // is 4 pending tree tiles get memory, and none of the active tree tiles
   // get memory.
 
   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
@@ skipping 11 matching lines @@
 
   if (UsingResourceLimit()) {
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
   } else {
     // Pending tiles are now required to avoid calimity (flickering or
     // raster-on-demand). Hard-limit is used and double the tiles fit.
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
   }
+
+  ReleaseTileOnBothTree(active_tree_tiles);
+  ReleaseTileOnBothTree(pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, TotalOOMMemoryToActive) {
   // 10 tiles on active tree eventually bin, 10 tiles on pending tree now bin,
   // but only enough memory for 4 tiles. The result is 4 active tree tiles
   // get memory, and none of the pending tree tiles get memory.
 
   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(10, TilePriorityForNowBin(), TilePriority());
   TileVector pending_tree_tiles =
       CreateTiles(10, TilePriority(), TilePriorityForNowBin());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   if (UsingResourceLimit()) {
     EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
   } else {
     // Active tiles are required to avoid calimity (flickering or
     // raster-on-demand). Hard-limit is used and double the tiles fit.
     EXPECT_EQ(8, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
   }
+
+  ReleaseTileOnBothTree(active_tree_tiles);
+  ReleaseTileOnBothTree(pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, TotalOOMMemoryToNewContent) {
   // 10 tiles on active tree now bin, 10 tiles on pending tree now bin,
   // but only enough memory for 8 tiles. Any tile missing would cause
   // a calamity (flickering or raster-on-demand). Depending on mode,
   // we should use varying amounts of the higher hard memory limit.
   if (UsingResourceLimit())
     return;
 
@@ skipping 19 matching lines @@
             AssignedMemoryCount(active_tree_tiles) +
                 AssignedMemoryCount(pending_tree_tiles));
 
   // The pending tree is now more important. Active tiles will take higher
   // priority if they are ready-to-draw in practice. Importantly though,
   // pending tiles also utilize the hard-limit.
   SetTreePriority(NEW_CONTENT_TAKES_PRIORITY);
   tile_manager()->AssignMemoryToTiles(global_state_);
   EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(10, AssignedMemoryCount(pending_tree_tiles));
+
+  ReleaseTileOnBothTree(active_tree_tiles);
+  ReleaseTileOnBothTree(pending_tree_tiles);
 }
 
 // If true, the max tile limit should be applied as bytes; if false,
 // as num_resources_limit.
 INSTANTIATE_TEST_CASE_P(TileManagerTests,
                         TileManagerTest,
                         ::testing::Values(true, false));
 
 class TileManagerTileIteratorTest : public testing::Test {
  public:
@@ skipping 670 matching lines @@
       }
     }
     last_tile = tile;
   }
   size_t expected_occluded_count =
       pending_child_high_res_tiles.size() + pending_child_low_res_tiles.size();
   EXPECT_EQ(expected_occluded_count, occluded_count);
 }
 }  // namespace
 }  // namespace cc