Android WebView: Make a custom Picture subclass

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/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 "gpu/command_buffer/service/in_process_command_buffer.h"
-#include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/vector2d_conversions.h"
 #include "ui/gfx/vector2d_f.h"
 
@@ skipping 21 matching lines @@
       return NULL;
     UserData* data = reinterpret_cast<UserData*>(
         contents->GetUserData(kUserDataKey));
     return data ? data->instance_ : NULL;
   }
 
  private:
   InProcessViewRenderer* instance_;
 };
 
-typedef base::Callback<bool(SkCanvas*)> RenderMethod;
-
 bool RasterizeIntoBitmap(JNIEnv* env,
                          const JavaRef<jobject>& jbitmap,
                          int scroll_x,
                          int scroll_y,
-                         const RenderMethod& renderer) {
+                         const InProcessViewRenderer::RenderMethod& renderer) {
   DCHECK(jbitmap.obj());
 
   AndroidBitmapInfo bitmap_info;
   if (AndroidBitmap_getInfo(env, jbitmap.obj(), &bitmap_info) < 0) {
     LOG(ERROR) << "Error getting java bitmap info.";
     return false;
   }
 
   void* pixels = NULL;
   if (AndroidBitmap_lockPixels(env, jbitmap.obj(), &pixels) < 0) {
@@ skipping 32 matching lines @@
 bool HardwareEnabled() {
   static bool g_hw_enabled = !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableWebViewGLMode);
   return g_hw_enabled;
 }
 
 // Provides software rendering functions from the Android glue layer.
 // 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 = 20;
 
 class ScopedAllowGL {
  public:
   ScopedAllowGL();
   ~ScopedAllowGL();
 
   static bool IsAllowed() {
     return BrowserThread::CurrentlyOn(BrowserThread::UI) && allow_gl;
   }
@@ skipping 30 matching lines @@
     if (!renderer || !renderer->RequestProcessGL()) {
       LOG(ERROR) << "Failed to request DrawGL. Probably going to deadlock.";
     }
   }
 }
 
 // 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.";
-
   gpu::InProcessCommandBuffer::SetScheduleCallback(
       base::Bind(&ScheduleGpuWork));
 }
 
 // static
 AwDrawSWFunctionTable* BrowserViewRenderer::GetAwDrawSWFunctionTable() {
   return g_sw_draw_functions;
 }
 
-// static
-bool BrowserViewRenderer::IsSkiaVersionCompatible() {
-  DCHECK(g_sw_draw_functions);
-  return g_is_skia_version_compatible;
-}
-
 InProcessViewRenderer::InProcessViewRenderer(
     BrowserViewRenderer::Client* client,
     JavaHelper* java_helper,
     content::WebContents* web_contents)
     : client_(client),
       java_helper_(java_helper),
       web_contents_(web_contents),
       compositor_(NULL),
       visible_(false),
       dip_scale_(0.0),
@@ skipping 162 matching lines @@
   EnsureContinuousInvalidation(draw_info, !drew_full_visible_rect);
 }
 
 void InProcessViewRenderer::SetGlobalVisibleRect(
     const gfx::Rect& visible_rect) {
   cached_global_visible_rect_ = visible_rect;
 }
 
 bool InProcessViewRenderer::DrawSWInternal(jobject java_canvas,
                                            const gfx::Rect& clip) {
-  TRACE_EVENT0("android_webview", "InProcessViewRenderer::DrawSW");
   fallback_tick_.Cancel();
 
   if (clip.IsEmpty()) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_EmptyClip", TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
   if (!compositor_) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
+  return RenderViaAuxilaryBitmapIfNeeded(
+      java_canvas,
+      java_helper_,
+      scroll_at_start_of_frame_,
+      clip,
+      base::Bind(&InProcessViewRenderer::CompositeSW,
+                 base::Unretained(this)),
+      web_contents_);
+}
+
+// static
+bool InProcessViewRenderer::RenderViaAuxilaryBitmapIfNeeded(
+      jobject java_canvas,
+      BrowserViewRenderer::JavaHelper* java_helper,
+      const gfx::Vector2d& scroll_correction,
+      const gfx::Rect& clip,
+      InProcessViewRenderer::RenderMethod render_source,
+      void* owner_key) {
+  TRACE_EVENT0("android_webview",
+               "InProcessViewRenderer::RenderViaAuxilaryBitmapIfNeeded");
   JNIEnv* env = AttachCurrentThread();
 
   AwDrawSWFunctionTable* sw_functions = GetAwDrawSWFunctionTable();
   AwPixelInfo* pixels = sw_functions ?
       sw_functions->access_pixels(env, java_canvas) : NULL;
-  // Render into an auxiliary bitmap if pixel info is not available.
-  ScopedJavaLocalRef<jobject> jcanvas(env, java_canvas);
   if (pixels == NULL) {
+    // Render into an auxiliary bitmap if pixel info is not available.
+    ScopedJavaLocalRef<jobject> jcanvas(env, java_canvas);
     TRACE_EVENT0("android_webview", "RenderToAuxBitmap");
-    ScopedJavaLocalRef<jobject> jbitmap(java_helper_->CreateBitmap(
-        env, clip.width(), clip.height(), jcanvas, web_contents_));
+    ScopedJavaLocalRef<jobject> jbitmap(java_helper->CreateBitmap(
+        env, clip.width(), clip.height(), jcanvas, owner_key));
     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::CompositeSW,
-                                        base::Unretained(this)))) {
+                             clip.x() - scroll_correction.x(),
+                             clip.y() - scroll_correction.y(),
+                             render_source)) {
       TRACE_EVENT_INSTANT0("android_webview",
                            "EarlyOut_RasterizeFail",
                            TRACE_EVENT_SCOPE_THREAD);
       return false;
     }
 
