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

ui/events/gesture_detection/touch_disposition_gesture_filter_unittest.cc

Index: ui/events/gesture_detection/touch_disposition_gesture_filter_unittest.cc
diff --git a/content/browser/renderer_host/input/touch_disposition_gesture_filter_unittest.cc b/ui/events/gesture_detection/touch_disposition_gesture_filter_unittest.cc
similarity index 45%
rename from content/browser/renderer_host/input/touch_disposition_gesture_filter_unittest.cc
rename to ui/events/gesture_detection/touch_disposition_gesture_filter_unittest.cc
index 16b4b7e4d94d456417d74e37e91cd98542e26e1a..a38dc95e4fad7e163afc085c78a94f7171c96aac 100644
--- a/content/browser/renderer_host/input/touch_disposition_gesture_filter_unittest.cc
+++ b/ui/events/gesture_detection/touch_disposition_gesture_filter_unittest.cc
@@ -4,25 +4,17 @@
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
-#include "content/browser/renderer_host/input/touch_disposition_gesture_filter.h"
-#include "content/common/input/synthetic_web_input_event_builders.h"
-#include "content/common/input/web_input_event_traits.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "ui/events/gesture_detection/mock_motion_event.h"
+#include "ui/events/gesture_detection/touch_disposition_gesture_filter.h"
 
