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;

[enne (OOO), 2015/04/08 17:19:34]

Maybe you could make these LayerTreeSettings, and then LayerTreeHost could call
SetMemoryLimits(cache_count, cache_bytes), taking into account visible=0 or hard
memory limit=0 itself?

[sohanjg, 2015/04/09 09:20:44]

OK, but the memory limit we are maintaining in the Impl side, do we have the
info in LTH to setthememorylimit there?

And we would need an additional commit to push the cache limits to the
rasterizer, will that be helpful ?

Or its still worth doing ?

[hendrikw, 2015/04/09 15:43:45]

I agree with enne (I think they meant LayerTreeHostImpl).  We've removed the
rasterizer abstraction, so this approach won't work anyway.

I don't like that we're duplicating these values in a third location.
third_party\skia\src\gpu\GrResourceCache.cpp(59)
webkit\common\gpu\grcontext_for_webgraphicscontext3d.cc(65)

+
+// 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),
+      max_textures_(kMaxGaneshResourceCacheCount),
+      max_texture_bytes_(kMaxGaneshResourceCacheBytes),
+      default_memory_limit_set_(true) {
+  SetGrCacheLimits(max_textures_, max_texture_bytes_);
 }
 
 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::SetMemoryLimits(bool visible, size_t memory_limit_bytes) {

[hendrikw, 2015/04/09 15:43:45]

Wouldn't it make sense to call freeGpuResources() instead of setting the limit
to 0 and back to max?  Then we wouldn't need to know what the defaults are, and
I think it would have the same effect (the tab is out of view, it shouldn't
create anymore resources, right?)

freeGpuResources will also clear more resource than setResourceCacheLimits, but
maybe this is a bad thing.

bsalomon@, freeGpuResources when we hide the tab, good? bad? really bad?

+  if (!visible || memory_limit_bytes == 0) {
+    SetGrCacheLimits(0, 0);
+    default_memory_limit_set_ = false;
+  } else if (!default_memory_limit_set_) {
+    SetGrCacheLimits(max_textures_, max_texture_bytes_);
+  }
+}
+
+void GpuRasterizer::SetGrCacheLimits(int textures, int texture_bytes) {
+  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();
+
+  GrContext* gr_context = context_provider->GrContext();
+  DCHECK(gr_context);
+  gr_context->setResourceCacheLimits(textures, texture_bytes);
+
+  // Allow context to bind to other threads.
+  context_provider->DetachFromThread();
+}
+
 }  // namespace cc