[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"
 #include "android_webview/common/aw_switches.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "android_webview/public/browser/draw_sw.h"
 #include "base/android/jni_android.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
-#include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/service/in_process_command_buffer.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkBitmapDevice.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/utils/SkCanvasStateUtils.h"
@@ skipping 276 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) {
+  // 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;
+
+  // Nothing to drop.
+  if (!attached_to_window_ || !hardware_initialized_ || !compositor_)
+    return;
+
+  // Do not release resources on view we expect to get DrawGL soon.
+  if (level < TRIM_MEMORY_BACKGROUND) {
+    client_->UpdateGlobalVisibleRect();
+    if (view_visible_ && window_visible_ &&
+        !cached_global_visible_rect_.IsEmpty()) {
+      return;
+    }
+  }
+
+  if (!eglGetCurrentContext()) {
+    NOTREACHED();
+    return;
+  }
+
+  // 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;
+
+  TRACE_EVENT0("android_webview", "InProcessViewRenderer::TrimMemory");
+  ScopedAppGLStateRestore state_restore(
+      ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
+  gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
+  ScopedAllowGL allow_gl;
+
+  SetMemoryPolicy(policy);
+  ForceFakeCompositeSW();
+}
+
+void InProcessViewRenderer::SetMemoryPolicy(
+    content::SynchronousCompositorMemoryPolicy& new_policy) {
+  if (memory_policy_ == new_policy)
+    return;
+
+  memory_policy_ = new_policy;
+  compositor_->SetMemoryPolicy(memory_policy_);
+}
+
 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()) {
@@ skipping 87 matching lines @@
   // 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 *
                        cached_global_visible_rect_.width() *
                        cached_global_visible_rect_.height();
   // Round up to a multiple of kMemoryAllocationStep.
   policy.bytes_limit =
       (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
   policy.num_resources_limit = kMaxNumTilesToFillDisplay * g_memory_multiplier;
-  compositor_->SetMemoryPolicy(policy);
+  SetMemoryPolicy(policy);
 
   DCHECK(gl_surface_);
   gl_surface_->SetBackingFrameBufferObject(
       state_restore.framebuffer_binding_ext());
 
   gfx::Transform transform;
   transform.matrix().setColMajorf(draw_info->transform);
   transform.Translate(scroll_at_start_of_frame_.x(),
                       scroll_at_start_of_frame_.y());
   gfx::Rect clip_rect(draw_info->clip_left,
@@ skipping 194 matching lines @@
 
 void InProcessViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview",
                "InProcessViewRenderer::OnDetachedFromWindow");
 
   NoLongerExpectsDrawGL();
   if (hardware_initialized_) {
     DCHECK(compositor_);
 
     ScopedAppGLStateRestore state_restore(
-        ScopedAppGLStateRestore::MODE_DETACH_FROM_WINDOW);
+        ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
     gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
     ScopedAllowGL allow_gl;
     compositor_->ReleaseHwDraw();
     hardware_initialized_ = false;
   }
 
   gl_surface_ = NULL;
   attached_to_window_ = false;
 }
 
@@ skipping 210 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_)
+    ForceFakeCompositeSW();
+}
+
+void InProcessViewRenderer::ForceFakeCompositeSW() {
+  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