-using blink::WebGestureEvent;
-using blink::WebInputEvent;
-using blink::WebTouchEvent;
-using blink::WebTouchPoint;
-
-namespace content {
+namespace ui {
 
 class TouchDispositionGestureFilterTest
     : public testing::Test,
       public TouchDispositionGestureFilterClient {
  public:
   TouchDispositionGestureFilterTest() : sent_gesture_count_(0) {}
-
   virtual ~TouchDispositionGestureFilterTest() {}
 
   // testing::Test
@@ -35,13 +27,13 @@ class TouchDispositionGestureFilterTest
   }
 
   // TouchDispositionGestureFilterClient
-  virtual void ForwardGestureEvent(const WebGestureEvent& event) OVERRIDE {
+  virtual void ForwardGestureEvent(const GestureEventData& event) OVERRIDE {
     ++sent_gesture_count_;
     sent_gestures_.push_back(event.type);
   }
 
  protected:
-  typedef std::vector<WebInputEvent::Type> GestureList;
+  typedef std::vector<GestureEventType> GestureList;
 
   ::testing::AssertionResult GesturesMatch(const GestureList& expected,
                                            const GestureList& actual) {
@@ -55,29 +47,29 @@ class TouchDispositionGestureFilterTest
       if (expected[i] != actual[i]) {
         return ::testing::AssertionFailure()
             << "actual[" << i << "] ("
-            << WebInputEventTraits::GetName(actual[i])
+            << actual[i]
             << ") != expected[" << i << "] ("
-            << WebInputEventTraits::GetName(expected[i]) << ")";
+            << expected[i] << ")";
       }
     }
 
     return ::testing::AssertionSuccess();
   }
 
-  GestureList Gestures(WebInputEvent::Type type) {
+  GestureList Gestures(GestureEventType type) {
     return GestureList(1, type);
   }
 
-  GestureList Gestures(WebInputEvent::Type type0, WebInputEvent::Type type1) {
+  GestureList Gestures(GestureEventType type0, GestureEventType type1) {
     GestureList gestures(2);
     gestures[0] = type0;
     gestures[1] = type1;
     return gestures;
   }
 
-  GestureList Gestures(WebInputEvent::Type type0,
-                       WebInputEvent::Type type1,
-                       WebInputEvent::Type type2) {
+  GestureList Gestures(GestureEventType type0,
+                       GestureEventType type1,
+                       GestureEventType type2) {
     GestureList gestures(3);
     gestures[0] = type0;
     gestures[1] = type1;
@@ -85,10 +77,10 @@ class TouchDispositionGestureFilterTest
     return gestures;
   }
 
-  GestureList Gestures(WebInputEvent::Type type0,
-                       WebInputEvent::Type type1,
-                       WebInputEvent::Type type2,
-                       WebInputEvent::Type type3) {
+  GestureList Gestures(GestureEventType type0,
+                       GestureEventType type1,
+                       GestureEventType type2,
+                       GestureEventType type3) {
     GestureList gestures(4);
     gestures[0] = type0;
     gestures[1] = type1;
@@ -98,38 +90,51 @@ class TouchDispositionGestureFilterTest
   }
 
   void SendTouchGestures() {
-    GestureEventPacket gesture_packet;
+    GestureEventDataPacket gesture_packet;
     std::swap(gesture_packet, pending_gesture_packet_);
     EXPECT_EQ(TouchDispositionGestureFilter::SUCCESS,
               SendTouchGestures(touch_event_, gesture_packet));
-    touch_event_.ResetPoints();
   }
 
   TouchDispositionGestureFilter::PacketResult
-  SendTouchGestures(const WebTouchEvent& touch,
-                    const GestureEventPacket& packet) {
-    GestureEventPacket touch_packet = GestureEventPacket::FromTouch(touch);
+  SendTouchGestures(const MotionEvent& touch,
+                    const GestureEventDataPacket& packet) {
+    GestureEventDataPacket touch_packet =
+        GestureEventDataPacket::FromTouch(touch);
     for (size_t i = 0; i < packet.gesture_count(); ++i)
       touch_packet.Push(packet.gesture(i));
-    return queue_->OnGestureEventPacket(touch_packet);
+    return queue_->OnGesturePacket(touch_packet);
   }
 
   TouchDispositionGestureFilter::PacketResult
-  SendTimeoutGesture(WebInputEvent::Type type) {
-    return queue_->OnGestureEventPacket(
-        GestureEventPacket::FromTouchTimeout(CreateGesture(type)));
+  SendTimeoutGesture(GestureEventType type) {
+    return queue_->OnGesturePacket(
+        GestureEventDataPacket::FromTouchTimeout(CreateGesture(type)));
   }
 
   TouchDispositionGestureFilter::PacketResult
-  SendGesturePacket(const GestureEventPacket& packet) {
-    return queue_->OnGestureEventPacket(packet);
+  SendGesturePacket(const GestureEventDataPacket& packet) {
+    return queue_->OnGesturePacket(packet);
   }
 
-  void SendTouchEventACK(InputEventAckState ack_result) {
+  void SendTouchEventACK(
+      TouchDispositionGestureFilter::TouchEventAck ack_result) {
     queue_->OnTouchEventAck(ack_result);
   }
 
-  void PushGesture(WebInputEvent::Type type) {
+  void SendTouchConsumedAck() {
+    SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  }
+
+  void SendNotConsumedAck() {
+    SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  }
+
+  void SendNoConsumerExistsAck() {
+    SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
+  }
+
+  void PushGesture(GestureEventType type) {
     pending_gesture_packet_.Push(CreateGesture(type));
   }
 
@@ -138,18 +143,18 @@ class TouchDispositionGestureFilterTest
     SendTouchGestures();
   }
 
-  void MoveTouchPoint(int index, int x, int y) {
+  void MoveTouchPoint(size_t index, int x, int y) {
     touch_event_.MovePoint(index, x, y);
     SendTouchGestures();
   }
 
-  void ReleaseTouchPoint(int index) {
-    touch_event_.ReleasePoint(index);
+  void ReleaseTouchPoint() {
+    touch_event_.ReleasePoint();
     SendTouchGestures();
   }
 
-  void CancelTouchPoint(int index) {
-    touch_event_.CancelPoint(index);
+  void CancelTouchPoint() {
+    touch_event_.CancelPoint();
     SendTouchGestures();
   }
 
@@ -167,15 +172,15 @@ class TouchDispositionGestureFilterTest
     return sent_gestures;
   }
 
-  static WebGestureEvent CreateGesture(WebInputEvent::Type type) {
-    return SyntheticWebGestureEventBuilder::Build(
-        type, WebGestureEvent::Touchscreen);
+  static GestureEventData CreateGesture(GestureEventType type) {
+    return GestureEventData(
+        type, base::TimeTicks(), 0, 0, GestureEventData::Details());
   }
 
  private:
   scoped_ptr<TouchDispositionGestureFilter> queue_;
-  SyntheticWebTouchEvent touch_event_;
-  GestureEventPacket pending_gesture_packet_;
+  MockMotionEvent touch_event_;
+  GestureEventDataPacket pending_gesture_packet_;
   size_t sent_gesture_count_;
   GestureList sent_gestures_;
 };
@@ -189,456 +194,473 @@ TEST_F(TouchDispositionGestureFilterTest, BasicNoGestures) {
 
   // No gestures should be dispatched by the ack, as the queued packets
   // contained no gestures.
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // Release the touch gesture.
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, BasicGestures) {
   // An unconsumed touch's gesture should be sent.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
   EXPECT_FALSE(GesturesSent());
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN),
                             GetAndResetSentGestures()));
 
   // Multiple gestures can be queued for a single event.
-  PushGesture(WebInputEvent::GestureFlingStart);
-  PushGesture(WebInputEvent::GestureFlingCancel);
-  ReleaseTouchPoint(0);
+  PushGesture(GESTURE_FLING_START);
+  PushGesture(GESTURE_FLING_CANCEL);
+  ReleaseTouchPoint();
   EXPECT_FALSE(GesturesSent());
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingStart,
-                                     WebInputEvent::GestureFlingCancel),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_FLING_START,
+                                     GESTURE_FLING_CANCEL),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, BasicGesturesConsumed) {
   // A consumed touch's gesture should not be sent.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GestureFlingStart);
-  PushGesture(WebInputEvent::GestureFlingCancel);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  PushGesture(GESTURE_FLING_START);
+  PushGesture(GESTURE_FLING_CANCEL);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, ConsumedThenNotConsumed) {
   // A consumed touch's gesture should not be sent.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // Even if the subsequent touch is not consumed, continue dropping gestures.
-  PushGesture(WebInputEvent::GestureScrollUpdate);
+  PushGesture(GESTURE_SCROLL_UPDATE);
   MoveTouchPoint(0, 2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // Even if the subsequent touch had no consumer, continue dropping gestures.
-  PushGesture(WebInputEvent::GestureFlingStart);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  PushGesture(GESTURE_FLING_START);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenConsumed) {
   // A not consumed touch's gesture should be sent.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN),
                             GetAndResetSentGestures()));
 
   // A newly consumed gesture should not be sent.
-  PushGesture(WebInputEvent::GesturePinchBegin);
+  PushGesture(GESTURE_PINCH_BEGIN);
   PressTouchPoint(10, 10);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // And subsequent non-consumed pinch updates should not be sent.
-  PushGesture(WebInputEvent::GestureScrollUpdate);
-  PushGesture(WebInputEvent::GesturePinchUpdate);
+  PushGesture(GESTURE_SCROLL_UPDATE);
+  PushGesture(GESTURE_PINCH_UPDATE);
   MoveTouchPoint(0, 2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollUpdate),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_UPDATE),
                             GetAndResetSentGestures()));
 
   // End events dispatched only when their start events were.
-  PushGesture(WebInputEvent::GesturePinchEnd);
-  ReleaseTouchPoint(1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  PushGesture(GESTURE_PINCH_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollEnd),
+  PushGesture(GESTURE_SCROLL_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_END),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, ScrollAlternatelyConsumed) {
   // A consumed touch's gesture should not be sent.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN),
                             GetAndResetSentGestures()));
 
   for (size_t i = 0; i < 3; ++i) {
-    PushGesture(WebInputEvent::GestureScrollUpdate);
+    PushGesture(GESTURE_SCROLL_UPDATE);
     MoveTouchPoint(0, 2, 2);
-    SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+    SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
     EXPECT_FALSE(GesturesSent());
 
-    PushGesture(WebInputEvent::GestureScrollUpdate);
+    PushGesture(GESTURE_SCROLL_UPDATE);
     MoveTouchPoint(0, 3, 3);
-    SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-    EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollUpdate),
+    SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+    EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_UPDATE),
                               GetAndResetSentGestures()));
   }
 
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollEnd),
+  PushGesture(GESTURE_SCROLL_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_END),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenNoConsumer) {
   // An unconsumed touch's gesture should be sent.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN),
                             GetAndResetSentGestures()));
 
   // If the subsequent touch has no consumer (e.g., a secondary pointer is
   // pressed but not on a touch handling rect), send the gesture.
