[Android] Out with the Android GR, in with the new unified C++ GR

content/browser/android/content_view_core_impl.cc

 // Copyright 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 "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "cc/layers/layer.h"
 #include "cc/output/begin_frame_args.h"
 #include "content/browser/android/gesture_event_type.h"
 #include "content/browser/android/interstitial_page_delegate_android.h"
 #include "content/browser/android/load_url_params.h"
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/media/android/browser_media_player_manager.h"
 #include "content/browser/renderer_host/compositor_impl_android.h"
+#include "content/browser/renderer_host/input/motion_event_android.h"
 #include "content/browser/renderer_host/input/web_input_event_builders_android.h"
 #include "content/browser/renderer_host/java/java_bound_object.h"
 #include "content/browser/renderer_host/java/java_bridge_dispatcher_host_manager.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/screen_orientation/screen_orientation_dispatcher_host.h"
 #include "content/browser/ssl/ssl_host_state.h"
 #include "content/browser/web_contents/web_contents_view_android.h"
 #include "content/common/input/web_input_event_traits.h"
@@ skipping 68 matching lines @@
     JNIEnv* env,
     const gfx::Rect& rect) {
   return ScopedJavaLocalRef<jobject>(
       Java_ContentViewCore_createRect(env,
                                       static_cast<int>(rect.x()),
                                       static_cast<int>(rect.y()),
                                       static_cast<int>(rect.right()),
                                       static_cast<int>(rect.bottom())));
 }
 
-bool PossiblyTriggeredByTouchTimeout(const WebGestureEvent& event) {
-  switch (event.type) {
-    case WebInputEvent::GestureShowPress:
-    case WebInputEvent::GestureLongPress:
-      return true;
-    // On Android, a GestureTap may be sent after a certain timeout window
-    // if there is no GestureDoubleTap follow-up.
-    case WebInputEvent::GestureTap:
-      return true;
-    // On Android, a GestureTapCancel may be triggered by the loss of window
-    //  focus (e.g., following a GestureLongPress).
-    case WebInputEvent::GestureTapCancel:
-      return true;
-    default:
-      break;
-  }
-  return false;
-}
-
-int ToContentViewGestureHandlerType(WebInputEvent::Type type) {
+int ToGestureEventType(WebInputEvent::Type type) {
   switch (type) {
     case WebInputEvent::GestureScrollBegin:
       return SCROLL_START;
     case WebInputEvent::GestureScrollEnd:
       return SCROLL_END;
     case WebInputEvent::GestureScrollUpdate:
       return SCROLL_BY;
     case WebInputEvent::GestureFlingStart:
       return FLING_START;
     case WebInputEvent::GestureFlingCancel:
@@ skipping 22 matching lines @@
       return PINCH_BY;
     case WebInputEvent::GestureTwoFingerTap:
     case WebInputEvent::GestureScrollUpdateWithoutPropagation:
     default:
       NOTREACHED() << "Invalid source gesture type: "
                    << WebInputEventTraits::GetName(type);
       return -1;
   };
 }
 
+float GetPrimaryDisplayDeviceScaleFactor() {
+  const gfx::Display& display =
+      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
+  return display.device_scale_factor();
+}
+
 }  // namespace
 
 // Enables a callback when the underlying WebContents is destroyed, to enable
 // nulling the back-pointer.
 class ContentViewCoreImpl::ContentViewUserData
     : public base::SupportsUserData::Data {
  public:
   explicit ContentViewUserData(ContentViewCoreImpl* content_view_core)
       : content_view_core_(content_view_core) {
   }
@@ skipping 39 matching lines @@
 
 ContentViewCoreImpl::ContentViewCoreImpl(JNIEnv* env,
                                          jobject obj,
                                          WebContents* web_contents,
                                          ui::ViewAndroid* view_android,
                                          ui::WindowAndroid* window_android)
     : WebContentsObserver(web_contents),
       java_ref_(env, obj),
       web_contents_(static_cast<WebContentsImpl*>(web_contents)),
       root_layer_(cc::Layer::Create()),
+      dpi_scale_(GetPrimaryDisplayDeviceScaleFactor()),
       vsync_interval_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros)),
       expected_browser_composite_time_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros * kDefaultBrowserCompositeVSyncFraction)),
       view_android_(view_android),
       window_android_(window_android),
