Ignore TouchCancel ack dispositions

content/browser/renderer_host/input/input_router_unittest.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/input_router_unittest.h"
 
 #include "content/browser/renderer_host/input/input_router.h"
 #include "content/common/input_messages.h"
 
 using blink::WebGestureEvent;
@@ skipping 56 matching lines @@
                                 ui::LatencyInfo()));
 }
 
 void InputRouterTest::SimulateWheelEventWithPhase(
     WebMouseWheelEvent::Phase phase) {
   input_router_->SendWheelEvent(
       MouseWheelEventWithLatencyInfo(
           SyntheticWebMouseWheelEventBuilder::Build(phase), ui::LatencyInfo()));
 }
 
-// Inject provided synthetic WebGestureEvent instance.
 void InputRouterTest::SimulateGestureEvent(
     const WebGestureEvent& gesture) {
   GestureEventWithLatencyInfo gesture_with_latency(gesture, ui::LatencyInfo());
   input_router_->SendGestureEvent(gesture_with_latency);
 }
 
-// Inject simple synthetic WebGestureEvent instances.
 void InputRouterTest::SimulateGestureEvent(
     WebInputEvent::Type type,
     WebGestureEvent::SourceDevice sourceDevice) {
   SimulateGestureEvent(
       SyntheticWebGestureEventBuilder::Build(type, sourceDevice));
 }
 
 void InputRouterTest::SimulateGestureScrollUpdateEvent(float dX,
                                                        float dY,
                                                        int modifiers) {
   SimulateGestureEvent(
       SyntheticWebGestureEventBuilder::BuildScrollUpdate(dX, dY, modifiers));
 }
 
 void InputRouterTest::SimulateGesturePinchUpdateEvent(float scale,
                                                       float anchorX,
                                                       float anchorY,
                                                       int modifiers) {
   SimulateGestureEvent(
       SyntheticWebGestureEventBuilder::BuildPinchUpdate(scale,
                                                         anchorX,
                                                         anchorY,
                                                         modifiers));
 }
 
-// Inject synthetic GestureFlingStart events.
 void InputRouterTest::SimulateGestureFlingStartEvent(
     float velocityX,
     float velocityY,
     WebGestureEvent::SourceDevice sourceDevice) {
   SimulateGestureEvent(
       SyntheticWebGestureEventBuilder::BuildFling(velocityX,
                                                   velocityY,
                                                   sourceDevice));
 }
 
-void InputRouterTest::SimulateTouchEvent(int x, int y) {
-  PressTouchPoint(x, y);
+void InputRouterTest::SimulateTouchEvent(WebInputEvent::Type type) {
+  touch_event_.ResetPoints();
+  int index = PressTouchPoint(0, 0);
+  switch (type) {
+    case WebInputEvent::TouchStart:
+      // Already handled by |PressTouchPoint()|.
+      break;
+    case WebInputEvent::TouchMove:
+      MoveTouchPoint(index, 5, 5);
+      break;
+    case WebInputEvent::TouchEnd:
+      ReleaseTouchPoint(index);
+      break;
+    case WebInputEvent::TouchCancel:
+      CancelTouchPoint(index);
+      break;
+    default:
+      FAIL() << "Invalid touch event type.";
+      break;
+  }
   SendTouchEvent();
 }
 
-// Set the timestamp for the touch-event.
 void InputRouterTest::SetTouchTimestamp(base::TimeDelta timestamp) {
   touch_event_.SetTimestamp(timestamp);
 }
 
-// Sends a touch event (irrespective of whether the page has a touch-event
-// handler or not).
 void InputRouterTest::SendTouchEvent() {
   input_router_->SendTouchEvent(
       TouchEventWithLatencyInfo(touch_event_, ui::LatencyInfo()));
   touch_event_.ResetPoints();
 }
 
 int InputRouterTest::PressTouchPoint(int x, int y) {
   return touch_event_.PressPoint(x, y);
 }
 
 void InputRouterTest::MoveTouchPoint(int index, int x, int y) {
   touch_event_.MovePoint(index, x, y);
 }
 
 void InputRouterTest::ReleaseTouchPoint(int index) {
   touch_event_.ReleasePoint(index);
 }
 
+void InputRouterTest::CancelTouchPoint(int index) {
+  touch_event_.CancelPoint(index);
+}
+
 }  // namespace content