-  PushGesture(WebInputEvent::GesturePinchBegin);
+  PushGesture(GESTURE_PINCH_BEGIN);
   PressTouchPoint(2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_PINCH_BEGIN),
                             GetAndResetSentGestures()));
 
   // End events should be dispatched when their start events were, independent
   // of the ack state.
-  PushGesture(WebInputEvent::GesturePinchEnd);
-  ReleaseTouchPoint(1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchEnd),
+  PushGesture(GESTURE_PINCH_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_PINCH_END),
                             GetAndResetSentGestures()));
 
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollEnd),
+  PushGesture(GESTURE_SCROLL_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_END),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, EndingEventsSent) {
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN),
                             GetAndResetSentGestures()));
 
-  PushGesture(WebInputEvent::GesturePinchBegin);
+  PushGesture(GESTURE_PINCH_BEGIN);
   PressTouchPoint(2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_PINCH_BEGIN),
                             GetAndResetSentGestures()));
 
   // Consuming the touchend event can't suppress the match end gesture.
-  PushGesture(WebInputEvent::GesturePinchEnd);
-  ReleaseTouchPoint(1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchEnd),
+  PushGesture(GESTURE_PINCH_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_PINCH_END),
                             GetAndResetSentGestures()));
 
   // But other events in the same packet are still suppressed.