+      gesture_provider_(this, 1.f / dpi_scale_),
       device_orientation_(0),
-      geolocation_needs_pause_(false),
-      touch_disposition_gesture_filter_(this),
-      handling_touch_event_(false) {
+      geolocation_needs_pause_(false) {
   CHECK(web_contents) <<
       "A ContentViewCoreImpl should be created with a valid WebContents.";
 
-  const gfx::Display& display =
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
-  dpi_scale_ = display.device_scale_factor();
-
   // Currently, the only use case we have for overriding a user agent involves
   // spoofing a desktop Linux user agent for "Request desktop site".
   // Automatically set it for all WebContents so that it is available when a
   // NavigationEntry requires the user agent to be overridden.
   const char kLinuxInfoStr[] = "X11; Linux x86_64";
   std::string product = content::GetContentClient()->GetProduct();
   std::string spoofed_ua =
       webkit_glue::BuildUserAgentFromOSAndProduct(kLinuxInfoStr, product);
   web_contents->SetUserAgentOverride(spoofed_ua);
 
@@ skipping 104 matching lines @@
       break;
     }
   }
 }
 
 void ContentViewCoreImpl::RenderViewReady() {
   if (device_orientation_ != 0)
     SendOrientationChangeEventInternal();
 }
 
-void ContentViewCoreImpl::ForwardGestureEvent(
-    const blink::WebGestureEvent& event) {
-  RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
-  if (rwhv)
-    rwhv->SendGestureEvent(event);
+void ContentViewCoreImpl::OnGestureEvent(const blink::WebGestureEvent& event) {
+  SendGestureEvent(event);
 }
 
 RenderWidgetHostViewAndroid*
     ContentViewCoreImpl::GetRenderWidgetHostViewAndroid() {
   RenderWidgetHostView* rwhv = NULL;
   if (web_contents_) {
     rwhv = web_contents_->GetRenderWidgetHostView();
     if (web_contents_->ShowingInterstitialPage()) {
       rwhv = static_cast<InterstitialPageImpl*>(
           web_contents_->GetInterstitialPage())->
@@ skipping 173 matching lines @@
     env->SetIntArrayRegion(enabled_array.obj(), i, 1, &enabled);
   }
   ScopedJavaLocalRef<jobjectArray> items_array(
       base::android::ToJavaArrayOfStrings(env, labels));
   Java_ContentViewCore_showSelectPopup(env, j_obj.obj(),
                                        items_array.obj(), enabled_array.obj(),
                                        multiple, selected_array.obj());
 }
 
 void ContentViewCoreImpl::ConfirmTouchEvent(InputEventAckState ack_result) {
-  touch_disposition_gesture_filter_.OnTouchEventAck(ack_result);
+  gesture_provider_.OnTouchEventAck(ack_result);
 }
 
 void ContentViewCoreImpl::OnGestureEventAck(const blink::WebGestureEvent& event,
                                             InputEventAckState ack_result) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
 
   switch (event.type) {
@@ skipping 51 matching lines @@
       event.type != WebInputEvent::GestureLongPress)
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return false;
 
   const blink::WebGestureEvent& gesture =
       static_cast<const blink::WebGestureEvent&>(event);
-  int gesture_type = ToContentViewGestureHandlerType(event.type);
+  int gesture_type = ToGestureEventType(event.type);
   return Java_ContentViewCore_filterTapOrPressEvent(env,
                                                     j_obj.obj(),
                                                     gesture_type,
                                                     gesture.x * GetDpiScale(),
                                                     gesture.y * GetDpiScale());
+
+  // TODO(jdduke): Also report double-tap UMA, crbug/347568.
 }
 
 bool ContentViewCoreImpl::HasFocus() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return false;
   return Java_ContentViewCore_hasFocus(env, obj.obj());
 }
 
@@ skipping 341 matching lines @@
 
 void ContentViewCoreImpl::SendOrientationChangeEvent(JNIEnv* env,
                                                      jobject obj,
                                                      jint orientation) {
   if (device_orientation_ != orientation) {
     device_orientation_ = orientation;
     SendOrientationChangeEventInternal();
   }
 }
 
