Added split tap to TouchExplorationController

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 106 matching lines @@
     } else if (on && !touch_exploration_controller_.get()) {
       touch_exploration_controller_.reset(
           new ui::TouchExplorationController(root_window()));
       touch_exploration_controller_->SetEventHandlerForTesting(
           &event_capturer_);
       cursor_client()->ShowCursor();
       cursor_client()->DisableMouseEvents();
     }
   }
 
+  void TouchExplorationModeAtLocation(gfx::Point tap_location, int id){

[aboxhall, 2014/06/13 20:52:50]

Nit: space between ) and {

Also, this might be better named as a verb, e.g.
"EnterTouchExplorationModeAtLocation".

Also also, it seems like |id| is always 0, and is never checked later, so
perhaps it doesn't need to be an argument.

[evy, 2014/06/13 22:03:47]

I made it like that just in case we want to try testing something later where
touch explore isn't entered with id 0.
Would it be best to just change the function to use id if we ever encounter the
need, and keep it without for now?

[aboxhall, 2014/06/13 22:09:00]

Yep, that sounds like a good idea. You could even make it a optional argument at
that point.

+    ui::TouchEvent touch_press(ui::ET_TOUCH_PRESSED, tap_location, id, Now());
+    generator_->Dispatch(&touch_press);
+    AdvanceSimulatedTimePastTapDelay();
+    EXPECT_TRUE(IsInTouchToMouseMode());
+  }
+
   bool IsInTouchToMouseMode() {
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(root_window());
     return cursor_client &&
            cursor_client->IsMouseEventsEnabled() &&
            !cursor_client->IsCursorVisible();
   }
 
   bool IsInNoFingersDownState() {
     return touch_exploration_controller_->IsInNoFingersDownStateForTesting();
@@ skipping 541 matching lines @@
   // 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(base::TimeDelta::FromMilliseconds(8000));
+  simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
   generator_->ReleaseTouch();
 
   const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
   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(
-      base::TimeDelta::FromMilliseconds(8000),
-      released_time - pressed_time);
+  EXPECT_EQ(gesture_detector_config_.longpress_timeout,
+            released_time - pressed_time);
 }
 
+// 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);
+
+  // Tap and hold at one location, and get a mouse move event in touch explore.
+  TouchExplorationModeAtLocation(initial_touch_location, 0);
+  std::vector<ui::LocatedEvent*> events =
+      GetCapturedEventsOfType(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 touch1_press(
+      ui::ET_TOUCH_PRESSED, gfx::Point(33, 34), 1, Now());
+  generator_->Dispatch(&touch1_press);
+  ui::TouchEvent touch1_release(
+      ui::ET_TOUCH_RELEASED, gfx::Point(33, 34), 1, Now());
+  generator_->Dispatch(&touch1_release);
+  EXPECT_FALSE(IsInNoFingersDownState());
+
+  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  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.
+// All fingers should be released after the click goes through.
+TEST_F(TouchExplorationTest, SplitTapRelease) {
+  SwitchTouchExplorationMode(true);
+
+  gfx::Point initial_touch_location(11, 12);
+
+  // Tap and hold at one location, and get a mouse move event in touch explore.
+ TouchExplorationModeAtLocation(initial_touch_location, 0);
+
+  std::vector<ui::LocatedEvent*> events =
+      GetCapturedEventsOfType(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. 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 touch1_press(
+      ui::ET_TOUCH_PRESSED, gfx::Point(33, 34), 1, Now());
+  generator_->Dispatch(&touch1_press);
+  ui::TouchEvent touch0_release(
+      ui::ET_TOUCH_RELEASED, initial_touch_location, 0, Now());
+  generator_->Dispatch(&touch0_release);
+  ui::TouchEvent touch1_release(
+      ui::ET_TOUCH_RELEASED, gfx::Point(33, 34), 1, Now());
+  generator_->Dispatch(&touch1_release);
+  EXPECT_TRUE(IsInNoFingersDownState());
+
+  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  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);
+
+  // Tap and hold at one location, and get a mouse move event in touch explore.
+  TouchExplorationModeAtLocation(initial_touch_location, 0);
+
+  std::vector<ui::LocatedEvent*> events =
+      GetCapturedEventsOfType(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 touch1_press(
+      ui::ET_TOUCH_PRESSED, gfx::Point(33, 34), 1, Now());
+  generator_->Dispatch(&touch1_press);
+  simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
+  ui::TouchEvent touch1_release(
+      ui::ET_TOUCH_RELEASED, gfx::Point(33, 34), 1, Now());
+  generator_->Dispatch(&touch1_release);
+  EXPECT_FALSE(IsInNoFingersDownState());
+
+  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  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);
+
+  // Tap and hold at one location, and get a mouse move event in touch explore.
+  TouchExplorationModeAtLocation(initial_touch_location, 0);
+
+  std::vector<ui::LocatedEvent*> events =
+      GetCapturedEventsOfType(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. 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 touch1_press(
+      ui::ET_TOUCH_PRESSED, gfx::Point(33, 34), 1, Now());
+  generator_->Dispatch(&touch1_press);
+  ui::TouchEvent touch0_release(
+      ui::ET_TOUCH_RELEASED, initial_touch_location, 0, Now());
+  generator_->Dispatch(&touch0_release);
+  simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
+  ui::TouchEvent touch1_release(
+      ui::ET_TOUCH_RELEASED, gfx::Point(33, 34), 1, Now());
+  generator_->Dispatch(&touch1_release);
+  EXPECT_TRUE(IsInTouchToMouseMode());
+
+  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  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);
+ }
+
+
 }  // namespace ui