[Android WebView] OnMemoryPressure to drop tile memory

android_webview/browser/in_process_view_renderer.cc

 // Copyright 2013 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 "android_webview/browser/in_process_view_renderer.h"
 
 #include <android/bitmap.h>
 
 #include "android_webview/browser/aw_gl_surface.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
@@ skipping 298 matching lines @@
   std::stringstream size;
   size << default_tile_size;
   cl->AppendSwitchASCII(switches::kDefaultTileWidth, size.str());
   cl->AppendSwitchASCII(switches::kDefaultTileHeight, size.str());
 }
 
 bool InProcessViewRenderer::RequestProcessGL() {
   return client_->RequestDrawGL(NULL);
 }
 
+void InProcessViewRenderer::TrimMemory(int level) {
+  // Nothing to drop.
+  if (!attached_to_window_ || !hardware_initialized_ || !compositor_)
+    return;
+
+  // Do not release resources on view we expect to get DrawGL soon.
+  client_->UpdateGlobalVisibleRect();
+  if (view_visible_ && window_visible_ &&
+      !cached_global_visible_rect_.IsEmpty()) {
+    return;
+  }
+
+  if (!eglGetCurrentContext()) {
+    NOTREACHED();
+    return;
+  }
+
+  TRACE_EVENT0("android_webview", "InProcessViewRenderer::TrimMemory");
+  ScopedAppGLStateRestore state_restore(ScopedAppGLStateRestore::MODE_ON_TRIM);
+  gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
+  ScopedAllowGL allow_gl;
+
+  // 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;
+  compositor_->SetMemoryPolicy(policy);
+  ForceCompositeSW();

[boliu, 2013/10/02 02:14:04]

Mad hacks, but don't really have a better idea for now.

We can add checks that this isn't repeated for no reason.

+}
+
 void InProcessViewRenderer::UpdateCachedGlobalVisibleRect() {
   client_->UpdateGlobalVisibleRect();
 }
 
 bool InProcessViewRenderer::OnDraw(jobject java_canvas,
                                    bool is_hardware_canvas,
                                    const gfx::Vector2d& scroll,
                                    const gfx::Rect& clip) {
   scroll_at_start_of_frame_  = scroll;
   if (is_hardware_canvas && attached_to_window_ && HardwareEnabled()) {
     // We should be performing a hardware draw here. If we don't have the
     // comositor yet or if RequestDrawGL fails, it means we failed this draw and
     // thus return false here to clear to background color for this draw.
     return compositor_ && client_->RequestDrawGL(java_canvas);
   }
   // Perform a software draw
   return DrawSWInternal(java_canvas, clip);
 }
 
 bool InProcessViewRenderer::InitializeHwDraw() {
   TRACE_EVENT0("android_webview", "InitializeHwDraw");
   DCHECK(!gl_surface_);
   gl_surface_  = new AwGLSurface;
   hardware_failed_ = !compositor_->InitializeHwDraw(gl_surface_);
   hardware_initialized_ = true;
 
-  if (hardware_failed_)
+  if (hardware_failed_) {
     gl_surface_ = NULL;
+  }
 
   return !hardware_failed_;
 }
 
 void InProcessViewRenderer::DrawGL(AwDrawGLInfo* draw_info) {
   TRACE_EVENT0("android_webview", "InProcessViewRenderer::DrawGL");
 
   manager_key_ = g_view_renderer_manager.Get().DidDrawGL(manager_key_, this);
 
   // We need to watch if the current Android context has changed and enforce
   // a clean-up in the compositor.
   EGLContext current_context = eglGetCurrentContext();
   if (!current_context) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NullEGLContext", TRACE_EVENT_SCOPE_THREAD);
     return;
   }
 
   ScopedAppGLStateRestore state_restore(ScopedAppGLStateRestore::MODE_DRAW);
   gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
   ScopedAllowGL allow_gl;
 
   if (!attached_to_window_) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NotAttached", TRACE_EVENT_SCOPE_THREAD);
     return;
   }
 
   if (draw_info->mode == AwDrawGLInfo::kModeProcess) {
-    TRACE_EVENT_INSTANT0(
-        "android_webview", "EarlyOut_ModeProcess", TRACE_EVENT_SCOPE_THREAD);
+    TRACE_EVENT0("android_webview", "EarlyOut_ModeProcess");

[joth, 2013/10/02 10:47:01]

intended edit?

[boliu, 2013/10/02 14:09:55]

reverted

     return;
   }
 
   if (compositor_ && !hardware_initialized_) {
     if (InitializeHwDraw()) {
       last_egl_context_ = current_context;
     } else {
       TRACE_EVENT_INSTANT0(
           "android_webview", "EarlyOut_HwInitFail", TRACE_EVENT_SCOPE_THREAD);
       LOG(ERROR) << "WebView hardware initialization failed";
@@ skipping 474 matching lines @@
 
 void InProcessViewRenderer::FallbackTickFired() {
   TRACE_EVENT1("android_webview",
                "InProcessViewRenderer::FallbackTickFired",
                "compositor_needs_continuous_invalidate_",
                compositor_needs_continuous_invalidate_);
 
   // This should only be called if OnDraw or DrawGL did not come in time, which
   // means block_invalidates_ must still be true.
   DCHECK(block_invalidates_);
-  if (compositor_needs_continuous_invalidate_ && compositor_) {
-    SkBitmapDevice device(SkBitmap::kARGB_8888_Config, 1, 1);
-    SkCanvas canvas(&device);
-    CompositeSW(&canvas);
-  }
+  if (compositor_needs_continuous_invalidate_ && compositor_)
+    ForceCompositeSW();
+}
+
+void InProcessViewRenderer::ForceCompositeSW() {

[joth, 2013/10/02 10:47:01]

maybe ForceFakeCompostieSW() will make it clear (at callsite) that this isn't
doing anything useful

[boliu, 2013/10/02 14:09:55]

Done.

+  DCHECK(compositor_);
+  SkBitmapDevice device(SkBitmap::kARGB_8888_Config, 1, 1);
+  SkCanvas canvas(&device);
+  CompositeSW(&canvas);
 }
 
 bool InProcessViewRenderer::CompositeSW(SkCanvas* canvas) {
   DCHECK(compositor_);
 
   fallback_tick_.Cancel();
   block_invalidates_ = true;
   bool result = compositor_->DemandDrawSw(canvas);
   block_invalidates_ = false;
   EnsureContinuousInvalidation(NULL, false);
@@ skipping 38 matching lines @@
     base::StringAppendF(&str,
                         "surface width height: [%d %d] ",
                         draw_info->width,
                         draw_info->height);
     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
   }
   return str;
 }
 
 }  // namespace android_webview