-  PushGesture(WebInputEvent::GestureScrollUpdate);
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollEnd),
+  PushGesture(GESTURE_SCROLL_UPDATE);
+  PushGesture(GESTURE_SCROLL_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_END),
                             GetAndResetSentGestures()));
 
-  // GestureScrollEnd and GestureFlingStart behave the same in this regard.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  // GESTURE_SCROLL_END and GESTURE_FLING_START behave the same in this regard.
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN),
                             GetAndResetSentGestures()));
 
-  PushGesture(WebInputEvent::GestureFlingStart);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingStart),
+  PushGesture(GESTURE_FLING_START);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_FLING_START),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, EndingEventsNotSent) {
   // Consuming a begin event ensures no end events are sent.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GesturePinchBegin);
+  PushGesture(GESTURE_PINCH_BEGIN);
   PressTouchPoint(2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GesturePinchEnd);
-  ReleaseTouchPoint(1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  PushGesture(GESTURE_PINCH_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  PushGesture(GESTURE_SCROLL_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, UpdateEventsSuppressedPerEvent) {
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN),
                             GetAndResetSentGestures()));
 
   // Consuming a single scroll or pinch update should suppress only that event.
-  PushGesture(WebInputEvent::GestureScrollUpdate);
+  PushGesture(GESTURE_SCROLL_UPDATE);
   MoveTouchPoint(0, 2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GesturePinchBegin);
+  PushGesture(GESTURE_PINCH_BEGIN);
   PressTouchPoint(2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_PINCH_BEGIN),
                             GetAndResetSentGestures()));
 
-  PushGesture(WebInputEvent::GesturePinchUpdate);
+  PushGesture(GESTURE_PINCH_UPDATE);
   MoveTouchPoint(1, 2, 3);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // Subsequent updates should not be affected.
-  PushGesture(WebInputEvent::GestureScrollUpdate);
+  PushGesture(GESTURE_SCROLL_UPDATE);
   MoveTouchPoint(0, 4, 4);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollUpdate),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_UPDATE),
                             GetAndResetSentGestures()));
 
-  PushGesture(WebInputEvent::GesturePinchUpdate);
+  PushGesture(GESTURE_PINCH_UPDATE);
   MoveTouchPoint(0, 4, 5);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchUpdate),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_PINCH_UPDATE),
                             GetAndResetSentGestures()));
 
