OffscreenPreRaster and its plumbings

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 "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 50 matching lines @@
       compositor_(NULL),
       is_paused_(false),
       view_visible_(false),
       window_visible_(false),
       attached_to_window_(false),
       hardware_enabled_(false),
       dip_scale_(0.0),
       page_scale_factor_(1.0),
       on_new_picture_enable_(false),
       clear_view_(false),
+      offscreen_pre_raster_(false),
       compositor_needs_continuous_invalidate_(false),
       invalidate_after_composite_(false),
       block_invalidates_(false),
       fallback_tick_pending_(false) {
 }
 
 BrowserViewRenderer::~BrowserViewRenderer() {
 }
 
 SharedRendererState* BrowserViewRenderer::GetAwDrawGLViewContext() {
@@ skipping 40 matching lines @@
   // 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();
 }
 
 size_t BrowserViewRenderer::CalculateDesiredMemoryPolicy() {
   if (g_memory_override_in_bytes)
     return static_cast<size_t>(g_memory_override_in_bytes);
 
-  size_t width = last_on_draw_global_visible_rect_.width();
-  size_t height = last_on_draw_global_visible_rect_.height();
+  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;
 }
 
 void BrowserViewRenderer::PrepareToDraw(const gfx::Vector2d& scroll,
                                         const gfx::Rect& global_visible_rect) {
   last_on_draw_scroll_offset_ = scroll;
@@ skipping 28 matching lines @@
   if (!hardware_enabled_) {
     TRACE_EVENT0("android_webview", "InitializeHwDraw");
     hardware_enabled_ = compositor_->InitializeHwDraw();
   }
   if (!hardware_enabled_) {
     TRACE_EVENT_INSTANT0("android_webview", "EarlyOut_HardwareNotEnabled",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
-  if (last_on_draw_global_visible_rect_.IsEmpty() &&
-      parent_draw_constraints_.surface_rect.IsEmpty()) {
-    TRACE_EVENT_INSTANT0("android_webview",
-                         "EarlyOut_EmptyVisibleRect",
-                         TRACE_EVENT_SCOPE_THREAD);
-    shared_renderer_state_.SetForceInvalidateOnNextDrawGLOnUI(true);
-    return true;
-  }
-
   ReturnResourceFromParent();
   if (shared_renderer_state_.HasCompositorFrameOnUI()) {
     TRACE_EVENT_INSTANT0("android_webview",
                          "EarlyOut_PreviousFrameUnconsumed",
                          TRACE_EVENT_SCOPE_THREAD);
     DidSkipCompositeInDraw();
     return true;
   }
 
   scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
@@ skipping 15 matching lines @@
   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
   // applied onto the layer so global visible rect does not make sense here.
   // In this case, just use the surface rect for tiling.
   gfx::Rect viewport_rect_for_tile_priority;
-  if (parent_draw_constraints_.is_layer ||
-      last_on_draw_global_visible_rect_.IsEmpty()) {
-    viewport_rect_for_tile_priority = parent_draw_constraints_.surface_rect;
-  } else {
-    viewport_rect_for_tile_priority = last_on_draw_global_visible_rect_;
+
+  // Leave viewport_rect_for_tile_priority empty if offscreen_pre_raster_ is on.
+  if (!offscreen_pre_raster_) {
+    if (parent_draw_constraints_.is_layer ||
+        last_on_draw_global_visible_rect_.IsEmpty()) {
+      viewport_rect_for_tile_priority = parent_draw_constraints_.surface_rect;
+    } else {
+      viewport_rect_for_tile_priority = last_on_draw_global_visible_rect_;
+    }
   }
 
   scoped_ptr<cc::CompositorFrame> frame =
       compositor_->DemandDrawHw(surface_size,
                                 gfx::Transform(),
                                 viewport,
                                 clip,
                                 viewport_rect_for_tile_priority,
                                 transform_for_tile_priority);
   if (frame.get())
@@ skipping 79 matching lines @@
                        "BrowserViewRenderer::ClearView",
                        TRACE_EVENT_SCOPE_THREAD);
   if (clear_view_)
     return;
 
   clear_view_ = true;
   // Always invalidate ignoring the compositor to actually clear the webview.
   EnsureContinuousInvalidation(true, false);
 }
 
+void BrowserViewRenderer::SetOffscreenPreRaster(bool enable) {
+  // TODO(hush): anything to do when the setting is toggled?
+  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;
   EnsureContinuousInvalidation(false, false);
 }
 
@@ skipping 407 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