gesture recognizer: Change the way a processed touch-release event is handled.

Instead of creating a fake touch-cancelled event and sending that to the
gesture recognizer, send the raw touch-release event with the status of
the event-processing. Update the gesture recognizer (GestureSequence)
transitions to handle these events correctly instead.

BUG=none

Review URL: https://chromiumcodereview.appspot.com/10831295

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@151375 0039d316-1c4b-4281-b951-d872f2087c98

ui/aura/gestures/gesture_recognizer_unittest.cc

@@ -1883,6 +1883,90 @@ TEST_F(GestureRecognizerTest, NoTapWithPreventDefaultedRelease) {
   EXPECT_FALSE(delegate->tap());
 }
 
+TEST_F(GestureRecognizerTest, PinchScrollWithPreventDefaultedRelease) {
+  scoped_ptr<QueueTouchEventDelegate> delegate(
+      new QueueTouchEventDelegate(root_window()));
+  const int kTouchId1 = 7;
+  const int kTouchId2 = 5;
+  gfx::Rect bounds(10, 20, 100, 100);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+  delegate->set_window(window.get());
+
+  delegate->Reset();
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(15, 25), kTouchId1,
+      GetTime());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(20, 95), kTouchId1,
+      press.time_stamp() + base::TimeDelta::FromMilliseconds(200));
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(15, 25), kTouchId1,
+      move.time_stamp() + base::TimeDelta::FromMilliseconds(50));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move);
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
+  delegate->Reset();
+
+  // Ack the press event.
+  delegate->ReceivedAck();
+  EXPECT_TRUE(delegate->tap_down());
+  delegate->Reset();
+
+  // Ack the move event.
+  delegate->ReceivedAck();
+  EXPECT_TRUE(delegate->scroll_begin());
+  delegate->Reset();
+
+  // Ack the release event. Although the release event has been processed, it
+  // should still generate a scroll-end event.
+  delegate->ReceivedAckPreventDefaulted();
+  EXPECT_TRUE(delegate->scroll_end());
+
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(55, 25), kTouchId2,
+      GetTime());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(45, 85), kTouchId2,
+      press2.time_stamp() + base::TimeDelta::FromMilliseconds(1000));
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(45, 85), kTouchId2,
+      move2.time_stamp() + base::TimeDelta::FromMilliseconds(14));
+
+  // Do a pinch.
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move);
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move2);
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release2);
+
+  // Ack the press and move events.
+  delegate->Reset();
+  delegate->ReceivedAck();
+  EXPECT_TRUE(delegate->begin());
+  EXPECT_TRUE(delegate->tap_down());
+
+  delegate->Reset();
+  delegate->ReceivedAck();
+  EXPECT_TRUE(delegate->scroll_begin());
+
+  delegate->Reset();
+  delegate->ReceivedAck();
+  EXPECT_TRUE(delegate->begin());
+  EXPECT_FALSE(delegate->pinch_begin());
+
+  delegate->Reset();
+  delegate->ReceivedAck();
+  EXPECT_TRUE(delegate->pinch_begin());
+
+  // Ack the first release. Although the release is processed, it should still
+  // generate a pinch-end event.
+  delegate->Reset();
+  delegate->ReceivedAckPreventDefaulted();
+  EXPECT_TRUE(delegate->pinch_end());
+  EXPECT_TRUE(delegate->end());
+
+  delegate->Reset();
+  delegate->ReceivedAckPreventDefaulted();
+  EXPECT_TRUE(delegate->scroll_end());
+  EXPECT_TRUE(delegate->end());
+}
+
 TEST_F(GestureRecognizerTest, CaptureSendsGestureEnd) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());

ui/base/gestures/gesture_sequence.cc

@@ -82,6 +82,9 @@ enum EdgeStateSignatureType {
   GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED =
       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_RELEASED, TSI_NOT_PROCESSED),
 
+  GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED =
+      G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_RELEASED, TSI_PROCESSED),
+
   // Ignore processed touch-move events until gesture-scroll starts.
   GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED =
       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_MOVED, TSI_NOT_PROCESSED),