-  PushGesture(WebInputEvent::GesturePinchEnd);
-  ReleaseTouchPoint(1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GesturePinchEnd),
+  PushGesture(GESTURE_PINCH_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_PINCH_END),
                             GetAndResetSentGestures()));
 
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollEnd),
+  PushGesture(GESTURE_SCROLL_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_END),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, UpdateEventsDependOnBeginEvents) {
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // Scroll and pinch gestures depend on the scroll begin gesture being
   // dispatched.
-  PushGesture(WebInputEvent::GestureScrollUpdate);
+  PushGesture(GESTURE_SCROLL_UPDATE);
   MoveTouchPoint(0, 2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GesturePinchBegin);
+  PushGesture(GESTURE_PINCH_BEGIN);
   PressTouchPoint(2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GesturePinchUpdate);
+  PushGesture(GESTURE_PINCH_UPDATE);
   MoveTouchPoint(1, 2, 3);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GesturePinchEnd);
-  ReleaseTouchPoint(1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  PushGesture(GESTURE_PINCH_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  PushGesture(GESTURE_SCROLL_END);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, MultipleTouchSequences) {
   // Queue two touch-to-gestures sequences.
-  PushGesture(WebInputEvent::GestureTapDown);
+  PushGesture(GESTURE_TAP_DOWN);
   PressTouchPoint(1, 1);
-  PushGesture(WebInputEvent::GestureTap);
-  ReleaseTouchPoint(0);
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_TAP);
+  ReleaseTouchPoint();
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  ReleaseTouchPoint(0);
+  PushGesture(GESTURE_SCROLL_END);
+  ReleaseTouchPoint();
 
   // The first gesture sequence should not be allowed.
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
   // The subsequent sequence should "reset" allowance.
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin,
-                                     WebInputEvent::GestureScrollEnd),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN,
+                                     GESTURE_SCROLL_END),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnNewTouchSequence) {
   // Simulate a fling.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN),
                             GetAndResetSentGestures()));
-  PushGesture(WebInputEvent::GestureFlingStart);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingStart),
+  PushGesture(GESTURE_FLING_START);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_FLING_START),
                             GetAndResetSentGestures()));
 
   // A new touch seqeuence should cancel the outstanding fling.
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingCancel),
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_FLING_CANCEL),
                             GetAndResetSentGestures()));
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
   EXPECT_FALSE(GesturesSent());
 }
 
+TEST_F(TouchDispositionGestureFilterTest, ScrollEndedOnNewTouchSequence) {
+  // Simulate a scroll.
+  PushGesture(GESTURE_SCROLL_BEGIN);
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN),
+                            GetAndResetSentGestures()));
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
+
+  // A new touch seqeuence should end the outstanding scroll.
+  PressTouchPoint(1, 1);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_END),
+                            GetAndResetSentGestures()));
+}
+
 TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnScrollBegin) {
   // Simulate a fling sequence.
-  PushGesture(WebInputEvent::GestureScrollBegin);
-  PushGesture(WebInputEvent::GestureFlingStart);
+  PushGesture(GESTURE_SCROLL_BEGIN);
+  PushGesture(GESTURE_FLING_START);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin,
-                                     WebInputEvent::GestureFlingStart),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN,
+                                     GESTURE_FLING_START),
                             GetAndResetSentGestures()));
 
   // The new fling should cancel the preceding one.