-void ContentViewCoreImpl::OnTouchEventHandlingBegin(JNIEnv* env,
-                                                    jobject obj,
-                                                    jobject motion_event) {
-  DCHECK(!handling_touch_event_);
-  handling_touch_event_ = true;
-
-  pending_touch_event_ =
-      WebTouchEventBuilder::Build(motion_event, GetDpiScale());
-
-  pending_gesture_packet_ =
-      GestureEventPacket::FromTouch(pending_touch_event_);
-}
-
-void ContentViewCoreImpl::OnTouchEventHandlingEnd(JNIEnv* env, jobject obj) {
-  if (!handling_touch_event_)
-    return;
-
-  GestureEventPacket gesture_packet;
-  std::swap(gesture_packet, pending_gesture_packet_);
-
-  handling_touch_event_ = false;
-
+jboolean ContentViewCoreImpl::OnTouchEvent(JNIEnv* env,
+                                           jobject obj,
+                                           jobject motion_event) {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (!rwhv)
-    return;
+    return false;
 
-  // Note: Order is important here, as the touch may be ack'ed synchronously
-  TouchDispositionGestureFilter::PacketResult result =
-      touch_disposition_gesture_filter_.OnGestureEventPacket(gesture_packet);
-  if (result != TouchDispositionGestureFilter::SUCCESS) {
-    NOTREACHED() << "Invalid touch gesture sequence detected.";
-    return;
-  }
-  rwhv->SendTouchEvent(pending_touch_event_);
+  MotionEventAndroid event(env, motion_event, false);
+
+  if (!gesture_provider_.OnTouchEvent(event))
+    return false;
+
+  rwhv->SendTouchEvent(WebTouchEventBuilder::Build(event, GetDpiScale()));
+  return true;
 }
 
 float ContentViewCoreImpl::GetTouchPaddingDip() {
   return 48.0f / GetDpiScale();
 }
 
 float ContentViewCoreImpl::GetDpiScale() const {
   return dpi_scale_;
 }
 
@@ skipping 41 matching lines @@
 }
 
 WebGestureEvent ContentViewCoreImpl::MakeGestureEvent(
     WebInputEvent::Type type, int64 time_ms, float x, float y) const {
   return WebGestureEventBuilder::Build(
       type, time_ms / 1000.0, x / GetDpiScale(), y / GetDpiScale());
 }
 
 void ContentViewCoreImpl::SendGestureEvent(
     const blink::WebGestureEvent& event) {
-  // Gestures received while |handling_touch_event_| will accumulate until
-  // touch handling finishes, at which point the gestures will be pushed to the
-  // |touch_disposition_gesture_filter_|.
-  if (handling_touch_event_) {
-    pending_gesture_packet_.Push(event);
-    return;
-  }
-
-  // TODO(jdduke): In general, timeout-based gestures *should* have the same
-  // timestamp as the initial TouchStart of the current sequence. We should
-  // verify that this is true, and use that as another timeout check.
-  if (PossiblyTriggeredByTouchTimeout(event)) {
-    TouchDispositionGestureFilter::PacketResult result =
-        touch_disposition_gesture_filter_.OnGestureEventPacket(
-            GestureEventPacket::FromTouchTimeout(event));
-    DCHECK_EQ(TouchDispositionGestureFilter::SUCCESS, result);
-    return;
-  }
-
-  // If |event| was not (directly or indirectly) touch-derived, treat it as
-  // a synthetic gesture event.
-  SendSyntheticGestureEvent(event);
-}
-
-void ContentViewCoreImpl::SendSyntheticGestureEvent(
-    const blink::WebGestureEvent& event) {
-  // Synthetic gestures (e.g., those not generated directly by touches
-  // for which we expect an ack), should be forwarded directly.
-  ForwardGestureEvent(event);
+  RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
+  if (rwhv)
+    rwhv->SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::ScrollBegin(JNIEnv* env,
                                       jobject obj,
                                       jlong time_ms,
                                       jfloat x,
                                       jfloat y,
                                       jfloat hintx,
                                       jfloat hinty) {
   WebGestureEvent event = MakeGestureEvent(
@@ skipping 39 matching lines @@
 
 void ContentViewCoreImpl::SingleTap(JNIEnv* env, jobject obj, jlong time_ms,
                                     jfloat x, jfloat y,
                                     jboolean disambiguation_popup_tap) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureTap, time_ms, x, y);
 
   event.data.tap.tapCount = 1;
 
   // Disambiguation popup gestures are treated as synthetic because their
   // generating touches were never forwarded to the renderer.

[Ted C, 2014/02/28 19:52:33]

This comment seems no longer valid.

Does this still work with the Disambiguation popup taps?

Assuming this is the correct behavior, is there any need for differentiating the
two?  Looks like it "might" be able to use the same code path following this.

[jdduke (slow), 2014/02/28 20:22:04]

You're absolutely right, these will always be synthetic so there's no need to
differentiate.

   if (disambiguation_popup_tap) {
-    SendSyntheticGestureEvent(event);
+    SendGestureEvent(event);
     return;
   }
 
   const float touch_padding_dip = GetTouchPaddingDip();
   event.data.tap.width = touch_padding_dip;
   event.data.tap.height = touch_padding_dip;
   SendGestureEvent(event);
 }
 
-void ContentViewCoreImpl::SingleTapUnconfirmed(JNIEnv* env, jobject obj,
-                                               jlong time_ms,
-                                               jfloat x, jfloat y) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureTapUnconfirmed, time_ms, x, y);
-
-  event.data.tap.tapCount = 1;
-
-  const float touch_padding_dip = GetTouchPaddingDip();
-  event.data.tap.width = touch_padding_dip;
-  event.data.tap.height = touch_padding_dip;
-
-  SendGestureEvent(event);
-}
-
-void ContentViewCoreImpl::ShowPress(JNIEnv* env, jobject obj,
-                                    jlong time_ms,
-                                    jfloat x, jfloat y) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureShowPress, time_ms, x, y);
-  SendGestureEvent(event);
-}
-
-void ContentViewCoreImpl::TapCancel(JNIEnv* env,
-                                    jobject obj,
-                                    jlong time_ms,
-                                    jfloat x,
-                                    jfloat y) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureTapCancel, time_ms, x, y);
-  SendGestureEvent(event);
-}
-
-void ContentViewCoreImpl::TapDown(JNIEnv* env, jobject obj,
-                                  jlong time_ms,
-                                  jfloat x, jfloat y) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureTapDown, time_ms, x, y);
-  SendGestureEvent(event);
-}
-
 void ContentViewCoreImpl::DoubleTap(JNIEnv* env, jobject obj, jlong time_ms,
                                     jfloat x, jfloat y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureDoubleTap, time_ms, x, y);
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::LongPress(JNIEnv* env, jobject obj, jlong time_ms,
                                     jfloat x, jfloat y,
                                     jboolean disambiguation_popup_tap) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureLongPress, time_ms, x, y);
 
   // Disambiguation popup gestures are treated as synthetic because their
   // generating touches were never forwarded to the renderer.
   if (disambiguation_popup_tap) {

[Ted C, 2014/02/28 19:52:33]

same general comment as above.

[jdduke (slow), 2014/02/28 20:22:04]

Done.

-    SendSyntheticGestureEvent(event);
+    SendGestureEvent(event);
     return;
   }
 
