cc: Free gpu resources when we are invisible or TM is oom.

cc/resources/gpu_rasterizer.cc

 // Copyright 2015 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/gpu_rasterizer.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/output/context_provider.h"
 #include "cc/resources/raster_buffer.h"
 #include "cc/resources/raster_source.h"
 #include "cc/resources/resource.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_gpu_raster.h"
 #include "cc/resources/tile_manager.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/skia/include/core/SkMultiPictureDraw.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 
+namespace {
+// The limit of the number of GPU resources we hold in the GrContext's
+// GPU cache.
+const int kMaxGaneshResourceCacheCount = 2048;
+
+// The limit of the bytes allocated toward GPU resources in the GrContext's
+// GPU cache.
+const size_t kMaxGaneshResourceCacheBytes = 96 * 1024 * 1024;
+
+}  // namespace
+
 namespace cc {
 
 // static
 scoped_ptr<GpuRasterizer> GpuRasterizer::Create(
     ContextProvider* context_provider,
     ResourceProvider* resource_provider,
     bool use_distance_field_text,
     bool threaded_gpu_rasterization_enabled,
     int msaa_sample_count) {
   return make_scoped_ptr<GpuRasterizer>(new GpuRasterizer(
       context_provider, resource_provider, use_distance_field_text,
       threaded_gpu_rasterization_enabled, msaa_sample_count));
 }
 
 GpuRasterizer::GpuRasterizer(ContextProvider* context_provider,
                              ResourceProvider* resource_provider,
                              bool use_distance_field_text,
                              bool threaded_gpu_rasterization_enabled,
                              int msaa_sample_count)
     : resource_provider_(resource_provider),
       use_distance_field_text_(use_distance_field_text),
       threaded_gpu_rasterization_enabled_(threaded_gpu_rasterization_enabled),
-      msaa_sample_count_(msaa_sample_count) {
+      msaa_sample_count_(msaa_sample_count),
+      maxTextures_(kMaxGaneshResourceCacheCount),
+      maxTextureBytes_(kMaxGaneshResourceCacheBytes),
+      cache_cleared_(false) {
+  ContextProvider* worker_context_provider =

[vmiura, 2015/04/02 19:12:34]

As this is in three places, please refactor the code for setting cache limits to
a single method.

[sohanjg, 2015/04/08 09:00:31]

Done.

+      resource_provider_->output_surface()->worker_context_provider();
+
+  // The context lock must be held while accessing the context on a
+  // worker thread.
+  base::AutoLock context_lock(*worker_context_provider->GetLock());
+
+  // Allow context to bind to current thread.
+  worker_context_provider->DetachFromThread();
+
+  GrContext* gr_context = worker_context_provider->GrContext();
+  if (gr_context)
+    gr_context->setResourceCacheLimits(maxTextures_, maxTextureBytes_);
+
+  // Allow context to bind to other threads.
+  worker_context_provider->DetachFromThread();
 }
 
 GpuRasterizer::~GpuRasterizer() {
 }
 
 PrepareTilesMode GpuRasterizer::GetPrepareTilesMode() {
   return threaded_gpu_rasterization_enabled_
              ? PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES
              : PrepareTilesMode::PREPARE_NONE;
 }
@@ skipping 134 matching lines @@
   canvas->save();
   tile->raster_source()->PlaybackToCanvas(canvas.get(), tile->content_rect(),
                                           tile->contents_scale());
   canvas->restore();
 
   // Add the canvas and recorded picture to |multi_picture_draw_|.
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
   multi_picture_draw_.add(sk_surface->getCanvas(), picture.get());
 }
 
+void GpuRasterizer::SetZeroMemoryLimit() {
+  ContextProvider* context_provider =
+      resource_provider()->output_surface()->worker_context_provider();
+
+  // The context lock must be held while accessing the context on a
+  // worker thread.
+  base::AutoLock context_lock(*context_provider->GetLock());
+
+  // Allow context to bind to current thread.
+  context_provider->DetachFromThread();
+
+  // Clear resource cache.
+  GrContext* gr_context = context_provider->GrContext();
+  DCHECK(gr_context);
+  gr_context->setResourceCacheLimits(0, 0);
+
+  // Allow context to bind to other threads.
+  context_provider->DetachFromThread();
+  cache_cleared_ = true;
+}
+
+void GpuRasterizer::SetDefaultMemoryLimit() {
+  if (!cache_cleared_)
+    return;
+
+  ContextProvider* context_provider =
+      resource_provider()->output_surface()->worker_context_provider();
+
+  // The context lock must be held while accessing the context on a
+  // worker thread.
+  base::AutoLock context_lock(*context_provider->GetLock());
+
+  // Allow context to bind to current thread.
+  context_provider->DetachFromThread();
+
+  // Restore resource cache.
+  GrContext* gr_context = context_provider->GrContext();
+  DCHECK(gr_context);
+  gr_context->setResourceCacheLimits(maxTextures_, maxTextureBytes_);
+
+  // Allow context to bind to other threads.
+  context_provider->DetachFromThread();
+}
+
 }  // namespace cc