-  PushGesture(WebInputEvent::GestureScrollBegin);
-  PushGesture(WebInputEvent::GestureFlingStart);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureFlingCancel,
-                                     WebInputEvent::GestureScrollBegin,
-                                     WebInputEvent::GestureFlingStart),
+  PushGesture(GESTURE_SCROLL_BEGIN);
+  PushGesture(GESTURE_FLING_START);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_FLING_CANCEL,
+                                     GESTURE_SCROLL_BEGIN,
+                                     GESTURE_FLING_START),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, FlingNotCancelledIfGFCEventReceived) {
   // Simulate a fling that is started then cancelled.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  PushGesture(WebInputEvent::GestureFlingStart);
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
+  PushGesture(GESTURE_FLING_START);
   MoveTouchPoint(0, 1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  PushGesture(WebInputEvent::GestureFlingCancel);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin,
-                                     WebInputEvent::GestureFlingStart,
-                                     WebInputEvent::GestureFlingCancel),
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
+  PushGesture(GESTURE_FLING_CANCEL);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN,
+                                     GESTURE_FLING_START,
+                                     GESTURE_FLING_CANCEL),
                             GetAndResetSentGestures()));
 
-  // A new touch sequence will not inject a GestureFlingCancel, as the fling
+  // A new touch sequence will not inject a GESTURE_FLING_CANCEL, as the fling
   // has already been cancelled.
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NO_CONSUMER_EXISTS);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenScrollBegins) {
-  PushGesture(WebInputEvent::GestureTapDown);
+  PushGesture(GESTURE_TAP_DOWN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapDown),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP_DOWN),
                             GetAndResetSentGestures()));
 
   // If the subsequent touch turns into a scroll, the tap should be cancelled.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   MoveTouchPoint(0, 2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapCancel,
-                                     WebInputEvent::GestureScrollBegin),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP_CANCEL,
+                                     GESTURE_SCROLL_BEGIN),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenTouchConsumed) {
-  PushGesture(WebInputEvent::GestureTapDown);
+  PushGesture(GESTURE_TAP_DOWN);
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapDown),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP_DOWN),
                             GetAndResetSentGestures()));
 
   // If the subsequent touch is consumed, the tap should be cancelled.
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   MoveTouchPoint(0, 2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapCancel),
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP_CANCEL),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest,
        TapNotCancelledIfTapEndingEventReceived) {
-  PushGesture(WebInputEvent::GestureTapDown);
+  PushGesture(GESTURE_TAP_DOWN);
   PressTouchPoint(1, 1);
   PressTouchPoint(2, 2);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapDown),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP_DOWN),
                             GetAndResetSentGestures()));
 
-  PushGesture(WebInputEvent::GestureTap);
-  ReleaseTouchPoint(1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTap),
+  PushGesture(GESTURE_TAP);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP),
                             GetAndResetSentGestures()));
 
-  // The tap should not be cancelled as it was terminated by a |GestureTap|.
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  // The tap should not be cancelled as it was terminated by a |GESTURE_TAP|.
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
@@ -646,70 +668,70 @@ TEST_F(TouchDispositionGestureFilterTest, TimeoutGestures) {
   // If the sequence is allowed, and there are no preceding gestures, the
   // timeout gestures should be forwarded immediately.
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  SendTimeoutGesture(WebInputEvent::GestureShowPress);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureShowPress),
+  SendTimeoutGesture(GESTURE_SHOW_PRESS);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SHOW_PRESS),
                             GetAndResetSentGestures()));
 
-  SendTimeoutGesture(WebInputEvent::GestureLongPress);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureLongPress),
+  SendTimeoutGesture(GESTURE_LONG_PRESS);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_LONG_PRESS),
                             GetAndResetSentGestures()));
 
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
 
   // If the sequence is disallowed, and there are no preceding gestures, the
   // timeout gestures should be dropped immediately.
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  SendTimeoutGesture(WebInputEvent::GestureShowPress);
+  SendTimeoutGesture(GESTURE_SHOW_PRESS);
   EXPECT_FALSE(GesturesSent());
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
 
   // If the sequence has a pending ack, the timeout gestures should
   // remain queued until the ack is received.
   PressTouchPoint(1, 1);
   EXPECT_FALSE(GesturesSent());
 