@@ -90,20 +93,20 @@ enum EdgeStateSignatureType {
       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_STATIONARY, TSI_NOT_PROCESSED),
 
   GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED =
-      G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_CANCELLED, TSI_NOT_PROCESSED),
+      G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_CANCELLED, TSI_ALWAYS),
 
   GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED =
       G(GS_PENDING_SYNTHETIC_CLICK, 1, TS_PRESSED, TSI_NOT_PROCESSED),
 
   GST_SCROLL_FIRST_RELEASED =
-      G(GS_SCROLL, 0, TS_RELEASED, TSI_NOT_PROCESSED),
+      G(GS_SCROLL, 0, TS_RELEASED, TSI_ALWAYS),
 
   // Once scroll has started, process all touch-move events.
   GST_SCROLL_FIRST_MOVED =
       G(GS_SCROLL, 0, TS_MOVED, TSI_ALWAYS),
 
   GST_SCROLL_FIRST_CANCELLED =
-      G(GS_SCROLL, 0, TS_CANCELLED, TSI_NOT_PROCESSED),
+      G(GS_SCROLL, 0, TS_CANCELLED, TSI_ALWAYS),
 
   GST_SCROLL_SECOND_PRESSED =
       G(GS_SCROLL, 1, TS_PRESSED, TSI_NOT_PROCESSED),
