TrimMemory strategy while offscreenPreRaster is on.

android_webview/browser/browser_view_renderer.cc

 // Copyright 2014 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/browser_view_renderer.h"
 
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/child_frame.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 100 matching lines @@
 }
 
 SharedRendererState* BrowserViewRenderer::GetAwDrawGLViewContext() {
   return &shared_renderer_state_;
 }
 
 bool BrowserViewRenderer::RequestDrawGL(bool wait_for_completion) {
   return client_->RequestDrawGL(wait_for_completion);
 }
 
-// This function updates the resource allocation in GlobalTileManager.
 void BrowserViewRenderer::TrimMemory(const int level, const bool visible) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   // Constants from Android ComponentCallbacks2.
   enum {
     TRIM_MEMORY_RUNNING_LOW = 10,
     TRIM_MEMORY_UI_HIDDEN = 20,
     TRIM_MEMORY_BACKGROUND = 40,
     TRIM_MEMORY_MODERATE = 60,
   };
 
   // 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;
 
   // Do not release resources on view we expect to get DrawGL soon.
   if (level < TRIM_MEMORY_BACKGROUND && visible)
     return;
 
   // Nothing to drop.
   if (!compositor_ || !hardware_enabled_)
     return;
 
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::TrimMemory");
 
-  // Drop everything in hardware.
+  // If offscreen pre-raster is disabled, drop everything in hardware. Otherwise
+  // keep the tiles and just delete the HardwareRenderer.
   if (level >= TRIM_MEMORY_MODERATE) {
-    shared_renderer_state_.ReleaseHardwareDrawIfNeededOnUI();
+    if (offscreen_pre_raster_)
+      shared_renderer_state_.DeleteHardwareRendererOnUI();
+    else
+      shared_renderer_state_.ReleaseHardwareDrawIfNeededOnUI();
     return;
   }
 
   // Just set the memory limit to 0 and drop all tiles. This will be reset to
   // normal levels in the next DrawGL call.
-  compositor_->SetMemoryPolicy(0u);
-  ForceFakeCompositeSW();
+  if (!offscreen_pre_raster_)
+    compositor_->SetMemoryPolicy(0u);
 }
 
-size_t BrowserViewRenderer::CalculateDesiredMemoryPolicy() {
-  if (g_memory_override_in_bytes)
-    return static_cast<size_t>(g_memory_override_in_bytes);
+void BrowserViewRenderer::UpdateMemoryPolicy() {
+  if (!hardware_enabled_) {
+    compositor_->SetMemoryPolicy(0u);
+    return;
+  }
 
-  gfx::Rect interest_rect = offscreen_pre_raster_
-                                ? gfx::Rect(size_)
-                                : last_on_draw_global_visible_rect_;
-  size_t width = interest_rect.width();
-  size_t height = interest_rect.height();
-  size_t bytes_limit = kMemoryMultiplier * kBytesPerPixel * width * height;
-  // Round up to a multiple of kMemoryAllocationStep.
-  bytes_limit =
-      (bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
-  return bytes_limit;
+  size_t bytes_limit = 0u;
+  if (g_memory_override_in_bytes) {
+    bytes_limit = static_cast<size_t>(g_memory_override_in_bytes);
+  } else {
+    gfx::Rect interest_rect = offscreen_pre_raster_
+                                  ? gfx::Rect(size_)
+                                  : last_on_draw_global_visible_rect_;
+    size_t width = interest_rect.width();
+    size_t height = interest_rect.height();
+    bytes_limit = kMemoryMultiplier * kBytesPerPixel * width * height;
+    // Round up to a multiple of kMemoryAllocationStep.
+    bytes_limit =
+        (bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
+  }
+
+  compositor_->SetMemoryPolicy(bytes_limit);
 }
 
 void BrowserViewRenderer::PrepareToDraw(const gfx::Vector2d& scroll,
                                         const gfx::Rect& global_visible_rect) {
   last_on_draw_scroll_offset_ = scroll;
   last_on_draw_global_visible_rect_ = global_visible_rect;
 }
 
 bool BrowserViewRenderer::CanOnDraw() {
   if (!compositor_) {
@@ skipping 22 matching lines @@
   shared_renderer_state_.SetScrollOffsetOnUI(last_on_draw_scroll_offset_);
   hardware_enabled_ = true;
 
   return CompositeHw();
 }
 
 bool BrowserViewRenderer::CompositeHw() {
   CancelFallbackTick();
 
   ReturnResourceFromParent();
-  compositor_->SetMemoryPolicy(CalculateDesiredMemoryPolicy());
+  UpdateMemoryPolicy();
 
   ParentCompositorDrawConstraints parent_draw_constraints =
       shared_renderer_state_.GetParentDrawConstraintsOnUI();
   gfx::Size surface_size(size_);
   gfx::Rect viewport(surface_size);
   gfx::Rect clip = viewport;
   gfx::Transform transform_for_tile_priority =
       parent_draw_constraints.transform;
 
   // If the WebView is on a layer, WebView does not know what transform is
@@ skipping 103 matching lines @@
                        TRACE_EVENT_SCOPE_THREAD);
   if (clear_view_)
     return;
 
   clear_view_ = true;
   // Always invalidate ignoring the compositor to actually clear the webview.
   PostInvalidateWithFallback();
 }
 
 void BrowserViewRenderer::SetOffscreenPreRaster(bool enable) {
-  // TODO(hush): anything to do when the setting is toggled?
+  if (offscreen_pre_raster_ != enable && compositor_)
+    UpdateMemoryPolicy();
+
   offscreen_pre_raster_ = enable;
 }
 
 void BrowserViewRenderer::SetIsPaused(bool paused) {
   TRACE_EVENT_INSTANT1("android_webview",
                        "BrowserViewRenderer::SetIsPaused",
                        TRACE_EVENT_SCOPE_THREAD,
                        "paused",
                        paused);
   is_paused_ = paused;
@@ skipping 362 matching lines @@
   base::StringAppendF(&str,
                       "overscroll_rounding_error_: %s ",
                       overscroll_rounding_error_.ToString().c_str());
   base::StringAppendF(
       &str, "on_new_picture_enable: %d ", on_new_picture_enable_);
   base::StringAppendF(&str, "clear_view: %d ", clear_view_);
   return str;
 }
 
 }  // namespace android_webview