-  SendTimeoutGesture(WebInputEvent::GestureLongPress);
+  SendTimeoutGesture(GESTURE_LONG_PRESS);
   EXPECT_FALSE(GesturesSent());
 
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureLongPress),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_LONG_PRESS),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, SpuriousAcksIgnored) {
   // Acks received when the queue is empty will be safely ignored.
   ASSERT_TRUE(IsEmpty());
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 
-  PushGesture(WebInputEvent::GestureScrollBegin);
+  PushGesture(GESTURE_SCROLL_BEGIN);
   PressTouchPoint(1, 1);
-  PushGesture(WebInputEvent::GestureScrollUpdate);
+  PushGesture(GESTURE_SCROLL_UPDATE);
   MoveTouchPoint(0, 3,3);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureScrollBegin,
-                                     WebInputEvent::GestureScrollUpdate),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_SCROLL_BEGIN,
+                                     GESTURE_SCROLL_UPDATE),
                             GetAndResetSentGestures()));
 
   // Even if all packets have been dispatched, the filter may not be empty as
   // there could be follow-up timeout events.  Spurious acks in such cases
   // should also be safely ignored.
   ASSERT_FALSE(IsEmpty());
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
   EXPECT_FALSE(GesturesSent());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, PacketWithInvalidTypeIgnored) {
-  GestureEventPacket packet;
+  GestureEventDataPacket packet;
   EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_TYPE,
             SendGesturePacket(packet));
   EXPECT_TRUE(IsEmpty());
@@ -717,49 +739,42 @@ TEST_F(TouchDispositionGestureFilterTest, PacketWithInvalidTypeIgnored) {
 
 TEST_F(TouchDispositionGestureFilterTest, PacketsWithInvalidOrderIgnored) {
   EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_ORDER,
-            SendTimeoutGesture(WebInputEvent::GestureShowPress));
-  EXPECT_TRUE(IsEmpty());
-
-  WebTouchEvent touch;
-  touch.type = WebInputEvent::TouchCancel;
-  EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_TYPE,
-            SendTouchGestures(WebInputEvent::GestureShowPress,
-                              GestureEventPacket()));
+            SendTimeoutGesture(GESTURE_SHOW_PRESS));
   EXPECT_TRUE(IsEmpty());
 }
 
 TEST_F(TouchDispositionGestureFilterTest, ConsumedTouchCancel) {
   // An unconsumed touch's gesture should be sent.
-  PushGesture(WebInputEvent::GestureTapDown);
+  PushGesture(GESTURE_TAP_DOWN);
   PressTouchPoint(1, 1);
   EXPECT_FALSE(GesturesSent());
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapDown),
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP_DOWN),
                             GetAndResetSentGestures()));
 
-  PushGesture(WebInputEvent::GestureTapCancel);
-  PushGesture(WebInputEvent::GestureScrollEnd);
-  CancelTouchPoint(0);
+  PushGesture(GESTURE_TAP_CANCEL);
+  PushGesture(GESTURE_SCROLL_END);
+  CancelTouchPoint();
   EXPECT_FALSE(GesturesSent());
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapCancel,
-                                     WebInputEvent::GestureScrollEnd),
+  SendTouchEventACK(TouchDispositionGestureFilter::CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP_CANCEL,
+                                     GESTURE_SCROLL_END),
                             GetAndResetSentGestures()));
 }
 
 TEST_F(TouchDispositionGestureFilterTest, TimeoutEventAfterRelease) {
   PressTouchPoint(1, 1);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
   EXPECT_FALSE(GesturesSent());
-  PushGesture(WebInputEvent::GestureTapUnconfirmed);
-  ReleaseTouchPoint(0);
-  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTapUnconfirmed),
+  PushGesture(GESTURE_TAP_UNCONFIRMED);
+  ReleaseTouchPoint();
+  SendTouchEventACK(TouchDispositionGestureFilter::NOT_CONSUMED);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP_UNCONFIRMED),
                             GetAndResetSentGestures()));
 
-  SendTimeoutGesture(WebInputEvent::GestureTap);
-  EXPECT_TRUE(GesturesMatch(Gestures(WebInputEvent::GestureTap),
+  SendTimeoutGesture(GESTURE_TAP);
+  EXPECT_TRUE(GesturesMatch(Gestures(GESTURE_TAP),
                             GetAndResetSentGestures()));
 }
 
-}  // namespace content
+}  // namespace ui