Swipe Gestures for Accessibility

ui/chromeos/touch_exploration_controller_unittest.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 "ui/chromeos/touch_exploration_controller.h"
 
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
+#include "ui/events/gestures/gesture_provider_aura.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 namespace ui {
 
 namespace {
-// Records all mouse and touch events.
+// Records all mouse, touch, gesture, and key events.
 class EventCapturer : public ui::EventHandler {
  public:
   EventCapturer() {}
   virtual ~EventCapturer() {}
 
   void Reset() {
     events_.clear();
   }
 
   virtual void OnEvent(ui::Event* event) OVERRIDE {
     if (event->IsMouseEvent()) {
       events_.push_back(
           new ui::MouseEvent(static_cast<ui::MouseEvent&>(*event)));
     } else if (event->IsTouchEvent()) {
       events_.push_back(
           new ui::TouchEvent(static_cast<ui::TouchEvent&>(*event)));
+    } else if (event->IsGestureEvent()) {
+      events_.push_back(
+          new ui::GestureEvent(static_cast<ui::GestureEvent&>(*event)));
+    } else if (event->IsKeyEvent()) {
+      events_.push_back(new ui::KeyEvent(static_cast<ui::KeyEvent&>(*event)));
     } else {
       return;
     }
     // Stop event propagation so we don't click on random stuff that
     // might break test assumptions.
     event->StopPropagation();
     // If there is a possibility that we're in an infinite loop, we should
     // exit early with a sensible error rather than letting the test time out.
     ASSERT_LT(events_.size(), 100u);
   }
-  const ScopedVector<ui::LocatedEvent>& captured_events() const {
-    return events_;
-  }
+
+  const ScopedVector<ui::Event>& captured_events() const { return events_; }
 
  private:
-  ScopedVector<ui::LocatedEvent> events_;
+  ScopedVector<ui::Event> events_;
 
   DISALLOW_COPY_AND_ASSIGN(EventCapturer);
 };
 
 }  // namespace
 
 class TouchExplorationTest : public aura::test::AuraTestBase {
  public:
   TouchExplorationTest()
       : simulated_clock_(new base::SimpleTestTickClock()) {}
@@ skipping 15 matching lines @@
   virtual void TearDown() OVERRIDE {
     root_window()->RemovePreTargetHandler(&event_capturer_);
     SwitchTouchExplorationMode(false);
     cursor_client_.reset();
     aura::test::AuraTestBase::TearDown();
   }
 
  protected:
   aura::client::CursorClient* cursor_client() { return cursor_client_.get(); }
 
-  const ScopedVector<ui::LocatedEvent>& GetCapturedEvents() {
+  const ScopedVector<ui::Event>& GetCapturedEvents() {
     return event_capturer_.captured_events();
   }
 
-  std::vector<ui::LocatedEvent*> GetCapturedEventsOfType(int type) {
-    const ScopedVector<ui::LocatedEvent>& all_events = GetCapturedEvents();
-    std::vector<ui::LocatedEvent*> events;
+  std::vector<ui::LocatedEvent*> GetCapturedLocatedEvents() {
+    const ScopedVector<ui::Event>& all_events = GetCapturedEvents();
+    std::vector<ui::LocatedEvent*> located_events;
+    for (size_t i = 0; i < all_events.size(); ++i) {
+      if (all_events[i]->IsMouseEvent() || all_events[i]->IsTouchEvent() ||

[evy, 2014/06/26 00:02:36]

A previous comment from Dominic:

When there are multiple conditions separated by && and ||, prefer one per line. 

So, more like this: 

if (foo == 1 && 
    bar == 2 && 
    baz == 3) { 
  DoSomething(); 
}

+          all_events[i]->IsGestureEvent()) {
+        located_events.push_back(static_cast<ui::LocatedEvent*>(all_events[i]));
+      }
+    }
+    return located_events;
+  }
+
+  std::vector<ui::Event*> GetCapturedEventsOfType(int type) {
+    const ScopedVector<ui::Event>& all_events = GetCapturedEvents();
+    std::vector<ui::Event*> events;
     for (size_t i = 0; i < all_events.size(); ++i) {
       if (type == all_events[i]->type())
         events.push_back(all_events[i]);
     }
     return events;
   }
 
+  std::vector<ui::LocatedEvent*> GetCapturedLocatedEventsOfType(int type) {
+    std::vector<ui::LocatedEvent*> located_events = GetCapturedLocatedEvents();
+    std::vector<ui::LocatedEvent*> events;
+    for (size_t i = 0; i < located_events.size(); ++i) {
+      if (type == located_events[i]->type())
+        events.push_back(located_events[i]);
+    }
+    return events;
+  }
+
   void ClearCapturedEvents() {
     event_capturer_.Reset();
   }
 
   void AdvanceSimulatedTimePastTapDelay() {
     simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
     touch_exploration_controller_->CallTapTimerNowForTesting();
   }
 
   void SwitchTouchExplorationMode(bool on) {
@@ skipping 21 matching lines @@
         aura::client::GetCursorClient(root_window());
     return cursor_client &&
            cursor_client->IsMouseEventsEnabled() &&
            !cursor_client->IsCursorVisible();
   }
 
   bool IsInNoFingersDownState() {
     return touch_exploration_controller_->IsInNoFingersDownStateForTesting();
   }
 
+  bool IsInGestureInProgressState() {
+    return touch_exploration_controller_
+        ->IsInGestureInProgressStateForTesting();
+  }
+
   base::TimeDelta Now() {
     // This is the same as what EventTimeForNow() does, but here we do it
     // with our simulated clock.
     return base::TimeDelta::FromInternalValue(
         simulated_clock_->NowTicks().ToInternalValue());
   }
 
   scoped_ptr<aura::test::EventGenerator> generator_;
   ui::GestureDetector::Config gesture_detector_config_;
   // Owned by |generator_|.
@@ skipping 27 matching lines @@
   ASSERT_TRUE(e1->IsMouseEvent());
   ASSERT_TRUE(e2->IsMouseEvent());
   ui::MouseEvent* mouse_event1 = static_cast<ui::MouseEvent*>(e1);
   ui::MouseEvent* mouse_event2 = static_cast<ui::MouseEvent*>(e2);
   EXPECT_EQ(mouse_event1->type(), mouse_event2->type());
   EXPECT_EQ(mouse_event1->location(), mouse_event2->location());
   EXPECT_EQ(mouse_event1->root_location(), mouse_event2->root_location());
   EXPECT_EQ(mouse_event1->flags(), mouse_event2->flags());
 }
 
+// Executes a number of assertions to confirm that |e1| and |e2| are key events
+// and are equal to each other.
+void ConfirmEventsAreKeyAndEqual(ui::Event* e1, ui::Event* e2) {
+  ASSERT_TRUE(e1->IsKeyEvent());
+  ASSERT_TRUE(e2->IsKeyEvent());
+  ui::KeyEvent* key_event1 = static_cast<ui::KeyEvent*>(e1);
+  ui::KeyEvent* key_event2 = static_cast<ui::KeyEvent*>(e2);
+  EXPECT_EQ(key_event1->type(), key_event2->type());
+  EXPECT_EQ(key_event1->key_code(), key_event2->key_code());
+  EXPECT_EQ(key_event1->code(), key_event2->code());
+  EXPECT_EQ(key_event1->flags(), key_event2->flags());
+}
+
 #define CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(e1, e2) \
   ASSERT_NO_FATAL_FAILURE(ConfirmEventsAreTouchAndEqual(e1, e2))
 
 #define CONFIRM_EVENTS_ARE_MOUSE_AND_EQUAL(e1, e2) \
   ASSERT_NO_FATAL_FAILURE(ConfirmEventsAreMouseAndEqual(e1, e2))
 
+#define CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(e1, e2) \
+  ASSERT_NO_FATAL_FAILURE(ConfirmEventsAreKeyAndEqual(e1, e2))
+
 // TODO(mfomitchev): Need to investigate why we don't get mouse enter/exit
 // events when running these tests as part of ui_unittests. We do get them when
 // the tests are run as part of ash unit tests.
 
+// If a swipe has been successfully completed, then six key events will be
+// dispatched that correspond to shift+search+direction
+void AssertDirectionalNavigationEvents(const ScopedVector<ui::Event>& events,
+                                       ui::KeyboardCode direction) {
+  ASSERT_EQ(6U, events.size());
+  std::vector<ui::KeyEvent> key_sequence;
+  ui::KeyEvent shift_pressed(
+      ui::ET_KEY_PRESSED, ui::VKEY_SHIFT, ui::EF_SHIFT_DOWN, false);
+  ui::KeyEvent search_pressed(
+      ui::ET_KEY_PRESSED, ui::VKEY_LWIN, ui::EF_SHIFT_DOWN, false);
+  ui::KeyEvent direction_pressed(
+      ui::ET_KEY_PRESSED, direction, ui::EF_SHIFT_DOWN, false);
+  ui::KeyEvent direction_released(
+      ui::ET_KEY_RELEASED, direction, ui::EF_SHIFT_DOWN, false);
+  ui::KeyEvent search_released(
+      ui::ET_KEY_RELEASED, VKEY_LWIN, ui::EF_SHIFT_DOWN, false);
+  ui::KeyEvent shift_released(
+      ui::ET_KEY_RELEASED, ui::VKEY_SHIFT, ui::EF_NONE, false);
+  CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&shift_pressed,
+                                   static_cast<ui::KeyEvent*>(events[0]));
+  CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&search_pressed,
+                                   static_cast<ui::KeyEvent*>(events[1]));
+  CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&direction_pressed,
+                                   static_cast<ui::KeyEvent*>(events[2]));
+  CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&direction_released,
+                                   static_cast<ui::KeyEvent*>(events[3]));
+  CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&search_released,
+                                   static_cast<ui::KeyEvent*>(events[4]));
+  CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&shift_released,
+                                   static_cast<ui::KeyEvent*>(events[5]));
+}
+
 TEST_F(TouchExplorationTest, EntersTouchToMouseModeAfterPressAndDelay) {
   SwitchTouchExplorationMode(true);
   EXPECT_FALSE(IsInTouchToMouseMode());
   generator_->PressTouch();
   AdvanceSimulatedTimePastTapDelay();
   EXPECT_TRUE(IsInTouchToMouseMode());
 }
 
 TEST_F(TouchExplorationTest, EntersTouchToMouseModeAfterMoveOutsideSlop) {
   int slop = gesture_detector_config_.touch_slop;
   int half_slop = slop / 2;
 
   SwitchTouchExplorationMode(true);
   EXPECT_FALSE(IsInTouchToMouseMode());
   generator_->set_current_location(gfx::Point(11, 12));
   generator_->PressTouch();
   generator_->MoveTouch(gfx::Point(11 + half_slop, 12));
   EXPECT_FALSE(IsInTouchToMouseMode());
   generator_->MoveTouch(gfx::Point(11, 12 + half_slop));
   EXPECT_FALSE(IsInTouchToMouseMode());
+  AdvanceSimulatedTimePastTapDelay();
   generator_->MoveTouch(gfx::Point(11 + slop + 1, 12));
   EXPECT_TRUE(IsInTouchToMouseMode());
 }
 
 TEST_F(TouchExplorationTest, OneFingerTap) {
   SwitchTouchExplorationMode(true);
   gfx::Point location(11, 12);
   generator_->set_current_location(location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   AdvanceSimulatedTimePastTapDelay();
 
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
 
   EXPECT_EQ(location, events[0]->location());
   EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
 TEST_F(TouchExplorationTest, ActualMouseMovesUnaffected) {
   SwitchTouchExplorationMode(true);
 
   gfx::Point location_start(11, 12);
   gfx::Point location_end(13, 14);
   generator_->set_current_location(location_start);
   generator_->PressTouch();
   AdvanceSimulatedTimePastTapDelay();
   generator_->MoveTouch(location_end);
 
   gfx::Point location_real_mouse_move(15, 16);
   ui::MouseEvent mouse_move(ui::ET_MOUSE_MOVED,
                             location_real_mouse_move,
                             location_real_mouse_move,
                             0,
                             0);
   generator_->Dispatch(&mouse_move);
   generator_->ReleaseTouch();
   AdvanceSimulatedTimePastTapDelay();
 
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(4U, events.size());
 
   EXPECT_EQ(location_start, events[0]->location());
   EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
 
   EXPECT_EQ(location_end, events[1]->location());
   EXPECT_TRUE(events[1]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[1]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
 
@@ skipping 24 matching lines @@
   // affected by the touch exploration mode, while the touch events from another
   // finger get rewritten.
   SwitchTouchExplorationMode(true);
   ui::TouchEvent touch_move(ui::ET_TOUCH_MOVED,
                             gfx::Point(11, 12),
                             1,
                             Now());
   generator_->Dispatch(&touch_move);
   EXPECT_TRUE(cursor_client()->IsCursorVisible());
   EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(1u, captured_events.size());
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_move);
   ClearCapturedEvents();
 
   // The press from the second finger should get rewritten.
   generator_->PressTouchId(2);
   AdvanceSimulatedTimePastTapDelay();
   EXPECT_TRUE(IsInTouchToMouseMode());
-  ScopedVector<ui::LocatedEvent>::const_iterator it;
+  captured_events = GetCapturedLocatedEvents();
+  std::vector<ui::LocatedEvent*>::const_iterator it;
   for (it = captured_events.begin(); it != captured_events.end(); ++it) {
     if ((*it)->type() == ui::ET_MOUSE_MOVED)
       break;
   }
   EXPECT_NE(captured_events.end(), it);
   ClearCapturedEvents();
 
   // The release of the first finger shouldn't be affected.
   ui::TouchEvent touch_release(ui::ET_TOUCH_RELEASED,
                                gfx::Point(11, 12),
                                1,
                                Now());
   generator_->Dispatch(&touch_release);
+  captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(1u, captured_events.size());
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_release);
   ClearCapturedEvents();
 
   // The move and release from the second finger should get rewritten.
   generator_->MoveTouchId(gfx::Point(13, 14), 2);
   generator_->ReleaseTouchId(2);
   AdvanceSimulatedTimePastTapDelay();
-
+  captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(2u, captured_events.size());
   EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());
   EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[1]->type());
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
 TEST_F(TouchExplorationTest, TwoFingerTouch) {
   SwitchTouchExplorationMode(true);
   generator_->PressTouchId(1);
   ClearCapturedEvents();
 
   // Confirm events from the second finger go through as is.
   ui::TouchEvent touch_press(
       ui::ET_TOUCH_PRESSED,
       gfx::Point(10, 11),
       2,
       Now());
   generator_->Dispatch(&touch_press);
   EXPECT_TRUE(cursor_client()->IsCursorVisible());
   EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   // TODO(mfomitchev): mouse enter/exit events
   // There will be a ET_MOUSE_EXITED event synthesized when the mouse cursor is
   // hidden - ignore it.
-  ScopedVector<ui::LocatedEvent>::const_iterator it;
+  std::vector<ui::LocatedEvent*>::const_iterator it;
   for (it = captured_events.begin(); it != captured_events.end(); ++it) {
     if ((*it)->type() == ui::ET_TOUCH_PRESSED) {
       CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(*it, &touch_press);
       break;
     }
   }
   EXPECT_NE(captured_events.end(), it);
   ClearCapturedEvents();
   ui::TouchEvent touch_move(
       ui::ET_TOUCH_MOVED,
       gfx::Point(20, 21),
       2,
       Now());
   generator_->Dispatch(&touch_move);
+  captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(1u, captured_events.size());
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_move);
   ClearCapturedEvents();
 
   // Confirm mouse moves go through unaffected.
   ui::MouseEvent mouse_move(ui::ET_MOUSE_MOVED,
                             gfx::Point(13, 14),
                             gfx::Point(13, 14),
                             0,
                             0);
   generator_->Dispatch(&mouse_move);
   // TODO(mfomitchev): mouse enter/exit events
   // Ignore synthesized ET_MOUSE_ENTERED/ET_MOUSE_EXITED
