Add support for touch-action: pinch-zoom.

content/browser/renderer_host/input/touch_action_filter.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 "content/browser/renderer_host/input/touch_action_filter.h"
 
 #include <math.h>
 
 #include "base/logging.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
@@ skipping 26 matching lines @@
 
 bool TouchActionFilter::FilterGestureEvent(WebGestureEvent* gesture_event) {
   if (gesture_event->sourceDevice != blink::WebGestureDeviceTouchscreen)
     return false;
 
   // Filter for allowable touch actions first (eg. before the TouchEventQueue
   // can decide to send a touch cancel event).
   switch (gesture_event->type) {
     case WebInputEvent::GestureScrollBegin:
       DCHECK(!drop_scroll_gesture_events_);
+      DCHECK(!drop_pinch_gesture_events_);
+      drop_pinch_gesture_events_ =
+          (allowed_touch_action_ & TOUCH_ACTION_PINCH_ZOOM) == 0;
       drop_scroll_gesture_events_ = ShouldSuppressScroll(*gesture_event);
       return drop_scroll_gesture_events_;
 
     case WebInputEvent::GestureScrollUpdate:
       if (drop_scroll_gesture_events_) {
         return true;
       } else {
         // Scrolls restricted to a specific axis shouldn't permit movement
         // in the perpendicular axis.
         if (IsYAxisActionDisallowed(allowed_touch_action_)) {
@@ skipping 23 matching lines @@
             !gesture_event->data.flingStart.velocityY) {
           gesture_event->type = WebInputEvent::GestureScrollEnd;
         }
       }
       return FilterScrollEndingGesture();
 
     case WebInputEvent::GestureScrollEnd:
       return FilterScrollEndingGesture();
 
     case WebInputEvent::GesturePinchBegin:
-      DCHECK(!drop_pinch_gesture_events_);
-      if (allowed_touch_action_ & TOUCH_ACTION_PINCH_ZOOM) {
-        // Pinch events are always bracketed by scroll events, and the W3C
-        // standard touch-action provides no way to disable scrolling without
-        // also disabling pinching (validated by the IPC ENUM traits).
-        DCHECK(allowed_touch_action_ == TOUCH_ACTION_AUTO ||
-            allowed_touch_action_ == TOUCH_ACTION_MANIPULATION);
-        DCHECK(!drop_scroll_gesture_events_);
-      } else {
-        drop_pinch_gesture_events_ = true;
-      }
       return drop_pinch_gesture_events_;
 
     case WebInputEvent::GesturePinchUpdate:
       return drop_pinch_gesture_events_;
 
     case WebInputEvent::GesturePinchEnd:
       if (drop_pinch_gesture_events_) {
         drop_pinch_gesture_events_ = false;
         return true;
       }
-      DCHECK(!drop_scroll_gesture_events_);
       break;
 
     // The double tap gesture is a tap ending event. If a double tap gesture is
     // filtered out, replace it with a tap event.
     case WebInputEvent::GestureDoubleTap:
       DCHECK_EQ(1, gesture_event->data.tap.tapCount);
       if (!allow_current_double_tap_event_)
         gesture_event->type = WebInputEvent::GestureTap;
       allow_current_double_tap_event_ = true;
       break;
@@ skipping 27 matching lines @@
     default:
       // Gesture events unrelated to touch actions (panning/zooming) are left
       // alone.
       break;
   }
 
   return false;
 }
 
 bool TouchActionFilter::FilterScrollEndingGesture() {
-  DCHECK(!drop_pinch_gesture_events_);
+  drop_pinch_gesture_events_ = false;
   if (drop_scroll_gesture_events_) {
     drop_scroll_gesture_events_ = false;
     return true;
   }
   return false;
 }
 
 void TouchActionFilter::OnSetTouchAction(TouchAction touch_action) {
   // For multiple fingers, we take the intersection of the touch actions for
   // all fingers that have gone down during this action.  In the majority of
@@ skipping 11 matching lines @@
 
 void TouchActionFilter::ResetTouchAction() {
   // Note that resetting the action mid-sequence is tolerated. Gestures that had
   // their begin event(s) suppressed will be suppressed until the next sequence.
   allowed_touch_action_ = TOUCH_ACTION_AUTO;
 }
 
 bool TouchActionFilter::ShouldSuppressScroll(
     const blink::WebGestureEvent& gesture_event) {
   DCHECK_EQ(gesture_event.type, WebInputEvent::GestureScrollBegin);
+  // if there are two or more pointers then ensure that we allow panning
+  // if pinch-zoom is allowed. Determine if this should really occur in the
+  // GestureScrollBegin or not; see crbug.com/649034.
+  if (!drop_pinch_gesture_events_ &&
+       gesture_event.data.scrollBegin.pointerCount >= 2) {
+    return false;
+  }
+
   if ((allowed_touch_action_ & TOUCH_ACTION_PAN) == TOUCH_ACTION_PAN)
     // All possible panning is enabled.
     return false;
+
   if (!(allowed_touch_action_ & TOUCH_ACTION_PAN))
     // No panning is enabled.
     return true;
 
   // If there's no hint or it's perfectly diagonal, then allow the scroll.
   if (fabs(gesture_event.data.scrollBegin.deltaXHint) ==
       fabs(gesture_event.data.scrollBegin.deltaYHint))
     return false;
 
   // Determine the primary initial axis of the scroll, and check whether
@@ skipping 16 matching lines @@
     } else if (gesture_event.data.scrollBegin.deltaYHint < 0 &&
                allowed_touch_action_ & TOUCH_ACTION_PAN_DOWN) {
       return false;
     } else {
       return true;
     }
   }
 }
 
 }  // namespace content