@@ -111,9 +114,15 @@ enum EdgeStateSignatureType {
   GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED =
       G(GS_PENDING_TWO_FINGER_TAP, 0, TS_RELEASED, TSI_NOT_PROCESSED),
 
+  GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED_HANDLED =
+      G(GS_PENDING_TWO_FINGER_TAP, 0, TS_RELEASED, TSI_PROCESSED),
+
   GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED =
       G(GS_PENDING_TWO_FINGER_TAP, 1, TS_RELEASED, TSI_NOT_PROCESSED),
 
+  GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED_HANDLED =
+      G(GS_PENDING_TWO_FINGER_TAP, 1, TS_RELEASED, TSI_PROCESSED),
+
   GST_PENDING_TWO_FINGER_TAP_FIRST_MOVED =
       G(GS_PENDING_TWO_FINGER_TAP, 0, TS_MOVED, TSI_ALWAYS),
 
@@ -121,10 +130,10 @@ enum EdgeStateSignatureType {
       G(GS_PENDING_TWO_FINGER_TAP, 1, TS_MOVED, TSI_ALWAYS),
 
   GST_PENDING_TWO_FINGER_TAP_FIRST_CANCELLED =
-      G(GS_PENDING_TWO_FINGER_TAP, 0, TS_CANCELLED, TSI_NOT_PROCESSED),
+      G(GS_PENDING_TWO_FINGER_TAP, 0, TS_CANCELLED, TSI_ALWAYS),
 
   GST_PENDING_TWO_FINGER_TAP_SECOND_CANCELLED =
-      G(GS_PENDING_TWO_FINGER_TAP, 1, TS_CANCELLED, TSI_NOT_PROCESSED),
+      G(GS_PENDING_TWO_FINGER_TAP, 1, TS_CANCELLED, TSI_ALWAYS),
 
   GST_PENDING_TWO_FINGER_TAP_THIRD_PRESSED =
       G(GS_PENDING_TWO_FINGER_TAP, 2, TS_PRESSED, TSI_NOT_PROCESSED),
@@ -136,16 +145,16 @@ enum EdgeStateSignatureType {
       G(GS_PINCH, 1, TS_MOVED, TSI_ALWAYS),
 
   GST_PINCH_FIRST_RELEASED =
-      G(GS_PINCH, 0, TS_RELEASED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 0, TS_RELEASED, TSI_ALWAYS),
 
   GST_PINCH_SECOND_RELEASED =
-      G(GS_PINCH, 1, TS_RELEASED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 1, TS_RELEASED, TSI_ALWAYS),
 
   GST_PINCH_FIRST_CANCELLED =
-      G(GS_PINCH, 0, TS_CANCELLED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 0, TS_CANCELLED, TSI_ALWAYS),
 
   GST_PINCH_SECOND_CANCELLED =
-      G(GS_PINCH, 1, TS_CANCELLED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 1, TS_CANCELLED, TSI_ALWAYS),
 
   GST_PINCH_THIRD_PRESSED =
       G(GS_PINCH, 2, TS_PRESSED, TSI_NOT_PROCESSED),
@@ -154,10 +163,10 @@ enum EdgeStateSignatureType {
       G(GS_PINCH, 2, TS_MOVED, TSI_ALWAYS),
 
   GST_PINCH_THIRD_RELEASED =
-      G(GS_PINCH, 2, TS_RELEASED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 2, TS_RELEASED, TSI_ALWAYS),
 
   GST_PINCH_THIRD_CANCELLED =
-      G(GS_PINCH, 2, TS_CANCELLED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 2, TS_CANCELLED, TSI_ALWAYS),
 
   GST_PINCH_FOURTH_PRESSED =
       G(GS_PINCH, 3, TS_PRESSED, TSI_NOT_PROCESSED),
@@ -166,10 +175,10 @@ enum EdgeStateSignatureType {
       G(GS_PINCH, 3, TS_MOVED, TSI_ALWAYS),
 
   GST_PINCH_FOURTH_RELEASED =
-      G(GS_PINCH, 3, TS_RELEASED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 3, TS_RELEASED, TSI_ALWAYS),
 
   GST_PINCH_FOURTH_CANCELLED =
-      G(GS_PINCH, 3, TS_CANCELLED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 3, TS_CANCELLED, TSI_ALWAYS),
 
   GST_PINCH_FIFTH_PRESSED =
       G(GS_PINCH, 4, TS_PRESSED, TSI_NOT_PROCESSED),
@@ -178,10 +187,10 @@ enum EdgeStateSignatureType {
       G(GS_PINCH, 4, TS_MOVED, TSI_ALWAYS),
 
   GST_PINCH_FIFTH_RELEASED =
-      G(GS_PINCH, 4, TS_RELEASED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 4, TS_RELEASED, TSI_ALWAYS),
 
   GST_PINCH_FIFTH_CANCELLED =
-      G(GS_PINCH, 4, TS_CANCELLED, TSI_NOT_PROCESSED),
+      G(GS_PINCH, 4, TS_CANCELLED, TSI_ALWAYS),
 };
 
 // Builds a signature. Signatures are assembled by joining together
@@ -203,6 +212,7 @@ EdgeStateSignatureType Signature(GestureState gesture_state,
   switch (signature) {
     case GST_NO_GESTURE_FIRST_PRESSED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED:
+    case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_STATIONARY:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED:
@@ -212,7 +222,9 @@ EdgeStateSignatureType Signature(GestureState gesture_state,
     case GST_SCROLL_FIRST_CANCELLED:
     case GST_SCROLL_SECOND_PRESSED:
     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED:
+    case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED_HANDLED:
     case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED:
+    case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED_HANDLED:
     case GST_PENDING_TWO_FINGER_TAP_FIRST_MOVED:
     case GST_PENDING_TWO_FINGER_TAP_SECOND_MOVED:
     case GST_PENDING_TWO_FINGER_TAP_FIRST_CANCELLED:
@@ -356,6 +368,7 @@ GestureSequence::Gestures* GestureSequence::ProcessTouchEventForGesture(
           point.UpdateForScroll();
       }
       break;
+    case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED:
       set_state(GS_NO_GESTURE);
       break;
@@ -391,6 +404,8 @@ GestureSequence::Gestures* GestureSequence::ProcessTouchEventForGesture(
       if (TwoFingerTouchMove(event, point, gestures.get()))
         set_state(GS_PINCH);
       break;
+    case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED_HANDLED:
+    case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED_HANDLED:
     case GST_PENDING_TWO_FINGER_TAP_FIRST_CANCELLED:
     case GST_PENDING_TWO_FINGER_TAP_SECOND_CANCELLED:
       scroll_type_ = ST_FREE;