-    java_helper_->DrawBitmapIntoCanvas(env, jbitmap, jcanvas,
-                                       clip.x(), clip.y());
+    java_helper->DrawBitmapIntoCanvas(env, jbitmap, jcanvas,
+                                      clip.x(), clip.y());
     return true;
   }
 
   // Draw in a SkCanvas built over the pixel information.
   bool succeeded = false;
   {
     SkBitmap bitmap;
     bitmap.setConfig(static_cast<SkBitmap::Config>(pixels->config),
                      pixels->width,
                      pixels->height,
                      pixels->row_bytes);
     bitmap.setPixels(pixels->pixels);
     SkDevice device(bitmap);
     SkCanvas canvas(&device);
     SkMatrix matrix;
     for (int i = 0; i < 9; i++)
       matrix.set(i, pixels->matrix[i]);
     canvas.setMatrix(matrix);
 
     if (pixels->clip_region_size) {
       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());
+    canvas.translate(scroll_correction.x(),
+                     scroll_correction.y());
 
-    succeeded = CompositeSW(&canvas);
+    succeeded = render_source.Run(&canvas);
   }
 
   sw_functions->release_pixels(pixels);
   return succeeded;
 }
 
-base::android::ScopedJavaLocalRef<jobject>
-InProcessViewRenderer::CapturePicture(int width, int height) {
-  if (!compositor_ || !GetAwDrawSWFunctionTable()) {
-    TRACE_EVENT_INSTANT0(
-        "android_webview", "EarlyOut_CapturePicture", TRACE_EVENT_SCOPE_THREAD);
-    return ScopedJavaLocalRef<jobject>();
-  }
-
+skia::RefPtr<SkPicture> InProcessViewRenderer::CapturePicture(int width,
+                                                              int height) {
   // Return empty Picture objects for empty SkPictures.
-  JNIEnv* env = AttachCurrentThread();
+  skia::RefPtr<SkPicture> picture = skia::AdoptRef(new SkPicture);
   if (width <= 0 || height <= 0) {
-    return java_helper_->RecordBitmapIntoPicture(env,
-                                                 ScopedJavaLocalRef<jobject>());
+    return picture;
   }
 
   // Reset scroll back to the origin, will go back to the old
   // value when scroll_reset is out of scope.
   base::AutoReset<gfx::Vector2dF> scroll_reset(&scroll_offset_css_,
                                                gfx::Vector2d());
 
-  skia::RefPtr<SkPicture> picture = skia::AdoptRef(new SkPicture);
   SkCanvas* rec_canvas = picture->beginRecording(width, height, 0);
-  if (!CompositeSW(rec_canvas))
-    return ScopedJavaLocalRef<jobject>();
+  if (compositor_)
+    CompositeSW(rec_canvas);
   picture->endRecording();
-
-  if (IsSkiaVersionCompatible()) {
-    // Add a reference that the create_picture() will take ownership of.
-    picture->ref();
-    return ScopedJavaLocalRef<jobject>(env,
-        GetAwDrawSWFunctionTable()->create_picture(env, picture.get()));
-  }
-
-  // If Skia versions are not compatible, workaround it by rasterizing the
-  // picture into a bitmap and drawing it into a new Java picture. Pass null
-  // for |canvas| as we don't have java canvas at this point (and it would be
-  // software anyway).
-  ScopedJavaLocalRef<jobject> jbitmap(java_helper_->CreateBitmap(
-      env, picture->width(), picture->height(), ScopedJavaLocalRef<jobject>(),
-      NULL));
-  if (!jbitmap.obj())
-    return ScopedJavaLocalRef<jobject>();
-
-  if (!RasterizeIntoBitmap(env, jbitmap, 0, 0,
-      base::Bind(&RenderPictureToCanvas,
-                 base::Unretained(picture.get())))) {
-    return ScopedJavaLocalRef<jobject>();
-  }
-
-  return java_helper_->RecordBitmapIntoPicture(env, jbitmap);
+  return picture;
 }
 
 void InProcessViewRenderer::EnableOnNewPicture(bool enabled) {
   on_new_picture_enable_ = enabled;
 }
 
 void InProcessViewRenderer::OnVisibilityChanged(bool visible) {
   TRACE_EVENT_INSTANT1("android_webview",
                        "InProcessViewRenderer::OnVisibilityChanged",
                        TRACE_EVENT_SCOPE_THREAD,
@@ skipping 265 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