Re-route Touchscreen GesturePinch events to root view.

content/browser/renderer_host/render_widget_host_input_event_router.cc

 // Copyright 2015 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/renderer_host/render_widget_host_input_event_router.h"
 
 #include "base/debug/dump_without_crashing.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/frame_messages.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 namespace {
 
 void TransformEventTouchPositions(blink::WebTouchEvent* event,
                                   const gfx::Vector2d& delta) {
   for (unsigned i = 0; i < event->touchesLength; ++i) {
      event->touches[i].position.x += delta.x();
@@ skipping 67 matching lines @@
 bool RenderWidgetHostInputEventRouter::HittestDelegate::AcceptHitTarget(
     const cc::SurfaceDrawQuad* surface_quad,
     const gfx::Point& point_in_quad_space) {
   auto it = hittest_data_.find(surface_quad->surface_id);
   if (it != hittest_data_.end() && !it->second.ignored_for_hittest)
     return true;
   return false;
 }
 
 RenderWidgetHostInputEventRouter::RenderWidgetHostInputEventRouter()
-    : active_touches_(0) {}
+    : active_touches_(0),
+      in_touchscreen_gesture_pinch_(false),
+      gesture_pinch_did_send_scroll_begin_(false) {}
 
 RenderWidgetHostInputEventRouter::~RenderWidgetHostInputEventRouter() {
   // We may be destroyed before some of the owners in the map, so we must
   // remove ourself from their observer lists.
   ClearAllObserverRegistrations();
 }
 
 RenderWidgetHostViewBase* RenderWidgetHostInputEventRouter::FindEventTarget(
     RenderWidgetHostViewBase* root_view,
     const gfx::Point& point,
@@ skipping 204 matching lines @@
 
   bubbling_gesture_scroll_target_.target = target_view;
 
   SendGestureScrollBegin(target_view, event);
   target_view->ProcessGestureEvent(event, ui::LatencyInfo());
 }
 
 void RenderWidgetHostInputEventRouter::SendGestureScrollBegin(
     RenderWidgetHostViewBase* view,
     const blink::WebGestureEvent& event) {
-  DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate);
+  DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate ||
+         event.type == blink::WebInputEvent::GesturePinchBegin);
   blink::WebGestureEvent scroll_begin(event);
   scroll_begin.type = blink::WebInputEvent::GestureScrollBegin;
   scroll_begin.data.scrollBegin.deltaXHint = event.data.scrollUpdate.deltaX;
   scroll_begin.data.scrollBegin.deltaYHint = event.data.scrollUpdate.deltaY;
   scroll_begin.data.scrollBegin.deltaHintUnits =
       event.data.scrollUpdate.deltaUnits;
   view->ProcessGestureEvent(scroll_begin, ui::LatencyInfo());
 }
 
 void RenderWidgetHostInputEventRouter::SendGestureScrollEnd(
     RenderWidgetHostViewBase* view,
     const blink::WebGestureEvent& event) {
-  DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate);
+  DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate ||
+         event.type == blink::WebInputEvent::GesturePinchEnd);
   blink::WebGestureEvent scroll_end(event);
   scroll_end.type = blink::WebInputEvent::GestureScrollEnd;
   scroll_end.timeStampSeconds =
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
   scroll_end.data.scrollEnd.inertialPhase =
       event.data.scrollUpdate.inertialPhase;
   scroll_end.data.scrollEnd.deltaUnits = event.data.scrollUpdate.deltaUnits;
   view->ProcessGestureEvent(scroll_end, ui::LatencyInfo());
 }
 
@@ skipping 40 matching lines @@
   data.ignored_for_hittest = params.ignored_for_hittest;
   hittest_data_[params.surface_id] = data;
 }
 
 void RenderWidgetHostInputEventRouter::RouteTouchscreenGestureEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebGestureEvent* event,
     const ui::LatencyInfo& latency) {
   DCHECK_EQ(blink::WebGestureDeviceTouchscreen, event->sourceDevice);
 
+  if (event->type == blink::WebInputEvent::GesturePinchBegin) {
+    in_touchscreen_gesture_pinch_ = true;
+    // If the root view wasn't already receiving the gesture stream, then we
+    // need to wrap the diverted pinch events in a GestureScrollBegin/End.
+    // TODO(wjmaclean,kenrb,tdresser): When scroll latching lands, we can
+    // revisit how this code should work.
+    // https://crbug.com/526463
+    auto rwhi =
+        static_cast<RenderWidgetHostImpl*>(root_view->GetRenderWidgetHost());
+    // If the root view is the current gesture target, then we explicitly don't
+    // send a GestureScrollBegin, as by the time we see GesturePinchBegin there
+    // should have been one.
+    if (root_view != touchscreen_gesture_target_.target &&
+        !rwhi->is_in_touchscreen_gesture_scroll()) {
+      gesture_pinch_did_send_scroll_begin_ = true;
+      SendGestureScrollBegin(root_view, *event);
+    }
+  }
+
+  if (in_touchscreen_gesture_pinch_) {
+    root_view->ProcessGestureEvent(*event, latency);
+    if (event->type == blink::WebInputEvent::GesturePinchEnd) {
+      in_touchscreen_gesture_pinch_ = false;
+      // If the root view wasn't already receiving the gesture stream, then we
+      // need to wrap the diverted pinch events in a GestureScrollBegin/End.
+      auto rwhi =
+          static_cast<RenderWidgetHostImpl*>(root_view->GetRenderWidgetHost());
+      if (root_view != touchscreen_gesture_target_.target &&
+          gesture_pinch_did_send_scroll_begin_ &&
+          rwhi->is_in_touchscreen_gesture_scroll()) {
+        SendGestureScrollEnd(root_view, *event);
+      }
+      gesture_pinch_did_send_scroll_begin_ = false;
+    }
+    return;
+  }
+
   // We use GestureTapDown to detect the start of a gesture sequence since there
   // is no WebGestureEvent equivalent for ET_GESTURE_BEGIN. Note that this
   // means the GestureFlingCancel that always comes between ET_GESTURE_BEGIN and
   // GestureTapDown is sent to the previous target, in case it is still in a
   // fling.
   if (event->type == blink::WebInputEvent::GestureTapDown) {
     if (touchscreen_gesture_target_queue_.empty()) {
       LOG(ERROR) << "Gesture sequence start detected with no target available.";
       // Ignore this gesture sequence as no target is available.
       // TODO(wjmaclean): this only happens on Windows, and should not happen.
@@ skipping 57 matching lines @@
   if (!touchpad_gesture_target_.target)
     return;
 
   // TODO(mohsen): Add tests to check event location.
   event->x += touchpad_gesture_target_.delta.x();
   event->y += touchpad_gesture_target_.delta.y();
   touchpad_gesture_target_.target->ProcessGestureEvent(*event, latency);
 }
 
 }  // namespace content