[Android WebView] Implement the capture picture API.

android_webview/native/aw_contents.cc

 // Copyright (c) 2012 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/native/aw_contents.h"
 
 #include <sys/system_properties.h>
 
 #include "android_webview/browser/aw_browser_main_parts.h"
 #include "android_webview/browser/net_disk_cache_remover.h"
@@ skipping 19 matching lines @@
 #include "content/components/navigation_interception/intercept_navigation_delegate.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cert_store.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/ssl_status.h"
 #include "jni/AwContents_jni.h"
 #include "net/base/x509_certificate.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/SkPicture.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/gl_bindings.h"
 
 // TODO(leandrogracia): remove when crbug.com/164140 is closed.
 // Borrowed from gl2ext.h. Cannot be included due to conflicts with
 // gl_bindings.h and the EGL library methods (eglGetCurrentContext).
 #ifndef GL_TEXTURE_EXTERNAL_OES
 #define GL_TEXTURE_EXTERNAL_OES 0x8D65
 #endif
 
 #ifndef GL_TEXTURE_BINDING_EXTERNAL_OES
 #define GL_TEXTURE_BINDING_EXTERNAL_OES 0x8D67
 #endif
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF16;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::ConvertUTF8ToJavaString;
+using base::android::GetClass;
+using base::android::GetFieldID;
 using base::android::JavaRef;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 using content::BrowserThread;
 using content::ContentViewCore;
 using content::InterceptNavigationDelegate;
 using content::WebContents;
 
 extern "C" {
 static AwDrawGLFunction DrawGLFunction;
@@ skipping 41 matching lines @@
 AwContents::AwContents(JNIEnv* env,
                        jobject obj,
                        jobject web_contents_delegate,
                        bool private_browsing)
     : java_ref_(env, obj),
       web_contents_delegate_(
           new AwWebContentsDelegate(env, web_contents_delegate)),
       view_visible_(false),
       compositor_visible_(false),
       is_composite_pending_(false),
+      on_new_picture_enabled_(false),
+      on_new_picture_invalidation_only_(false),
       last_frame_context_(NULL) {
   RendererPictureMap::CreateInstance();
   android_webview::AwBrowserDependencyFactory* dependency_factory =
       android_webview::AwBrowserDependencyFactory::GetInstance();
 
   // TODO(joth): rather than create and set the WebContents here, expose the
   // factory method to java side and have that orchestrate the construction
   // order.
   SetWebContents(dependency_factory->CreateWebContents(private_browsing));
 }
@@ skipping 238 matching lines @@
 
     glScissor(scissor_box[0], scissor_box[1], scissor_box[2],
                      scissor_box[3]);
 
     glUseProgram(current_program);
   }
   // ---------------------------------------------------------------------------
 }
 
 bool AwContents::DrawSW(JNIEnv* env, jobject obj, jobject java_canvas) {
-  skia::RefPtr<SkPicture> picture =
-      RendererPictureMap::GetInstance()->GetRendererPicture(
-          web_contents_->GetRoutingID());
+  // TODO(leandrogracia): once Ubercompositor is ready and we support software
+  // rendering mode, we should avoid this as much as we can, ideally always.
+  // This includes finding a proper replacement for onDraw calls in hardware
+  // mode with software canvases.
+  skia::RefPtr<SkPicture> picture = GetLastCapturedPicture();
   if (!picture)
     return false;
 
   AwPixelInfo* pixels;
   if (!g_draw_sw_functions ||
       (pixels = g_draw_sw_functions->access_pixels(env, java_canvas)) == NULL) {
     // TODO(joth): Fall back to slow path rendering via temporary bitmap.
     return false;
   }
 
@@ skipping 280 matching lines @@
   is_composite_pending_ = true;
   Invalidate();
 }
 
 void AwContents::Invalidate() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
-  Java_AwContents_invalidate(env, obj.obj());
+  if (view_visible_)
+    Java_AwContents_invalidate(env, obj.obj());
+
+  if (on_new_picture_enabled_ && on_new_picture_invalidation_only_)
+    Java_AwContents_onNewPicture(env, obj.obj(), 0, 0, 0);
 }
 
 void AwContents::SetCompositorVisibility(bool visible) {
   if (compositor_visible_ != visible) {
     compositor_visible_ = visible;
     compositor_->SetVisible(compositor_visible_);
   }
 }
 
 void AwContents::OnSwapBuffersCompleted() {
@@ skipping 131 matching lines @@
 }
 
 void AwContents::FocusFirstNode(JNIEnv* env, jobject obj) {
   web_contents_->FocusThroughTabTraversal(false);
 }
 
 jint AwContents::ReleasePopupWebContents(JNIEnv* env, jobject obj) {
   return reinterpret_cast<jint>(pending_contents_.release());
 }
 
+void AwContents::CapturePicture(JNIEnv* env,
+                                jobject obj,
+                                jobject picture_data) {
+  skia::RefPtr<SkPicture> picture = GetLastCapturedPicture();
+  ScopedJavaLocalRef<jclass> external_picture_class = GetClass(env,
+      "org/chromium/android_webview/AwContentsClient$ExternalPictureData");
+  env->SetIntField(picture_data,
+      GetFieldID(env, external_picture_class, "nativePicture", "I"),
+      reinterpret_cast<jint>(picture.get()));
+  env->SetIntField(picture_data,
+      GetFieldID(env, external_picture_class, "width", "I"),
+      picture ? picture->width() : 0);
+  env->SetIntField(picture_data,
+      GetFieldID(env, external_picture_class, "height", "I"),
+      picture ? picture->height() : 0);
+}
+
+void AwContents::EnableOnNewPicture(JNIEnv* env,
+                                    jobject obj,
+                                    jboolean enabled,
+                                    jboolean invalidation_only) {
+  on_new_picture_enabled_ = enabled;
+  on_new_picture_invalidation_only_ = invalidation_only;
+
+  // If onNewPicture is triggered only on invalidation do not capture
+  // pictures on every new frame.
+  if (on_new_picture_invalidation_only_)
+    return;
+
+  // TODO(leandrogracia): uncomment when sw rendering uses Ubercompositor.
+  // Until then we need the callback enabled for SW mode invalidation.
+  // render_view_host_ext_->EnableCapturePictureCallback(enabled);
+}
+
 void AwContents::OnPictureUpdated(int process_id, int render_view_id) {
   CHECK_EQ(web_contents_->GetRenderProcessHost()->GetID(), process_id);
   if (render_view_id != web_contents_->GetRoutingID())
     return;
 
+  // TODO(leandrogracia): this can be made unconditional once software rendering
+  // uses Ubercompositor. Until then this path is required for SW invalidations.
+  if (on_new_picture_enabled_ && !on_new_picture_invalidation_only_) {
+    JNIEnv* env = AttachCurrentThread();
+    ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
+    if (!obj.is_null()) {
+      skia::RefPtr<SkPicture> picture = GetLastCapturedPicture();
+      Java_AwContents_onNewPicture(env, obj.obj(),
+          reinterpret_cast<jint>(picture.get()),
+          picture ? picture->width() : 0,
+          picture ? picture->height() : 0);
+    }
+  }
+
   // TODO(leandrogracia): delete when sw rendering uses Ubercompositor.
   // Invalidation should be provided by the compositor only.
   Invalidate();
 }
 
+skia::RefPtr<SkPicture> AwContents::GetLastCapturedPicture() {
+  // Use the latest available picture if the listener callback is enabled.
+  skia::RefPtr<SkPicture> picture;
+  if (on_new_picture_enabled_)
+    picture = RendererPictureMap::GetInstance()->GetRendererPicture(
+        web_contents_->GetRoutingID());
+
+  // If not available or not in listener mode get it synchronously.
+  if (!picture) {
+    render_view_host_ext_->CapturePictureSync();
+    picture = RendererPictureMap::GetInstance()->GetRendererPicture(
+        web_contents_->GetRoutingID());
+  }
+
+  return picture;
+}
+
 }  // namespace android_webview