-  const float touch_padding_dip = GetTouchPaddingDip();
-  event.data.longPress.width = touch_padding_dip;
-  event.data.longPress.height = touch_padding_dip;
-  SendGestureEvent(event);
-}
-
-void ContentViewCoreImpl::LongTap(JNIEnv* env, jobject obj, jlong time_ms,
-                                  jfloat x, jfloat y,
-                                  jboolean disambiguation_popup_tap) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureLongTap, time_ms, x, y);
-
-  // Disambiguation popup gestures are treated as synthetic because their
-  // generating touches were never forwarded to the renderer.
-  if (disambiguation_popup_tap) {
-    SendSyntheticGestureEvent(event);
-    return;
-  }
-
   const float touch_padding_dip = GetTouchPaddingDip();
   event.data.longPress.width = touch_padding_dip;
   event.data.longPress.height = touch_padding_dip;
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::PinchBegin(JNIEnv* env, jobject obj, jlong time_ms,
                                      jfloat x, jfloat y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GesturePinchBegin, time_ms, x, y);
@@ skipping 27 matching lines @@
 }
 
 void ContentViewCoreImpl::MoveCaret(JNIEnv* env, jobject obj,
                                     jfloat x, jfloat y) {
   if (GetRenderWidgetHostViewAndroid()) {
     GetRenderWidgetHostViewAndroid()->MoveCaret(
         gfx::Point(x / GetDpiScale(), y / GetDpiScale()));
   }
 }
 
