cc: Make tiles that are not required by trees NEVER_BIN

cc/resources/tile_manager.cc

 // Copyright 2012 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_manager.h"
 
 #include <algorithm>
+#include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
@@ skipping 11 matching lines @@
                                           TreePriority tree_priority) {
   // The amount of time for which we want to have prepainting coverage.
   const float kPrepaintingWindowTimeSeconds = 1.0f;
   const float kBackflingGuardDistancePixels = 314.0f;
 
   // Don't let low res tiles be in the now bin unless we're in a mode where
   // we're prioritizing checkerboard prevention.
   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;
 
   if (prio.resolution == NON_IDEAL_RESOLUTION)
     return EVENTUALLY_BIN;
 
   if (prio.distance_to_visible_in_pixels < kBackflingGuardDistancePixels ||
       prio.time_to_visible_in_seconds < kPrepaintingWindowTimeSeconds)
     return SOON_BIN;
 
@@ skipping 456 matching lines @@
     }
   }
 
   // In OOM situation, we iterate tiles_, remove the memory for active tree
   // and not the now bin. And give them to bytes_oom_in_now_bin_on_pending_tree
   if (!tiles_requiring_memory_but_oomed.empty()) {
     size_t bytes_freed = 0;
     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];
           if (tile_version.resource_) {
             DCHECK(!tile->required_for_activation());
             bytes_that_can_be_freed += tile->bytes_consumed_if_allocated();
           }
         }
 
+        // 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);
         }
       }
 
       if (bytes_oom_in_now_bin_on_pending_tree <= bytes_freed)
         break;
     }
 
     for (TileVector::iterator it = tiles_requiring_memory_but_oomed.begin();
          it != tiles_requiring_memory_but_oomed.end() && bytes_freed > 0;
          ++it) {
@@ skipping 253 matching lines @@
 }
 
 void TileManager::DidTileTreeBinChange(Tile* tile,
                                        TileManagerBin new_tree_bin,
                                        WhichTree tree) {
   ManagedTileState& mts = tile->managed_state();
   mts.tree_bin[tree] = new_tree_bin;
 }
 
 }  // namespace cc