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 6136aeab9af4aa988b0b410093a94130fa56e37f..881bfd1dd13631a674ca0072b8a0f1bfc14169ad 100644
--- a/android_webview/browser/hardware_renderer.cc
+++ b/android_webview/browser/hardware_renderer.cc
@@ -6,12 +6,12 @@
 
 #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/scoped_app_gl_state_restore.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/strings/string_number_conversions.h"
+#include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
@@ -19,18 +19,10 @@
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/transform.h"
 
-using content::BrowserThread;
-
 namespace android_webview {
 
 namespace {
 
-// Used to calculate memory and resource allocation. Determined experimentally.
-const size_t g_memory_multiplier = 10;
-const size_t g_num_gralloc_limit = 150;
-const size_t kBytesPerPixel = 4;
-const size_t kMemoryAllocationStep = 5 * 1024 * 1024;
-
 base::LazyInstance<scoped_refptr<internal::DeferredGpuCommandService> >
     g_service = LAZY_INSTANCE_INITIALIZER;
 
@@ -39,7 +31,7 @@ base::LazyInstance<scoped_refptr<internal::DeferredGpuCommandService> >
 HardwareRenderer::HardwareRenderer(SharedRendererState* state)
     : shared_renderer_state_(state),
       last_egl_context_(eglGetCurrentContext()),
-      manager_key_(GLViewRendererManager::GetInstance()->PushBack(
+      renderer_manager_key_(GLViewRendererManager::GetInstance()->PushBack(
           shared_renderer_state_)) {
   DCHECK(last_egl_context_);
   if (!g_service.Get()) {
@@ -59,8 +51,8 @@ HardwareRenderer::HardwareRenderer(SharedRendererState* state)
 }
 
 HardwareRenderer::~HardwareRenderer() {
-  GLViewRendererManager* mru = GLViewRendererManager::GetInstance();
-  mru->Remove(manager_key_);
+  GLViewRendererManager* render_manager = GLViewRendererManager::GetInstance();
+  render_manager->Remove(renderer_manager_key_);
 
   ScopedAppGLStateRestore state_restore(
       ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
@@ -72,7 +64,7 @@ HardwareRenderer::~HardwareRenderer() {
 
 bool HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info, DrawGLResult* result) {
   TRACE_EVENT0("android_webview", "HardwareRenderer::DrawGL");
-  GLViewRendererManager::GetInstance()->DidDrawGL(manager_key_);
+  GLViewRendererManager::GetInstance()->DidDrawGL(renderer_manager_key_);
   const DrawGLInput input = shared_renderer_state_->GetDrawGLInput();
 
   // We need to watch if the current Android context has changed and enforce
@@ -93,17 +85,7 @@ bool HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info, DrawGLResult* result) {
   if (draw_info->mode == AwDrawGLInfo::kModeProcess)
     return false;
 
-  // Update memory budget. This will no-op in compositor if the policy has not
-  // changed since last draw.
-  content::SynchronousCompositorMemoryPolicy policy;
-  policy.bytes_limit = g_memory_multiplier * kBytesPerPixel *
-                       input.global_visible_rect.width() *
-                       input.global_visible_rect.height();
-  // Round up to a multiple of kMemoryAllocationStep.
-  policy.bytes_limit =
-      (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
-  policy.num_resources_limit = g_num_gralloc_limit;
-  SetMemoryPolicy(policy);
+  SetCompositorMemoryPolicy();
 
   gl_surface_->SetBackingFrameBufferObject(
       state_restore.framebuffer_binding_ext());
@@ -140,56 +122,14 @@ bool HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info, DrawGLResult* result) {
   return did_draw;
 }
 
-bool HardwareRenderer::TrimMemory(int level, bool visible) {
-  // Constants from Android ComponentCallbacks2.
-  enum {
-    TRIM_MEMORY_RUNNING_LOW = 10,
-    TRIM_MEMORY_UI_HIDDEN = 20,
-    TRIM_MEMORY_BACKGROUND = 40,
-  };
-
-  // Not urgent enough. TRIM_MEMORY_UI_HIDDEN is treated specially because
-  // it does not indicate memory pressure, but merely that the app is
-  // backgrounded.
-  if (level < TRIM_MEMORY_RUNNING_LOW || level == TRIM_MEMORY_UI_HIDDEN)
-    return false;
-
-  // Do not release resources on view we expect to get DrawGL soon.
-  if (level < TRIM_MEMORY_BACKGROUND && visible)
-    return false;
-
-  if (!eglGetCurrentContext()) {
-    NOTREACHED();
-    return false;
+void HardwareRenderer::SetCompositorMemoryPolicy() {
+  if (shared_renderer_state_->IsMemoryPolicyDirty()) {
+    content::SynchronousCompositorMemoryPolicy policy =
+        shared_renderer_state_->GetMemoryPolicy();
+    // Memory policy is set by BrowserViewRenderer on UI thread.
+    shared_renderer_state_->GetCompositor()->SetMemoryPolicy(policy);
+    shared_renderer_state_->SetMemoryPolicyDirty(false);
   }
-
-  DCHECK_EQ(last_egl_context_, eglGetCurrentContext());
-
-  // 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)
-    return false;
-
-  TRACE_EVENT0("android_webview", "HardwareRenderer::TrimMemory");
-  ScopedAppGLStateRestore state_restore(
-      ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
-  internal::ScopedAllowGL allow_gl;
-
-  SetMemoryPolicy(policy);
-  return true;
-}
-
-void HardwareRenderer::SetMemoryPolicy(
-    content::SynchronousCompositorMemoryPolicy& new_policy) {
-  if (memory_policy_ == new_policy)
-    return;
-
-  memory_policy_ = new_policy;
-  shared_renderer_state_->GetCompositor()->
-      SetMemoryPolicy(memory_policy_);
 }
 
 // static