Global GPU memory manager for android webview

android_webview/browser/hardware_renderer.cc

Index: android_webview/browser/hardware_renderer.cc
diff --git a/android_webview/browser/hardware_renderer.cc b/android_webview/browser/hardware_renderer.cc
index 59356dbe7aea8656256a2fcba77c99ddf9e09d4d..bd334d82b7ede7872cdc0fe2bb86620d44858d13 100644
--- a/android_webview/browser/hardware_renderer.cc
+++ b/android_webview/browser/hardware_renderer.cc
@@ -7,6 +7,7 @@
 #include "android_webview/browser/aw_gl_surface.h"
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/gl_view_renderer_manager.h"
+#include "android_webview/browser/gpu_memory_manager.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/command_line.h"
@@ -40,6 +41,7 @@ HardwareRenderer::HardwareRenderer(SharedRendererState* state)
       manager_key_(GLViewRendererManager::GetInstance()->PushBack(
           shared_renderer_state_)) {
   DCHECK(last_egl_context_);
+
   if (!g_service.Get()) {
     g_service.Get() = new internal::DeferredGpuCommandService;
     content::SynchronousCompositor::SetGpuService(g_service.Get());
@@ -60,6 +62,9 @@ HardwareRenderer::~HardwareRenderer() {
   GLViewRendererManager* mru = GLViewRendererManager::GetInstance();
   mru->Remove(manager_key_);
 
+  content::SynchronousCompositorMemoryPolicy zero_policy;
+  SetMemoryPolicy(zero_policy);
+
   ScopedAppGLStateRestore state_restore(
       ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
   internal::ScopedAllowGL allow_gl;
@@ -158,10 +163,9 @@ bool HardwareRenderer::TrimMemory(int level, bool visible) {
 
   // Just set the memory limit to 0 and drop all tiles. This will be reset to
   // normal levels in the next DrawGL call.
-  content::SynchronousCompositorMemoryPolicy policy;
-  policy.bytes_limit = 0;
-  policy.num_resources_limit = 0;
-  if (memory_policy_ == policy)
+  content::SynchronousCompositorMemoryPolicy current_policy, zero_policy;
+  current_policy = GetMemoryPolicy();
+  if (current_policy == zero_policy)
     return false;
 
   TRACE_EVENT0("android_webview", "HardwareRenderer::TrimMemory");
@@ -169,18 +173,28 @@ bool HardwareRenderer::TrimMemory(int level, bool visible) {
       ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
   internal::ScopedAllowGL allow_gl;
 
-  SetMemoryPolicy(policy);
+  SetMemoryPolicy(zero_policy);
   return true;
 }
 
 void HardwareRenderer::SetMemoryPolicy(
     content::SynchronousCompositorMemoryPolicy& new_policy) {
-  if (memory_policy_ == new_policy)
+  content::SynchronousCompositorMemoryPolicy current_policy;
+  current_policy = GetMemoryPolicy();
+
+  if (current_policy == new_policy)
     return;
 
-  memory_policy_ = new_policy;
+  GpuMemoryManager::GetInstance()->UpdateResources(
+      current_policy, new_policy, manager_key_);

[boliu, 2014/04/08 03:06:45]

Too aggressive and not stable? And I think it doesn't actually work since you
don't force call ManageTiles.

Stability is probably the most important issue. If we solve that, the other two
shouldn't be problems anymore...

What if we do something like this:
First webview, use half of available
Next one comes, use quarter
etc...

If first one ever draws again, it can adjust itself.
If first one never draws again, then at some point, we start dropping its tiles.

That's just my first idea that came to mind.

+
   shared_renderer_state_->GetCompositor()->
-      SetMemoryPolicy(memory_policy_);
+      SetMemoryPolicy(new_policy);
+}
+
+const content::SynchronousCompositorMemoryPolicy&
+    HardwareRenderer::GetMemoryPolicy() const {
+  return shared_renderer_state_->GetCompositor()->GetMemoryPolicy();
 }
 
 // static