+void ContentViewCoreImpl::ResetGestureDetectors(JNIEnv* env, jobject obj) {
+  gesture_provider_.ResetGestureDetectors();
+}
+
+void ContentViewCoreImpl::IgnoreRemainingTouchEvents(JNIEnv* env, jobject obj) {
+  gesture_provider_.CancelActiveTouchSequence();
+}
+
+void ContentViewCoreImpl::OnWindowFocusLost(JNIEnv* env, jobject obj) {
+  gesture_provider_.CancelActiveTouchSequence();
+}
+
+void ContentViewCoreImpl::SetDoubleTapSupportForPageEnabled(JNIEnv* env,
+                                                            jobject obj,
+                                                            jboolean enabled) {
+  gesture_provider_.SetDoubleTapSupportForPageEnabled(enabled);
+}
+
+void ContentViewCoreImpl::SetDoubleTapSupportEnabled(JNIEnv* env,
+                                                     jobject obj,
+                                                     jboolean enabled) {
+  gesture_provider_.SetDoubleTapSupportForPlatformEnabled(enabled);
+}
+
+void ContentViewCoreImpl::SetMultiTouchZoomSupportEnabled(JNIEnv* env,
+                                                          jobject obj,
+                                                          jboolean enabled) {
+  gesture_provider_.SetMultiTouchSupportEnabled(enabled);
+}
+
 void ContentViewCoreImpl::LoadIfNecessary(JNIEnv* env, jobject obj) {
   web_contents_->GetController().LoadIfNecessary();
 }
 
 void ContentViewCoreImpl::RequestRestoreLoad(JNIEnv* env, jobject obj) {
   web_contents_->GetController().SetNeedsReload();
 }
 
 void ContentViewCoreImpl::StopLoading(JNIEnv* env, jobject obj) {
   web_contents_->Stop();
@@ skipping 391 matching lines @@
     // If it was actually enabled globally, enable it for this RenderWidget now.
     if (accessibility_state->IsAccessibleBrowser() && host_impl)
       host_impl->AddAccessibilityMode(AccessibilityModeComplete);
   } else {
     accessibility_state->ResetAccessibilityMode();
     if (host_impl)
       host_impl->ResetAccessibilityMode();
   }
 }
 
-void ContentViewCoreImpl::SendSingleTapUma(JNIEnv* env,
-                                           jobject obj,
-                                           jint type,
-                                           jint count) {
-  UMA_HISTOGRAM_ENUMERATION("Event.SingleTapType", type, count);
-}
-
-void ContentViewCoreImpl::SendActionAfterDoubleTapUma(JNIEnv* env,
-                                                      jobject obj,
-                                                      jint type,
-                                                      jboolean has_delay,
-                                                      jint count) {
-  // This UMA stat tracks a user's action after a double tap within
-  // k seconds (where k == 5 currently). This UMA will tell us if
-  // removing the tap gesture delay will lead to significantly more
-  // accidental navigations after a double tap.
-  if (has_delay) {
-    UMA_HISTOGRAM_ENUMERATION("Event.ActionAfterDoubleTapWithDelay", type,
-                              count);
-  } else {
-    UMA_HISTOGRAM_ENUMERATION("Event.ActionAfterDoubleTapNoDelay", type,
-                              count);
-  }
-}
-
 void ContentViewCoreImpl::SendOrientationChangeEventInternal() {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (rwhv)
     rwhv->UpdateScreenInfo(rwhv->GetNativeView());
 
   RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(
       web_contents_->GetRenderViewHost());
   rvhi->SendOrientationChangeEvent(device_orientation_);
 
   // TODO(mlamouri): temporary plumbing for Screen Orientation, this will change
@@ skipping 76 matching lines @@
       reinterpret_cast<ui::ViewAndroid*>(view_android),
       reinterpret_cast<ui::WindowAndroid*>(window_android));
   return reinterpret_cast<intptr_t>(view);
 }
 
 bool RegisterContentViewCore(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content