+  captured_events = GetCapturedLocatedEvents();
   for (it = captured_events.begin(); it != captured_events.end(); ++it) {
     if ((*it)->type() == ui::ET_MOUSE_MOVED) {
       CONFIRM_EVENTS_ARE_MOUSE_AND_EQUAL(*it, &mouse_move);
       break;
     }
   }
   EXPECT_NE(captured_events.end(), it);
   ClearCapturedEvents();
 
   // Events from the first finger should not go through while the second finger
   // is touching.
   gfx::Point touch1_location = gfx::Point(15, 16);
   generator_->MoveTouchId(touch1_location, 1);
-  EXPECT_EQ(0u, GetCapturedEvents().size());
+  captured_events = GetCapturedLocatedEvents();
+  EXPECT_EQ(0u, GetCapturedLocatedEvents().size());

[tdresser, 2014/06/26 13:31:49]

It looks like you're caching |GetCapturedLocatedEvents()|, and then not using
the cached value.

 
   EXPECT_TRUE(cursor_client()->IsCursorVisible());
   EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
 
   // A release of the second finger should be rewritten as a mouse move
   // of that finger to the |touch1_location| and we stay in passthrough
   // mode.
   ui::TouchEvent touch_release(
       ui::ET_TOUCH_RELEASED,
       gfx::Point(25, 26),
       2,
       Now());
   generator_->Dispatch(&touch_release);
