Add touch scrolling modes experimental flags (DEPRECATED)

content/browser/renderer_host/input/gesture_event_queue.cc

 // Copyright 2014 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/gesture_event_queue.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
 
@@ skipping 13 matching lines @@
   return event;
 }
 
 }  // namespace
 
 // GestureEventQueue
 
 GestureEventQueue::GestureEventQueue(GestureEventQueueClient* client)
     : client_(client),
       needs_tap_ending_event_(false),
-      needs_fling_ending_event_(false) {
+      needs_fling_ending_event_(false),
+      needs_scroll_ending_event_(false),
+      needs_pinch_ending_event_(false) {
   DCHECK(client_);
 }
 
 GestureEventQueue::~GestureEventQueue() {}
 
 void GestureEventQueue::OnGestureEventPacket(const GestureEventPacket& packet) {
   switch (packet.gesture_source()) {
     case GestureEventPacket::TOUCH_BEGIN:
       sequences_.push(GestureSequence());
       break;
 
     case GestureEventPacket::TOUCH:
       break;
 
     case GestureEventPacket::TOUCH_TIMEOUT:
       // Handle the timeout packet immediately if the packet preceding the
       // timeout has already been dispatched.
       if (Tail().IsEmpty()) {
-        if (!Tail().IsGesturePrevented())
-          SendPacket(packet);
+          FilterAndSendPacket(packet, Tail().IsGesturePrevented(),
+              INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
         return;
       }
       break;
 
     case GestureEventPacket::INVALID:
       NOTREACHED() << "Invalid gesture packet detected.";
       break;
   }
 
   Tail().Push(packet);
 }
 
 void GestureEventQueue::OnTouchEventAck(InputEventAckState ack_state) {
   if (Head().IsEmpty()) {
     CancelTapIfNecessary();
     CancelFlingIfNecessary();
     sequences_.pop();
   }
 
   GestureSequence& sequence = Head();
-  sequence.UpdateState(ack_state);
 
   // Dispatch the packet corresponding to the ack'ed touch, as well as any
   // additional timeout-based packets queued before the ack was received.
   bool touch_packet_for_current_ack_handled = false;
   while (!sequence.IsEmpty()) {
     const GestureEventPacket& packet = sequence.Front();
 
     if (packet.gesture_source() == GestureEventPacket::TOUCH_BEGIN ||
         packet.gesture_source() == GestureEventPacket::TOUCH) {
       // We should handle at most one touch-based packet corresponding to a
       // given ack.
       if (touch_packet_for_current_ack_handled)
         break;
+      if (!packet.is_independent() || packet.gesture_count() == 0)
+        sequence.UpdateState(ack_state);
       touch_packet_for_current_ack_handled = true;
     }
-
-    if (!sequence.IsGesturePrevented())
-      SendPacket(packet);
+    FilterAndSendPacket(packet, sequence.IsGesturePrevented(), ack_state);
 
     sequence.Pop();
   }
   DCHECK(touch_packet_for_current_ack_handled);
 
   // Immediately cancel a TapDown if TouchStart went unconsumed, but a
   // subsequent TouchMove is consumed.
   if (sequence.IsGesturePrevented())
     CancelTapIfNecessary();
 }
 
-void GestureEventQueue::SendPacket(const GestureEventPacket& packet) {
-  for (size_t i = 0; i < packet.gesture_count(); ++i)
-    SendGesture(packet.gesture(i));
+void GestureEventQueue::FilterAndSendPacket(
+    const GestureEventPacket& packet,
+    bool gesturePrevented,
+    InputEventAckState ack_state) {
+  for (size_t i = 0; i < packet.gesture_count(); ++i) {
+    const blink::WebGestureEvent& gesture = packet.gesture(i);
+
+    // Scroll and pinch ending events are sent if and only if their
+    // corresponding begin event was sent, regardless of the filtering state.
+    bool send = false;

[tdresser, 2014/02/03 15:52:58]

Need {} in this conditional.

[tdresser, 2014/02/03 18:55:14]

Done.

+    if (needs_scroll_ending_event_ &&
+        (gesture.type == WebInputEvent::GestureScrollEnd ||
+            gesture.type == WebInputEvent::GestureFlingStart))
+      send = true;
+    else if (needs_pinch_ending_event_ &&
+        gesture.type == WebInputEvent::GesturePinchEnd)
+      send = true;
+    // Other gestures are sent only when the current filtering state allows.
+    else if (!gesturePrevented) {
+      // Independent packets can be suppressed by the current ack state.
+      if (!(packet.is_independent() &&
+          ack_state == INPUT_EVENT_ACK_STATE_CONSUMED))
+        send = true;
+    }
+
+    if (send)
+      SendGesture(gesture);
+  }
 }
 
 void GestureEventQueue::SendGesture(const WebGestureEvent& event) {
+
   switch (event.type) {
     case WebInputEvent::GestureLongTap:
       CancelTapIfNecessary();
       CancelFlingIfNecessary();
       break;
     case WebInputEvent::GestureTapDown:
+      DCHECK(!needs_tap_ending_event_);
       needs_tap_ending_event_ = true;
       break;
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureTap:
     case WebInputEvent::GestureTapUnconfirmed:
     case WebInputEvent::GestureDoubleTap:
       needs_tap_ending_event_ = false;
       break;
     case WebInputEvent::GestureScrollBegin:
       CancelTapIfNecessary();
       CancelFlingIfNecessary();
+      DCHECK(!needs_scroll_ending_event_);
+      needs_scroll_ending_event_ = true;
       break;
     case WebInputEvent::GestureFlingStart:
       CancelFlingIfNecessary();
       needs_fling_ending_event_ = true;
+      // FALL THROUGH
+    case WebInputEvent::GestureScrollEnd:
+      DCHECK(needs_scroll_ending_event_);
+      needs_scroll_ending_event_ = false;
       break;
     case WebInputEvent::GestureFlingCancel:
       needs_fling_ending_event_ = false;
       break;
+    case WebInputEvent::GesturePinchBegin:
+      DCHECK(!needs_pinch_ending_event_);
+      needs_pinch_ending_event_ = true;
+      break;
+    case WebInputEvent::GesturePinchEnd:
+      DCHECK(needs_pinch_ending_event_);
+      needs_pinch_ending_event_ = false;
+      break;
     default:
       break;
   }
   client_->ForwardGestureEvent(event);
 }
 
 void GestureEventQueue::CancelTapIfNecessary() {
   if (!needs_tap_ending_event_)
     return;
 
@@ skipping 61 matching lines @@
 
 bool GestureEventQueue::GestureSequence::IsGesturePrevented() const {
   return state_ == ALWAYS_PREVENTED;
 }
 
 bool GestureEventQueue::GestureSequence::IsEmpty() const {
   return packets_.empty();
 }
 
 }  // namespace content