Modified state flow for touch explore released in touch_exploration_controller.

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"
@@ skipping 758 matching lines @@
   // This should result in a single touch press at the location of the tap,
   // not at the location of the double-tap.
   gfx::Point first_tap_location(13, 14);
   generator_->set_current_location(first_tap_location);
   generator_->PressTouchId(1);
   generator_->ReleaseTouchId(1);
   gfx::Point second_tap_location(15, 16);
   generator_->set_current_location(second_tap_location);
   generator_->PressTouchId(1);
   // Advance to the finger passing through.
-  AdvanceSimulatedTimePastTapDelay();
+  AdvanceSimulatedTimePastPassthroughDelay();
 
   gfx::Vector2d passthrough_offset = second_tap_location - tap_location;
 
   std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(1U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
   EXPECT_EQ(second_tap_location - passthrough_offset,
             captured_events[0]->location());
 
   ClearCapturedEvents();
@@ skipping 67 matching lines @@
   // 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();
   // Advance to the finger passing through, and then to the longpress timeout.
-  AdvanceSimulatedTimePastTapDelay();
+  AdvanceSimulatedTimePastPassthroughDelay();
   simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
   generator_->ReleaseTouch();
 
   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());
@@ skipping 31 matching lines @@
   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());
 }
 
+// Single-tapping and holding should send a touch press and release through to
+// the location of the last successful touch exploration. There should be a
+// delay between the touch and release events (right click). The user should
+// not enter passthrough mode - touch moves should be discarded.
+TEST_F(TouchExplorationTest, SingleTapLongPress) {
+  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();
+
+  std::vector<ui::LocatedEvent*> 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());
+  ClearCapturedEvents();
+
+  // Tap again for a long press single tap.
+  gfx::Point final_location(33, 34);
+  generator_->set_current_location(final_location);
+  generator_->PressTouch();
+  simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
+
+  captured_events = GetCapturedLocatedEvents();
+  ASSERT_EQ(1U, 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();
+  ClearCapturedEvents();
+
+  // Touch moves should not send any events through, since the user should be
+  // in a wait for release state.
+  gfx::Point move_location(44, 45);
+  generator_->MoveTouch(move_location);
+  captured_events = GetCapturedLocatedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  generator_->ReleaseTouch();
+  captured_events = GetCapturedLocatedEvents();
+  ASSERT_EQ(1U, captured_events.size());
+  EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[0]->type());
+  EXPECT_EQ(tap_location, captured_events[0]->location());
+  base::TimeDelta released_time = captured_events[0]->time_stamp();
+  EXPECT_EQ(gesture_detector_config_.longpress_timeout,
+            released_time - pressed_time);
+}
+
 // 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);
@@ skipping 1015 matching lines @@
     generator_->PressTouch();
     generator_->MoveTouch(initial_press);
     generator_->MoveTouch(*point);
     generator_->ReleaseTouch();
     ASSERT_EQ(1U, delegate_.NumExitScreenSounds());
     delegate_.ResetCountersToZero();
   }
 }
 
 }  // namespace ui