Expire resources in ResourcePool after non-use

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 1203 matching lines @@
   if (output_surface_ && global_tile_state_.hard_memory_limit_in_bytes > 0) {
     // If |global_tile_state_.hard_memory_limit_in_bytes| is greater than 0, we
     // allow the worker context to retain allocated resources. Notify the worker
     // context. If the memory policy has become zero, we'll handle the
     // notification in NotifyAllTileTasksCompleted, after in-progress work
     // finishes.
     output_surface_->SetWorkerContextShouldAggressivelyFreeResources(
         false /* aggressively_free_resources */);
   }
 
-  // TODO(reveman): We should avoid keeping around unused resources if
-  // possible. crbug.com/224475
-  // Unused limit is calculated from soft-limit, as hard-limit may
-  // be very high and shouldn't typically be exceeded.
-  size_t unused_memory_limit_in_bytes = static_cast<size_t>(
-      (static_cast<int64>(global_tile_state_.soft_memory_limit_in_bytes) *
-       settings_.max_unused_resource_memory_percentage) /
-      100);
-
   DCHECK(resource_pool_);
   resource_pool_->CheckBusyResources();
   // Soft limit is used for resource pool such that memory returns to soft
   // limit after going over.
   resource_pool_->SetResourceUsageLimits(
       global_tile_state_.soft_memory_limit_in_bytes,
-      unused_memory_limit_in_bytes,
       global_tile_state_.num_resources_limit);
 
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::DidModifyTilePriorities() {
   // Mark priorities as dirty and schedule a PrepareTiles().
   tile_priorities_dirty_ = true;
   client_->SetNeedsPrepareTilesOnImplThread();
 }
@@ skipping 834 matching lines @@
   // if we're in synchronous single-threaded mode.
   TaskGraphRunner* task_graph_runner = task_graph_runner_;
   if (is_synchronous_single_threaded_) {
     DCHECK(!single_thread_synchronous_task_graph_runner_);
     single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner);
     task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
   }
 
   ContextProvider* context_provider = output_surface_->context_provider();
   if (!context_provider) {
-    *resource_pool =
-        ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
+    *resource_pool = ResourcePool::Create(resource_provider_.get(),
+                                          GetTaskRunner(), GL_TEXTURE_2D);
 
     *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, resource_provider_.get());
     return;
   }
 
   if (use_gpu_rasterization_) {
     DCHECK(resource_provider_->output_surface()->worker_context_provider());
 
-    *resource_pool =
-        ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
+    *resource_pool = ResourcePool::Create(resource_provider_.get(),
+                                          GetTaskRunner(), GL_TEXTURE_2D);
 
     int msaa_sample_count = use_msaa_ ? RequestedMSAASampleCount() : 0;
 
     *tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, context_provider,
         resource_provider_.get(), settings_.use_distance_field_text,
         msaa_sample_count);
     return;
   }
 
   DCHECK(GetRendererCapabilities().using_image);
 
   bool use_zero_copy = settings_.use_zero_copy;
   // TODO(reveman): Remove this when mojo supports worker contexts.
   // crbug.com/522440
   if (!resource_provider_->output_surface()->worker_context_provider()) {
     LOG(ERROR)
         << "Forcing zero-copy tile initialization as worker context is missing";
     use_zero_copy = true;
   }
 
   if (use_zero_copy) {
-    *resource_pool = ResourcePool::Create(resource_provider_.get());
+    *resource_pool =
+        ResourcePool::Create(resource_provider_.get(), GetTaskRunner());
 
     *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, resource_provider_.get());
     return;
   }
 
   if (settings_.use_one_copy) {
-    *resource_pool =
-        ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
+    *resource_pool = ResourcePool::Create(resource_provider_.get(),
+                                          GetTaskRunner(), GL_TEXTURE_2D);
 
     int max_copy_texture_chromium_size =
         context_provider->ContextCapabilities()
             .gpu.max_copy_texture_chromium_size;
 
     *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, context_provider,
         resource_provider_.get(), max_copy_texture_chromium_size,
         settings_.use_persistent_map_for_gpu_memory_buffers,
         settings_.max_staging_buffers);
     return;
   }
 
   // Synchronous single-threaded mode depends on tiles being ready to
   // draw when raster is complete.  Therefore, it must use one of zero
   // copy, software raster, or GPU raster (in the branches above).
   DCHECK(!is_synchronous_single_threaded_);
 
-  *resource_pool = ResourcePool::Create(
-      resource_provider_.get(), GL_TEXTURE_2D);
+  *resource_pool = ResourcePool::Create(resource_provider_.get(),
+                                        GetTaskRunner(), GL_TEXTURE_2D);
 
   *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
       GetTaskRunner(), task_graph_runner_, context_provider,
       resource_provider_.get(),
       GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
                                      settings_.renderer_settings.refresh_rate));
 }
 
 void LayerTreeHostImpl::RecordMainFrameTiming(
     const BeginFrameArgs& start_of_main_frame_args,
@@ skipping 1462 matching lines @@
   if (active_tree()) {
     LayerAnimationValueProvider* layer = active_tree()->LayerById(layer_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc