Enable gesture events handling on Android.

content/browser/android/content_view_core_impl.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 "content/browser/android/content_view_core_impl.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "content/browser/android/content_view_client.h"
+#include "content/browser/android/touch_point.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_view_android.h"
 #include "content/browser/web_contents/navigation_controller_impl.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/web_contents.h"
 #include "jni/ContentViewCore_jni.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/android/WebInputEventFactory.h"
 #include "webkit/glue/webmenuitem.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::GetClass;
 using base::android::HasField;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
+using WebKit::WebInputEvent;
+using WebKit::WebInputEventFactory;
 
 // Describes the type and enabled state of a select popup item.
 // Keep in sync with the value defined in SelectPopupDialog.java
 enum PopupItemType {
   POPUP_ITEM_TYPE_GROUP = 0,
   POPUP_ITEM_TYPE_DISABLED,
   POPUP_ITEM_TYPE_ENABLED
 };
 
 namespace {
@@ skipping 53 matching lines @@
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   // TODO(jrg)
 }
 
 void ContentViewCoreImpl::InitJNI(JNIEnv* env, jobject obj) {
   java_object_ = new JavaObject;
   java_object_->obj = env->NewWeakGlobalRef(obj);
 }
 
+RenderWidgetHostViewAndroid* ContentViewCoreImpl::GetRenderWidgetHostViewAndroid() {
+  RenderWidgetHostView* rwhv = NULL;
+  if (!web_contents_) {
+    return NULL;
+  } else if (web_contents_->ShowingInterstitialPage()) {

[aelias_OOO_until_Jul13, 2012/07/27 01:35:04]

Please delete this whole else block.  This is the wrong way to do it and we have
another plan for handling interstitial pages (sievers@ is working on it).

+    rwhv = web_contents_->GetInterstitialPage()->
+        GetRenderViewHostForTesting()->GetView();
+    // An interstitial page must have had Show() called immediately after
+    // construction in order for the render widget to exist. Currently Desktop
+    // Chrome does not enforce this is the case, however we do here to keep the
+    // state consistent with the WebContents.
+    CHECK(rwhv);
+  } else {
+    rwhv = web_contents_->GetRenderWidgetHostView();
+  }
+  return static_cast<RenderWidgetHostViewAndroid*>(rwhv);
+}
+
 // ----------------------------------------------------------------------------
 // Methods called from Java via JNI
 // ----------------------------------------------------------------------------
 
 void ContentViewCoreImpl::LoadUrlWithoutUrlSanitization(JNIEnv* env,
                                                         jobject,
                                                         jstring jurl,
                                                         int page_transition) {
   GURL url(base::android::ConvertJavaStringToUTF8(env, jurl));
 
@@ skipping 29 matching lines @@
   // We report 1 in that case so the UI does not assume the page is loading.
   if (web_contents()->GetURL().is_empty() || !content_view_client_.get())
     return static_cast<jdouble>(1.0);
   return static_cast<jdouble>(content_view_client_->GetLoadProgress());
 }
 
 jboolean ContentViewCoreImpl::IsIncognito(JNIEnv* env, jobject obj) {
   return web_contents()->GetBrowserContext()->IsOffTheRecord();
 }
 
