[Android WebView] Fallback tick

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/public/browser/draw_gl.h"
 #include "android_webview/public/browser/draw_sw.h"
@@ skipping 257 matching lines @@
 // Allows preventing extra copies of data when rendering.
 AwDrawSWFunctionTable* g_sw_draw_functions = NULL;
 
 // Tells if the Skia library versions in Android and Chromium are compatible.
 // If they are then it's possible to pass Skia objects like SkPictures to the
 // Android glue layer via the SW rendering functions.
 // If they are not, then additional copies and rasterizations are required
 // as a fallback mechanism, which will have an important performance impact.
 bool g_is_skia_version_compatible = false;
 
+const int64 kFallbackTickTimeoutInMilliseconds = 500;
+
 }  // namespace
 
 // static
 void BrowserViewRenderer::SetAwDrawSWFunctionTable(
     AwDrawSWFunctionTable* table) {
   g_sw_draw_functions = table;
   g_is_skia_version_compatible =
       g_sw_draw_functions->is_skia_version_compatible(&SkGraphics::GetVersion);
   LOG_IF(WARNING, !g_is_skia_version_compatible)
       << "Skia versions are not compatible, rendering performance will suffer.";
@@ skipping 24 matching lines @@
       block_invalidates_(false),
       width_(0),
       height_(0),
       attached_to_window_(false),
       hardware_initialized_(false),
       hardware_failed_(false),
       last_egl_context_(NULL) {
   CHECK(web_contents_);
   web_contents_->SetUserData(kUserDataKey, new UserData(this));
   content::SynchronousCompositor::SetClientForWebContents(web_contents_, this);
+
   // Currently the logic in this class relies on |compositor_| remaining NULL
   // until the DidInitializeCompositor() call, hence it is not set here.
 }
 
 InProcessViewRenderer::~InProcessViewRenderer() {
   CHECK(web_contents_);
   content::SynchronousCompositor::SetClientForWebContents(web_contents_, NULL);
   web_contents_->SetUserData(kUserDataKey, NULL);
   DCHECK(web_contents_ == NULL);  // WebContentsGone should have been called.
 }
 
 // static
 InProcessViewRenderer* InProcessViewRenderer::FromWebContents(
     content::WebContents* contents) {
   return UserData::GetInstance(contents);
 }
 
 void InProcessViewRenderer::WebContentsGone() {
   web_contents_ = NULL;
   compositor_ = NULL;
 }
 
 bool InProcessViewRenderer::OnDraw(jobject java_canvas,
                                    bool is_hardware_canvas,
                                    const gfx::Vector2d& scroll,
                                    const gfx::Rect& clip) {
+  fallback_tick_.Cancel();
   scroll_at_start_of_frame_  = scroll;
   if (is_hardware_canvas && attached_to_window_ && compositor_ &&
       HardwareEnabled() && client_->RequestDrawGL(java_canvas)) {
     // All set: we'll get a call on DrawGL when the time comes.
     return true;
   }
   // Perform a software draw
   block_invalidates_ = true;
   bool result = DrawSWInternal(java_canvas, clip);
   block_invalidates_ = false;
@@ skipping 90 matching lines @@
     if (!jbitmap.obj()) {
       TRACE_EVENT_INSTANT0("android_webview",
                            "EarlyOut_BitmapAllocFail",
                            TRACE_EVENT_SCOPE_THREAD);
       return false;
     }
 
     if (!RasterizeIntoBitmap(env, jbitmap,
                              clip.x() - scroll_at_start_of_frame_.x(),
                              clip.y() - scroll_at_start_of_frame_.y(),
-                             base::Bind(&InProcessViewRenderer::RenderSW,
+                             base::Bind(&InProcessViewRenderer::CompositeSW,
                                         base::Unretained(this)))) {
       TRACE_EVENT_INSTANT0("android_webview",
                            "EarlyOut_RasterizeFail",
                            TRACE_EVENT_SCOPE_THREAD);
       return false;
     }
 
     java_helper_->DrawBitmapIntoCanvas(env, jbitmap, jcanvas,
                                        clip.x(), clip.y());
     return true;
@@ skipping 19 matching lines @@
       SkRegion clip_region;
       size_t bytes_read = clip_region.readFromMemory(pixels->clip_region);
       DCHECK_EQ(pixels->clip_region_size, bytes_read);
       canvas.setClipRegion(clip_region);
     } else {
       canvas.clipRect(gfx::RectToSkRect(clip));
     }
     canvas.translate(scroll_at_start_of_frame_.x(),
                      scroll_at_start_of_frame_.y());
 
-    succeeded = RenderSW(&canvas);
+    succeeded = CompositeSW(&canvas);
   }
 
   sw_functions->release_pixels(pixels);
   return succeeded;
 }
 
 base::android::ScopedJavaLocalRef<jobject>
 InProcessViewRenderer::CapturePicture() {
   if (!GetAwDrawSWFunctionTable())
     return ScopedJavaLocalRef<jobject>();
@@ skipping 121 matching lines @@
 void InProcessViewRenderer::SetContinuousInvalidate(bool invalidate) {
   if (continuous_invalidate_ == invalidate)
     return;
 
   TRACE_EVENT_INSTANT1("android_webview",
                        "InProcessViewRenderer::SetContinuousInvalidate",
                        TRACE_EVENT_SCOPE_THREAD,
                        "invalidate",
                        invalidate);
   continuous_invalidate_ = invalidate;
-  // TODO(boliu): Handle if not attached to window case.
   EnsureContinuousInvalidation(NULL);
 }
 
 void InProcessViewRenderer::SetDipScale(float dip_scale) {
   dip_scale_ = dip_scale;
   CHECK(dip_scale_ > 0);
 }
 
 void InProcessViewRenderer::ScrollTo(gfx::Vector2d new_value) {
   DCHECK(dip_scale_ > 0);
@@ skipping 40 matching lines @@
   if (continuous_invalidate_ && !block_invalidates_) {
     if (draw_info) {
       draw_info->dirty_left = draw_info->clip_left;
       draw_info->dirty_top = draw_info->clip_top;
       draw_info->dirty_right = draw_info->clip_right;
       draw_info->dirty_bottom = draw_info->clip_bottom;
       draw_info->status_mask |= AwDrawGLInfo::kStatusMaskDraw;
     } else {
       client_->PostInvalidate();
     }
+
+    // Unretained here is safe because the callback is cancelled when
+    // |fallback_tick_| is destroyed.
+    fallback_tick_.Reset(base::Bind(&InProcessViewRenderer::FallbackTickFired,
+                                    base::Unretained(this)));
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        fallback_tick_.callback(),
+        base::TimeDelta::FromMilliseconds(kFallbackTickTimeoutInMilliseconds));
+
     block_invalidates_ = true;
   }
 }
 
-bool InProcessViewRenderer::RenderSW(SkCanvas* canvas) {
-  // TODO(joth): BrowserViewRendererImpl had a bunch of logic for dpi and page
-  // scale here. Determine what if any needs bringing over to this class.
-  return CompositeSW(canvas);
+void InProcessViewRenderer::FallbackTickFired() {
+  TRACE_EVENT1("android_webview",
+               "InProcessViewRenderer::FallbackTickFired",
+               "continuous_invalidate_",
+               continuous_invalidate_);
+  if (continuous_invalidate_) {
+    SkDevice device(SkBitmap::kARGB_8888_Config, 1, 1);
+    SkCanvas canvas(&device);
+    block_invalidates_ = true;
+    CompositeSW(&canvas);
+  }
+  block_invalidates_ = false;
+  EnsureContinuousInvalidation(NULL);
 }
 
 bool InProcessViewRenderer::CompositeSW(SkCanvas* canvas) {
   return compositor_ && compositor_->DemandDrawSw(canvas);
 }
 
 }  // namespace android_webview