aw: Move clearView implementaiton to native

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 211 matching lines @@
       java_helper_(java_helper),
       web_contents_(web_contents),
       compositor_(NULL),
       is_paused_(false),
       view_visible_(false),
       window_visible_(false),
       attached_to_window_(false),
       dip_scale_(0.0),
       page_scale_factor_(1.0),
       on_new_picture_enable_(false),
+      clear_view_(false),
       compositor_needs_continuous_invalidate_(false),
       block_invalidates_(false),
       width_(0),
       height_(0),
       hardware_initialized_(false),
       hardware_failed_(false),
       last_egl_context_(NULL),
       manager_key_(g_view_renderer_manager.Get().NullKey()) {
   CHECK(web_contents_);
   web_contents_->SetUserData(kUserDataKey, new UserData(this));
@@ skipping 126 matching lines @@
 
 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 (clear_view_)
+    return false;
   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);
 }
 
@@ skipping 232 matching lines @@
     CompositeSW(rec_canvas);
   picture->endRecording();
   return picture;
 }
 
 void InProcessViewRenderer::EnableOnNewPicture(bool enabled) {
   on_new_picture_enable_ = enabled;
   EnsureContinuousInvalidation(NULL, false);
 }
 
+void InProcessViewRenderer::ClearView() {
+  TRACE_EVENT_INSTANT0("android_webview",
+                       "InProcessViewRenderer::ClearView",
+                       TRACE_EVENT_SCOPE_THREAD);
+  if (clear_view_)
+    return;
+
+  clear_view_ = true;
+  // Always invalidate ignoring the compositor to actually clear the webview.
+  EnsureContinuousInvalidation(NULL, true);
+}
+
 void InProcessViewRenderer::SetIsPaused(bool paused) {
   TRACE_EVENT_INSTANT1("android_webview",
                        "InProcessViewRenderer::SetIsPaused",
                        TRACE_EVENT_SCOPE_THREAD,
                        "paused",
                        paused);
   is_paused_ = paused;
   EnsureContinuousInvalidation(NULL, false);
 }
 
@@ skipping 145 matching lines @@
   if (scroll_offset_dip_ == scroll_offset_dip)
     return;
 
   scroll_offset_dip_ = scroll_offset_dip;
 
   if (compositor_)
     compositor_->DidChangeRootLayerScrollOffset();
 }
 
 void InProcessViewRenderer::DidUpdateContent() {
+  TRACE_EVENT_INSTANT0("android_webview",
+                       "InProcessViewRenderer::DidUpdateContent",
+                       TRACE_EVENT_SCOPE_THREAD);
+  clear_view_ = false;
+  EnsureContinuousInvalidation(NULL, false);
   if (on_new_picture_enable_)
     client_->OnNewPicture();
 }
 
 void InProcessViewRenderer::SetMaxRootLayerScrollOffset(
     gfx::Vector2dF new_value_dip) {
   DCHECK_GT(dip_scale_, 0);
 
   max_scroll_offset_dip_ = new_value_dip;
   DCHECK_LE(0, max_scroll_offset_dip_.x());
@@ skipping 71 matching lines @@
 
 void InProcessViewRenderer::EnsureContinuousInvalidation(
     AwDrawGLInfo* draw_info,
     bool invalidate_ignore_compositor) {
   // This method should be called again when any of these conditions change.
   bool need_invalidate =
       compositor_needs_continuous_invalidate_ || invalidate_ignore_compositor;
   if (!need_invalidate || block_invalidates_)
     return;
 
+  // Always call view invalidate. We rely the Android framework to ignore the
+  // invalidate when it's not needed such as when view is not visible.
   if (draw_info) {
     draw_info->dirty_left = cached_global_visible_rect_.x();
     draw_info->dirty_top = cached_global_visible_rect_.y();
     draw_info->dirty_right = cached_global_visible_rect_.right();
     draw_info->dirty_bottom = cached_global_visible_rect_.bottom();
     draw_info->status_mask |= AwDrawGLInfo::kStatusMaskDraw;
   } else {
     client_->PostInvalidate();
   }
 
-  bool throttle_fallback_tick = (is_paused_ && !on_new_picture_enable_) ||
-                                (attached_to_window_ && !window_visible_);
+  // Stop fallback ticks when one of these is true.
+  // 1) Webview is paused. Also need to check we are not in clear view since
+  // paused, offscreen still expect clear view to recover.
+  // 2) If we are attached to window and the window is not visible (eg when
+  // app is in the background). We are sure in this case the webview is used
+  // "on-screen" but that updates are not needed when in the background.
+  bool throttle_fallback_tick =
+      (is_paused_ && !clear_view_) || (attached_to_window_ && !window_visible_);
   if (throttle_fallback_tick)
     return;
 
   block_invalidates_ = compositor_needs_continuous_invalidate_;
 
   // Unretained here is safe because the callback is cancelled when
   // |fallback_tick_| is destroyed.
   fallback_tick_.Reset(base::Bind(&InProcessViewRenderer::FallbackTickFired,
                                   base::Unretained(this)));
 
@@ skipping 62 matching lines @@
   base::StringAppendF(&str,
                       "scroll_at_start_of_frame: %s ",
                       scroll_at_start_of_frame_.ToString().c_str());
   base::StringAppendF(
       &str, "scroll_offset_dip: %s ", scroll_offset_dip_.ToString().c_str());
   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_);
   if (draw_info) {
     base::StringAppendF(&str,
                         "clip left top right bottom: [%d %d %d %d] ",
                         draw_info->clip_left,
                         draw_info->clip_top,
                         draw_info->clip_right,
                         draw_info->clip_bottom);
     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