cc: Prevent the tile manager from allocating more memory than allowed.

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>
 
@@ skipping 491 matching lines @@
 
   all_tiles_that_need_to_be_rasterized_have_memory_ = true;
   all_tiles_required_for_activation_have_memory_ = true;
   all_tiles_required_for_activation_have_been_initialized_ = true;
 
   // Cast to prevent overflow.
   int64 bytes_available =
       static_cast<int64>(bytes_releasable) +
       static_cast<int64>(global_state_.memory_limit_in_bytes) -
       static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
-  int resources_available = resources_releasable +
-                            global_state_.num_resources_limit -
-                            resource_pool_->NumResources();
+  int resources_available =
+      resources_releasable +
+      global_state_.num_resources_limit -
+      resource_pool_->acquired_resource_count();
 
   size_t bytes_allocatable =
       std::max(static_cast<int64>(0), bytes_available);
   size_t resources_allocatable = std::max(0, resources_available);
 
   size_t bytes_that_exceeded_memory_budget = 0;
   size_t bytes_left = bytes_allocatable;
   size_t resources_left = resources_allocatable;
   bool oomed = false;
 
@@ skipping 177 matching lines @@
 
     DCHECK(tile_version.requires_resource());
     DCHECK(!tile_version.resource_);
 
     if (tile_version.raster_task_.is_null())
       tile_version.raster_task_ = CreateRasterTask(tile);
 
     tasks.Append(tile_version.raster_task_, tile->required_for_activation());
   }
 
+  // We must reduce the amount of unused memory before calling
+  // ScheduleTasks to prevent usage from rising above limit.
+  resource_pool_->ReduceMemoryUsage();

[vmpstr, 2013/08/15 18:26:37]

I'm not sure I follow this. Wouldn't we want to ReduceMemoryUsage after
SchedulingTasks? There is no guarantee that ScheduleTasks won't take us over the
limit and in the case that we are currently over limit, we'll end up releasing a
bunch of resources only to create them again during ScheduleTasks (assuming same
format and size). Am I missing something?

[reveman, 2013/08/15 19:13:55]

ScheduleTasks can't create new resources. It can only allocate the ones already
given to it.

So at this point we've already requested all resources that can be used by
ScheduleTasks and they are accounted for by the resource pool but they have not
yet been allocated as allocation is lazy. We've likely requested more resources
than allowed at this point as we might not have been able to recycle all unused
resources. This is good as it means the memory available to us is not affected
by our ability to recycle tiles and odd-sized tiles wont keep hanging around and
affect available memory. We just need to make sure we free enough unused
resources to stay below the limit before calling ScheduleTasks as that call will
cause real memory to be allocated.

+
   // Schedule running of |tasks|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // in |tasks|.
   raster_worker_pool_->ScheduleTasks(&tasks);
 }
 
 RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
     Tile* tile, skia::LazyPixelRef* pixel_ref) {
   return RasterWorkerPool::CreateImageDecodeTask(
       pixel_ref,
@@ skipping 116 matching lines @@
     tile_version.set_use_resource();
     tile_version.resource_ = resource.Pass();
   }
 
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
 }
 
 }  // namespace cc