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

cc/resources/gpu_rasterizer.cc

Index: cc/resources/gpu_rasterizer.cc
diff --git a/cc/resources/gpu_rasterizer.cc b/cc/resources/gpu_rasterizer.cc
index d810386da94a2c9ff36475e59590e2d79ed92787..5a9a8923c200434df6d9c6c2e7b8587a54503955 100644
--- a/cc/resources/gpu_rasterizer.cc
+++ b/cc/resources/gpu_rasterizer.cc
@@ -24,6 +24,17 @@
 #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
@@ -46,7 +57,11 @@ GpuRasterizer::GpuRasterizer(ContextProvider* context_provider,
     : 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() {
@@ -201,4 +216,32 @@ void GpuRasterizer::AddToMultiPictureDraw(const Tile* tile,
   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