+jboolean ContentViewCoreImpl::TouchEvent(JNIEnv* env,
+                                         jobject obj,
+                                         jlong time_ms,
+                                         jint type,
+                                         jobjectArray pts) {
+  RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
+  if (rwhv) {
+    using WebKit::WebTouchEvent;
+    WebKit::WebTouchEvent event;
+    TouchPoint::BuildWebTouchEvent(env, type, time_ms, pts, event);
+    rwhv->TouchEvent(event);
+    return true;
+  }
+  return false;
+}
+
+void ContentViewCoreImpl::SendGestureEvent(WebInputEvent::Type type,
+                                           long time_ms, int x, int y,
+                                           float dx, float dy,
+                                           bool link_preview_tap) {
+  WebKit::WebGestureEvent event = WebInputEventFactory::gestureEvent(
+      type, time_ms / 1000.0, x, y, dx, dy, 0);
+  if (GetRenderWidgetHostViewAndroid())
+    GetRenderWidgetHostViewAndroid()->GestureEvent(event);
+}
+
+void ContentViewCoreImpl::ScrollBegin(JNIEnv* env, jobject obj, jlong time_ms,
+                                      jint x, jint y) {
+  SendGestureEvent(
+      WebInputEvent::GestureScrollBegin, time_ms, x, y, 0, 0, false);
+}
+
+void ContentViewCoreImpl::ScrollEnd(JNIEnv* env, jobject obj, jlong time_ms) {
+  SendGestureEvent(WebInputEvent::GestureScrollEnd, time_ms, 0, 0, 0, 0, false);
+}
+
+void ContentViewCoreImpl::ScrollBy(JNIEnv* env, jobject obj, jlong time_ms,
+                                   jint dx, jint dy) {
+  SendGestureEvent(
+      WebInputEvent::GestureScrollUpdate, time_ms, 0, 0, -dx, -dy, false);
+}
+
+void ContentViewCoreImpl::FlingStart(JNIEnv* env, jobject obj, jlong time_ms,
+                                     jint x, jint y, jint vx, jint vy) {
+  SendGestureEvent(
+      WebInputEvent::GestureFlingStart, time_ms, x, y, vx, vy, false);
+}
+
+void ContentViewCoreImpl::FlingCancel(JNIEnv* env, jobject obj, jlong time_ms) {
+  SendGestureEvent(
+      WebInputEvent::GestureFlingCancel, time_ms, 0, 0, 0, 0, false);
+}
+
+void ContentViewCoreImpl::SingleTap(JNIEnv* env, jobject obj, jlong time_ms,
+                                    jint x, jint y, jboolean link_preview_tap) {
+  SendGestureEvent(
+      WebInputEvent::GestureTap, time_ms, x, y, 0, 0, link_preview_tap);
+}
+
+void ContentViewCoreImpl::ShowPressState(JNIEnv* env, jobject obj,
+                                         jlong time_ms,
+                                         jint x, jint y) {
+  SendGestureEvent(WebInputEvent::GestureTapDown, time_ms, x, y, 0, 0, false);
+}
+
+void ContentViewCoreImpl::DoubleTap(JNIEnv* env, jobject obj, jlong time_ms,
+                                    jint x, jint y) {
+  SendGestureEvent(WebInputEvent::GestureDoubleTap, time_ms, x, y, 0, 0, false);
+}
+
+void ContentViewCoreImpl::LongPress(JNIEnv* env, jobject obj, jlong time_ms,
+                                    jint x, jint y, jboolean link_preview_tap) {
+  SendGestureEvent(
+      WebInputEvent::GestureLongPress, time_ms, x, y, 0, 0, link_preview_tap);
+}
+
+void ContentViewCoreImpl::PinchBegin(JNIEnv* env, jobject obj, jlong time_ms,
+                                     jint x, jint y) {
+  SendGestureEvent(
+      WebInputEvent::GesturePinchBegin, time_ms, x, y, 0, 0, false);
+}
+
+void ContentViewCoreImpl::PinchEnd(JNIEnv* env, jobject obj, jlong time_ms) {
+  SendGestureEvent(WebInputEvent::GesturePinchEnd, time_ms, 0, 0, 0, 0, false);
+}
+
+void ContentViewCoreImpl::PinchBy(JNIEnv* env, jobject obj, jlong time_ms,
+                                  jint anchor_x, jint anchor_y, jfloat delta) {
+  SendGestureEvent(WebInputEvent::GesturePinchUpdate,
+                   time_ms,
+                   anchor_x,
+                   anchor_y,
+                   delta,
+                   delta,
+                   false);
+}
+
 jboolean ContentViewCoreImpl::CanGoBack(JNIEnv* env, jobject obj) {
   return web_contents_->GetController().CanGoBack();
 }
 
 jboolean ContentViewCoreImpl::CanGoForward(JNIEnv* env, jobject obj) {
   return web_contents_->GetController().CanGoForward();
 }
 
 jboolean ContentViewCoreImpl::CanGoToOffset(JNIEnv* env, jobject obj,
                                             jint offset) {
@@ skipping 133 matching lines @@
                 POPUP_ITEM_TYPE_DISABLED));
     env->SetIntArrayRegion(enabled_array.obj(), i, 1, &enabled);
   }
   ScopedJavaLocalRef<jobjectArray> items_array(
       base::android::ToJavaArrayOfStrings(env, labels));
   Java_ContentViewCore_showSelectPopup(env, java_object_->View(env).obj(),
                                        items_array.obj(), enabled_array.obj(),
                                        multiple, selected_array.obj());
 }
 
+void ContentViewCoreImpl::ConfirmTouchEvent(bool handled) {
+  JNIEnv* env = AttachCurrentThread();
+  Java_ContentViewCore_confirmTouchEvent(env,
+                                         java_object_->View(env).obj(),
+                                         handled);
+}
+
+void ContentViewCoreImpl::DidSetNeedTouchEvents(bool need_touch_events) {
+  JNIEnv* env = AttachCurrentThread();
+  Java_ContentViewCore_didSetNeedTouchEvents(env,
+                                             java_object_->View(env).obj(),
+                                             need_touch_events);
+}
+
 bool ContentViewCoreImpl::HasFocus() {
   NOTIMPLEMENTED() << "not upstreamed yet";
   return false;
 }
 
 void ContentViewCoreImpl::OnSelectionChanged(const std::string& text) {
   NOTIMPLEMENTED() << "not upstreamed yet";
 }
 
 void ContentViewCoreImpl::OnSelectionBoundsChanged(
@@ skipping 68 matching lines @@
   if (!HasField(env, clazz, "mNativeContentViewCore", "I")) {
     DLOG(ERROR) << "Unable to find ContentView.mNativeContentViewCore!";
     return false;
   }
   g_native_content_view = GetFieldID(env, clazz, "mNativeContentViewCore", "I");
 
   return RegisterNativesImpl(env) >= 0;
 }
 
 }  // namespace content