+  captured_events = GetCapturedLocatedEvents();
   EXPECT_FALSE(IsInTouchToMouseMode());
   ASSERT_EQ(captured_events.size(), 1u);
   EXPECT_EQ(touch1_location, captured_events[0]->location());
 }
 
 TEST_F(TouchExplorationTest, MultiFingerTouch) {
   SwitchTouchExplorationMode(true);
   generator_->PressTouchId(1);
   generator_->PressTouchId(2);
   ClearCapturedEvents();
@@ skipping 28 matching lines @@
                                 4,
                                 Now());
   generator_->Dispatch(&touch3_press);
   generator_->Dispatch(&touch3_move1);
   generator_->Dispatch(&touch4_press);
   generator_->Dispatch(&touch3_move2);
   generator_->Dispatch(&touch4_move);
   generator_->Dispatch(&touch3_release);
   generator_->Dispatch(&touch4_release);
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(7u, captured_events.size());
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch3_press);
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[1], &touch3_move1);
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[2], &touch4_press);
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[3], &touch3_move2);
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[4], &touch4_move);
 
   // The release of finger 3 is rewritten as a move to the former location
   // of finger 1.
   EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[5]->type());
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[6], &touch4_release);
 }
 
 // Test the case when there are multiple fingers on the screen and the first
 // finger is released. This should be ignored, but then the second finger
 // release should be passed through.
 TEST_F(TouchExplorationTest, FirstFingerLifted) {
   SwitchTouchExplorationMode(true);
   generator_->PressTouchId(1);
   generator_->PressTouchId(2);
   gfx::Point touch2_location(10, 11);
   generator_->MoveTouchId(touch2_location, 2);
   generator_->PressTouchId(3);
   gfx::Point touch3_location(20, 21);
   generator_->MoveTouchId(touch3_location, 3);
   ClearCapturedEvents();
 
   // Release of finger 1 should be ignored.
   generator_->ReleaseTouchId(1);
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(0u, captured_events.size());
 
   // Move of finger 2 should be passed through.
   gfx::Point touch2_new_location(20, 11);
   generator_->MoveTouchId(touch2_new_location, 2);
+  captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(1u, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[0]->type());
   EXPECT_EQ(touch2_new_location, captured_events[0]->location());
   ClearCapturedEvents();
 
   // Release of finger 2 should be passed through.
   ui::TouchEvent touch2_release(
       ui::ET_TOUCH_RELEASED,
       gfx::Point(14, 15),
       2,
       Now());
   generator_->Dispatch(&touch2_release);
+  captured_events = GetCapturedLocatedEvents();
+
   ASSERT_EQ(1u, captured_events.size());
+  EXPECT_EQ(touch2_release.type(), captured_events[0]->type());
+  EXPECT_EQ(touch2_release.touch_id(),
+            (static_cast<ui::TouchEvent*>(captured_events[0]))->touch_id());
   CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch2_release);
 }
 
 // Test the case when there are multiple fingers on the screen and the
 // second finger is released. This should be rewritten as a move to the
 // location of the first finger.
 TEST_F(TouchExplorationTest, SecondFingerLifted) {
   SwitchTouchExplorationMode(true);
   gfx::Point touch1_location(0, 11);
   generator_->set_current_location(touch1_location);
   generator_->PressTouchId(1);
   generator_->PressTouchId(2);
   gfx::Point touch2_location(10, 11);
   generator_->MoveTouchId(touch2_location, 2);
   generator_->PressTouchId(3);
   gfx::Point touch3_location(20, 21);
   generator_->MoveTouchId(touch3_location, 3);
   ClearCapturedEvents();
 
   // Release of finger 2 should be rewritten as a move to the location
   // of the first finger.
   generator_->ReleaseTouchId(2);
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(1u, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[0]->type());
   EXPECT_EQ(2, static_cast<ui::TouchEvent*>(captured_events[0])->touch_id());
   EXPECT_EQ(touch1_location, captured_events[0]->location());
   ClearCapturedEvents();
 
   // Move of finger 1 should be rewritten as a move of finger 2.
   gfx::Point touch1_new_location(0, 41);
   generator_->MoveTouchId(touch1_new_location, 1);
+  captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(1u, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[0]->type());
   EXPECT_EQ(2, static_cast<ui::TouchEvent*>(captured_events[0])->touch_id());
   EXPECT_EQ(touch1_new_location, captured_events[0]->location());
   ClearCapturedEvents();
 
   // Release of finger 1 should be rewritten as release of finger 2.
   gfx::Point touch1_final_location(0, 41);
   ui::TouchEvent touch1_release(
       ui::ET_TOUCH_RELEASED,
       touch1_final_location,
       1,
       Now());
   generator_->Dispatch(&touch1_release);
+  captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(1u, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[0]->type());
   EXPECT_EQ(2, static_cast<ui::TouchEvent*>(captured_events[0])->touch_id());
   EXPECT_EQ(touch1_final_location, captured_events[0]->location());
 }
 
 // If an event is received after the double-tap timeout has elapsed, but
 // before the timer has fired, a mouse move should still be generated.
 TEST_F(TouchExplorationTest, TimerFiresLateDuringTouchExploration) {
   SwitchTouchExplorationMode(true);
 
   // Send a press, then add another finger after the double-tap timeout.
   generator_->PressTouchId(1);
   simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
   generator_->PressTouchId(2);
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
   EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
 
   generator_->ReleaseTouchId(2);
   generator_->ReleaseTouchId(1);
   AdvanceSimulatedTimePastTapDelay();
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
@@ skipping 12 matching lines @@
   // Send a tap at location2, after the double-tap timeout, but before the
   // timer fires.
   gfx::Point location1(33, 34);
   generator_->set_current_location(location1);
   simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(301));
   generator_->PressTouch();
   generator_->ReleaseTouch();
   AdvanceSimulatedTimePastTapDelay();
 
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(2U, events.size());
   EXPECT_EQ(location0, events[0]->location());
   EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
   EXPECT_EQ(location1, events[1]->location());
   EXPECT_TRUE(events[1]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[1]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
 // Double-tapping should send a touch press and release through to the location
 // of the last successful touch exploration.
 TEST_F(TouchExplorationTest, DoubleTap) {
   SwitchTouchExplorationMode(true);
 
   // Tap at one location, and get a mouse move event.
   gfx::Point tap_location(11, 12);
   generator_->set_current_location(tap_location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   AdvanceSimulatedTimePastTapDelay();
 
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
 
   EXPECT_EQ(tap_location, events[0]->location());
   EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
   ClearCapturedEvents();
 
   // Now double-tap at a different location. This should result in
   // a single touch press and release at the location of the tap,
   // not at the location of the double-tap.
   gfx::Point double_tap_location(33, 34);
   generator_->set_current_location(double_tap_location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   generator_->PressTouch();
   generator_->ReleaseTouch();
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(2U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
   EXPECT_EQ(tap_location, captured_events[0]->location());
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
   EXPECT_EQ(tap_location, captured_events[1]->location());
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
 // Double-tapping where the user holds their finger down for the second time
 // for a longer press should send a touch press and released (right click)
 // to the location of the last successful touch exploration.
 TEST_F(TouchExplorationTest, DoubleTapLongPress) {
   SwitchTouchExplorationMode(true);
 
   // Tap at one location, and get a mouse move event.
   gfx::Point tap_location(11, 12);
   generator_->set_current_location(tap_location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   AdvanceSimulatedTimePastTapDelay();
 
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
 
   EXPECT_EQ(tap_location, events[0]->location());
   EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
   ClearCapturedEvents();
 
   // Now double-tap and hold at a different location.
   // This should result in a single touch long press and release
   // at the location of the tap, not at the location of the double-tap.
   // There should be a time delay between the touch press and release.
   gfx::Point first_tap_location(33, 34);
   generator_->set_current_location(first_tap_location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   gfx::Point second_tap_location(23, 24);
   generator_->set_current_location(second_tap_location);
   generator_->PressTouch();
   simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
   generator_->ReleaseTouch();
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(2U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
   EXPECT_EQ(tap_location, captured_events[0]->location());
   base::TimeDelta pressed_time = captured_events[0]->time_stamp();
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
   EXPECT_EQ(tap_location, captured_events[1]->location());
   base::TimeDelta released_time = captured_events[1]->time_stamp();
   EXPECT_EQ(gesture_detector_config_.longpress_timeout,
             released_time - pressed_time);
 }
 
 // Single-tapping should send a touch press and release through to the location
 // of the last successful touch exploration if the grace period has not
 // elapsed.
 TEST_F(TouchExplorationTest, SingleTap) {
   SwitchTouchExplorationMode(true);
 
   // Tap once to simulate a mouse moved event.
   gfx::Point initial_location(11, 12);
   generator_->set_current_location(initial_location);
   generator_->PressTouch();
+  AdvanceSimulatedTimePastTapDelay();
+  ClearCapturedEvents();
 
   // Move to another location for single tap
   gfx::Point tap_location(22, 23);
   generator_->MoveTouch(tap_location);
   generator_->ReleaseTouch();
 
   // Allow time to pass within the grace period of releasing before
   // tapping again.
   gfx::Point final_location(33, 34);
   generator_->set_current_location(final_location);
   simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(250));
   generator_->PressTouch();
   generator_->ReleaseTouch();
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(4U, captured_events.size());
   EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());
   EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[1]->type());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[2]->type());
   EXPECT_EQ(tap_location, captured_events[2]->location());
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[3]->type());
   EXPECT_EQ(tap_location, captured_events[3]->location());
 }
 
 // Double-tapping without coming from touch exploration (no previous touch
 // exploration event) should not generate any events.
 TEST_F(TouchExplorationTest, DoubleTapNoTouchExplore) {
   SwitchTouchExplorationMode(true);
 
   // Double-tap without any previous touch.
   // Touch exploration mode has not been entered, so there is no previous
   // touch exploration event. The double-tap should be discarded, and no events
   // should be generated at all.
   gfx::Point double_tap_location(33, 34);
   generator_->set_current_location(double_tap_location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   generator_->PressTouch();
   generator_->ReleaseTouch();
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(0U, captured_events.size());
 }
 
 // Tapping and releasing with a second finger when in touch exploration mode
 // should send a touch press and released to the location of the last
 // successful touch exploration and return to touch explore.
 TEST_F(TouchExplorationTest, SplitTap) {
   SwitchTouchExplorationMode(true);
   gfx::Point initial_touch_location(11, 12);
   gfx::Point second_touch_location(33, 34);
 
   // Tap and hold at one location, and get a mouse move event in touch explore.
   EnterTouchExplorationModeAtLocation(initial_touch_location);
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
 
   EXPECT_EQ(initial_touch_location, events[0]->location());
   EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
   ClearCapturedEvents();
 
   // Now tap and release at a different location. This should result in a
   // single touch and release at the location of the first (held) tap,
   // not at the location of the second tap and release.
   // After the release, there is still a finger in touch explore mode.
   ui::TouchEvent split_tap_press(
       ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
   generator_->Dispatch(&split_tap_press);
   ui::TouchEvent split_tap_release(
       ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());
   generator_->Dispatch(&split_tap_release);
   EXPECT_FALSE(IsInNoFingersDownState());
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(2U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
   EXPECT_EQ(initial_touch_location, captured_events[0]->location());
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
   EXPECT_EQ(initial_touch_location, captured_events[1]->location());
 }
 
 // If split tap is started but the touch explore finger is released first,
 // there should still be a touch press and release sent to the location of
 // the last successful touch exploration.
 // Both fingers should be released after the click goes through.
 TEST_F(TouchExplorationTest, SplitTapRelease) {
   SwitchTouchExplorationMode(true);
 
   gfx::Point initial_touch_location(11, 12);
   gfx::Point second_touch_location(33, 34);
 
   // Tap and hold at one location, and get a mouse move event in touch explore.
   EnterTouchExplorationModeAtLocation(initial_touch_location);
 
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
 
   ClearCapturedEvents();
 
   // Now tap at a different location. Release at the first location,
   // then release at the second. This should result in a
   // single touch and release at the location of the first (held) tap,
   // not at the location of the second tap and release.
   ui::TouchEvent split_tap_press(
       ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
   generator_->Dispatch(&split_tap_press);
   ui::TouchEvent touch_explore_release(
       ui::ET_TOUCH_RELEASED, initial_touch_location, 0, Now());
   generator_->Dispatch(&touch_explore_release);
   ui::TouchEvent split_tap_release(
       ui::ET_TOUCH_RELEASED, second_touch_location , 1, Now());
   generator_->Dispatch(&split_tap_release);
   EXPECT_TRUE(IsInNoFingersDownState());
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(2U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
   EXPECT_EQ(initial_touch_location, captured_events[0]->location());
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
   EXPECT_EQ(initial_touch_location, captured_events[1]->location());
 }
 
 // When in touch exploration mode, making a long press with a second finger
 // should send a touch press and released to the location of the last
 // successful touch exploration. There should be a delay between the
 // touch and release events (right click).
 TEST_F(TouchExplorationTest, SplitTapLongPress) {
   SwitchTouchExplorationMode(true);
   gfx::Point initial_touch_location(11, 12);
   gfx::Point second_touch_location(33, 34);
 
   // Tap and hold at one location, and get a mouse move event in touch explore.
   EnterTouchExplorationModeAtLocation(initial_touch_location);
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
 
   ClearCapturedEvents();
 
   // Now tap and release at a different location. This should result in a
   // single touch and release at the location of the first (held) tap,
   // not at the location of the second tap and release.
   // After the release, there is still a finger in touch explore mode.
   ui::TouchEvent split_tap_press(
       ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
   generator_->Dispatch(&split_tap_press);
   simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
   ui::TouchEvent split_tap_release(
       ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());
   generator_->Dispatch(&split_tap_release);
   EXPECT_FALSE(IsInNoFingersDownState());
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(2U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
   EXPECT_EQ(initial_touch_location, captured_events[0]->location());
   base::TimeDelta pressed_time = captured_events[0]->time_stamp();
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
   EXPECT_EQ(initial_touch_location, captured_events[1]->location());
   base::TimeDelta released_time = captured_events[1]->time_stamp();
   EXPECT_EQ(gesture_detector_config_.longpress_timeout,
             released_time - pressed_time);
 }
 
 // If split tap is started but the touch explore finger is released first,
 // there should still be a touch press and release sent to the location of
 // the last successful touch exploration. If the remaining finger is held
 // as a longpress, there should be a delay between the sent touch and release
 // events (right click).All fingers should be released after the click
 // goes through.
 TEST_F(TouchExplorationTest, SplitTapReleaseLongPress) {
   SwitchTouchExplorationMode(true);
   gfx::Point initial_touch_location(11, 12);
   gfx::Point second_touch_location(33, 34);
 
   // Tap and hold at one location, and get a mouse move event in touch explore.
   EnterTouchExplorationModeAtLocation(initial_touch_location);
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
   ClearCapturedEvents();
 
   // Now tap at a different location. Release at the first location,
   // then release at the second. This should result in a
   // single touch and release at the location of the first (held) tap,
   // not at the location of the second tap and release.
   // After the release, TouchToMouseMode should still be on.
   ui::TouchEvent split_tap_press(
       ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
   generator_->Dispatch(&split_tap_press);
   ui::TouchEvent touch_explore_release(
       ui::ET_TOUCH_RELEASED, initial_touch_location, 0, Now());
   generator_->Dispatch(&touch_explore_release);
   simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
   ui::TouchEvent split_tap_release(
       ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());
   generator_->Dispatch(&split_tap_release);
   EXPECT_TRUE(IsInTouchToMouseMode());
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(2U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
   EXPECT_EQ(initial_touch_location, captured_events[0]->location());
   base::TimeDelta pressed_time = captured_events[0]->time_stamp();
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
   EXPECT_EQ(initial_touch_location, captured_events[1]->location());
   base::TimeDelta released_time = captured_events[1]->time_stamp();
   EXPECT_EQ(gesture_detector_config_.longpress_timeout,
             released_time - pressed_time);
  }
 
 TEST_F(TouchExplorationTest, SplitTapLongPressMultiFinger) {
   SwitchTouchExplorationMode(true);
   gfx::Point initial_touch_location(11, 12);
   gfx::Point second_touch_location(33, 34);
   gfx::Point third_touch_location(16, 17);
 
   // Tap and hold at one location, and get a mouse move event in touch explore.
   EnterTouchExplorationModeAtLocation(initial_touch_location);
 
   std::vector<ui::LocatedEvent*> events =
-      GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);
+      GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
 
   EXPECT_EQ(initial_touch_location, events[0]->location());
   EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
   ClearCapturedEvents();
 
   // Now tap at a different location and hold for long press.
   ui::TouchEvent split_tap_press(
       ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
@@ skipping 11 matching lines @@
   ui::TouchEvent touch_explore_release(
       ui::ET_TOUCH_RELEASED, initial_touch_location, 0, Now());
   generator_->Dispatch(&touch_explore_release);
   ui::TouchEvent split_tap_release(
       ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());
   generator_->Dispatch(&split_tap_release);
   ui::TouchEvent third_tap_release(
       ui::ET_TOUCH_RELEASED, third_touch_location, 2, Now());
   generator_->Dispatch(&third_tap_release);
 
-  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(2U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
   EXPECT_EQ(initial_touch_location, captured_events[0]->location());
   base::TimeDelta pressed_time = captured_events[0]->time_stamp();
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
   EXPECT_EQ(initial_touch_location, captured_events[1]->location());
   base::TimeDelta released_time = captured_events[1]->time_stamp();
   EXPECT_EQ(gesture_detector_config_.longpress_timeout,
             released_time - pressed_time);
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
+// Finger must have moved more than slop, faster than the minimum swipe
+// velocity, and before the tap timer fires in order to enter
+// GestureInProgress state. Otherwise, if the tap timer fires before the a
+// gesture is completed, enter touch exploration.
+TEST_F(TouchExplorationTest, EnterGestureInProgressState) {
+  SwitchTouchExplorationMode(true);
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  EXPECT_FALSE(IsInGestureInProgressState());
+  float delta_distance = gesture_detector_config_.touch_slop + 1;
+  ui::TouchEvent first_press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 1), 0, Now());
+  generator_->Dispatch(&first_press);
+  gfx::Point second_location(delta_distance, 1);
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+  generator_->MoveTouch(second_location);
+  EXPECT_TRUE(IsInGestureInProgressState());
+  EXPECT_FALSE(IsInTouchToMouseMode());
+  const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  // Exit out of gesture mode once grace period is over and enter touch
+  // exploration.
+  AdvanceSimulatedTimePastTapDelay();
+  ASSERT_EQ(1U, captured_events.size());
+  EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());
+  EXPECT_TRUE(IsInTouchToMouseMode());
+  EXPECT_FALSE(IsInGestureInProgressState());
+}
+
+// A swipe+direction gesture should trigger a Shift+Search+Direction
+// keyboard event.
+TEST_F(TouchExplorationTest, GestureSwipe) {
+  SwitchTouchExplorationMode(true);
+  std::vector<ui::KeyboardCode> directions;
+  directions.push_back(ui::VKEY_RIGHT);
+  directions.push_back(ui::VKEY_LEFT);
+  directions.push_back(ui::VKEY_UP);
+  directions.push_back(ui::VKEY_DOWN);
+
+  for (std::vector<ui::KeyboardCode>::const_iterator it = directions.begin();
+       it != directions.end();
+       ++it) {
+    int x = 30;
+    int y = 31;
+    ui::TouchEvent origin(ui::ET_TOUCH_PRESSED, gfx::Point(x, y), 0, Now());
+    generator_->Dispatch(&origin);
+
+    ui::KeyboardCode direction = *it;
+    float delta_distance = gesture_detector_config_.touch_slop + 1;
+    scoped_ptr<gfx::Point> swipe;
+    switch (direction) {
+      case ui::VKEY_RIGHT:
+        swipe.reset(new gfx::Point(x + delta_distance, y));
+        break;
+      case ui::VKEY_LEFT:
+        swipe.reset(new gfx::Point(x - delta_distance, y));
+        break;
+      case ui::VKEY_UP:
+        swipe.reset(new gfx::Point(x, y - delta_distance));
+        break;
+      case ui::VKEY_DOWN:
+        swipe.reset(new gfx::Point(x, y + delta_distance));
+        break;
+      default:
+        return;
+    }
+
+    // A swipe is made when a fling starts
+    float delta_time =
+        delta_distance / gesture_detector_config_.maximum_fling_velocity;
+    simulated_clock_->Advance(base::TimeDelta::FromSecondsD(delta_time));
+    generator_->MoveTouch(*swipe);
+    EXPECT_TRUE(IsInGestureInProgressState());
+    EXPECT_FALSE(IsInTouchToMouseMode());
+    const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+    ASSERT_EQ(0U, captured_events.size());
+    generator_->ReleaseTouch();
+
+    // The swipe registered and sent the appropriate key events.
+    AssertDirectionalNavigationEvents(captured_events, direction);
+    EXPECT_TRUE(IsInNoFingersDownState());
+    EXPECT_FALSE(IsInTouchToMouseMode());
+    EXPECT_FALSE(IsInGestureInProgressState());
+    ClearCapturedEvents();
+  }
+}
+
 }  // namespace ui