cc: Make tiles that are not required by trees NEVER_BIN

Currently if we have allow anything mode, we never have a tile
in the NEVER_BIN, even if both active and pending trees don't
own the tile anymore (ie it's being kept alive by the raster
callback). This cleans it up.

BUG=251938

Review URL: https://chromiumcodereview.appspot.com/16959022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@208047 0039d316-1c4b-4281-b951-d872f2087c98

cc/resources/tile_manager.cc

@@ -5,6 +5,7 @@
 #include "cc/resources/tile_manager.h"
 
 #include <algorithm>
+#include <limits>
 #include <string>
 
 #include "base/bind.h"
@@ -36,6 +37,10 @@ inline TileManagerBin BinFromTilePriority(const TilePriority& prio,
   bool can_be_in_now_bin = tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
                            prio.resolution != LOW_RESOLUTION;
 
+  if (prio.distance_to_visible_in_pixels ==
+      std::numeric_limits<float>::infinity())
+    return NEVER_BIN;
+
   if (can_be_in_now_bin && prio.time_to_visible_in_seconds == 0)
     return NOW_BIN;
 
@@ -512,9 +517,24 @@ void TileManager::AssignGpuMemoryToTiles() {
     for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
       Tile* tile = *it;
       ManagedTileState& mts = tile->managed_state();
+      ManagedTileState::TileVersion& tile_version =
+          mts.tile_versions[mts.raster_mode];
       if (mts.tree_bin[PENDING_TREE] == NEVER_BIN &&
           mts.tree_bin[ACTIVE_TREE] != NOW_BIN) {
         size_t bytes_that_can_be_freed = 0;
+
+        // If the tile is in the to-rasterize list, but it has no task,
+        // then it means that we have assigned memory for it.
+        TileVector::iterator raster_it =
+            std::find(tiles_that_need_to_be_rasterized_.begin(),
+                      tiles_that_need_to_be_rasterized_.end(),
+                      tile);
+        if (raster_it != tiles_that_need_to_be_rasterized_.end() &&
+            tile_version.raster_task_.is_null()) {
+          bytes_that_can_be_freed += tile->bytes_consumed_if_allocated();
+        }
+
+        // Also consider all of the completed resources for freeing.
         for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
           ManagedTileState::TileVersion& tile_version =
               mts.tile_versions[mode];
@@ -524,16 +544,13 @@ void TileManager::AssignGpuMemoryToTiles() {
           }
         }
 
+        // If we can free anything, then do so.
         if (bytes_that_can_be_freed > 0) {
           FreeResourcesForTile(tile);
           bytes_freed += bytes_that_can_be_freed;
           mts.tile_versions[mts.raster_mode].set_rasterize_on_demand();
-          TileVector::iterator it = std::find(
-                  tiles_that_need_to_be_rasterized_.begin(),
-                  tiles_that_need_to_be_rasterized_.end(),
-                  tile);
-          if (it != tiles_that_need_to_be_rasterized_.end())
-              tiles_that_need_to_be_rasterized_.erase(it);
+          if (raster_it != tiles_that_need_to_be_rasterized_.end())
+              tiles_that_need_to_be_rasterized_.erase(raster_it);
         }
       }
 

cc/resources/tile_manager_unittest.cc

@@ -142,7 +142,7 @@ TEST_F(TileManagerTest, EnoughMemoryAllowAnything) {
   EXPECT_EQ(3, AssignedMemoryCounts(active_now));
   EXPECT_EQ(3, AssignedMemoryCounts(pending_now));
   EXPECT_EQ(3, AssignedMemoryCounts(active_pending_soon));
-  EXPECT_EQ(1, AssignedMemoryCounts(never_bin));
+  EXPECT_EQ(0, AssignedMemoryCounts(never_bin));
 
   active_now.clear();
   pending_now.clear();
@@ -296,6 +296,27 @@ TEST_F(TileManagerTest, TotalOOMMemoryToPending) {
   TearDown();
 }
 
+TEST_F(TileManagerTest, TotalOOMActiveSoonMemoryToPending) {
+  // 5 tiles on active tree soon bin, 5 tiles on pending tree now bin,
+  // but only enough memory 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 =
+      CreateTiles(5, TilePriorityForSoonBin(), TilePriority());
+  TileVector pending_tree_tiles =
+      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
+
+  tile_manager()->ManageTiles();
+
+  EXPECT_EQ(0, AssignedMemoryCounts(active_tree_tiles));
+  EXPECT_EQ(4, AssignedMemoryCounts(pending_tree_tiles));
+
+  pending_tree_tiles.clear();
+  active_tree_tiles.clear();
+  TearDown();
+}
+
 TEST_F(TileManagerTest, TotalOOMMemoryToActive) {
   // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin,
   // but only enough memory for 4 tiles. The result is 5 active tree tiles