?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update V8 to version 4.7.45.
[chromium-blink-merge.git] / ui / chromeos / touch_exploration_controller_unittest.cc
blob1f584ba3e8ac09fcc4534392a64f83727e15d8ee
1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "ui/chromeos/touch_exploration_controller.h"
6
7 #include "base/test/simple_test_tick_clock.h"
8 #include "base/time/time.h"
9 #include "ui/aura/client/cursor_client.h"
10 #include "ui/aura/test/aura_test_base.h"
11 #include "ui/aura/test/test_cursor_client.h"
12 #include "ui/aura/window.h"
13 #include "ui/events/event.h"
14 #include "ui/events/event_utils.h"
15 #include "ui/events/gestures/gesture_provider_aura.h"
16 #include "ui/events/test/event_generator.h"
17 #include "ui/events/test/events_test_utils.h"
18 #include "ui/gfx/geometry/point.h"
19 #include "ui/gl/gl_implementation.h"
20 #include "ui/gl/test/gl_surface_test_support.h"
21
22 namespace ui {
23
24 namespace {
25
26 // Records all mouse, touch, gesture, and key events.
27 class EventCapturer : public ui::EventHandler {
28 public:
29 EventCapturer() {}
30 ~EventCapturer() override {}
31
32 void Reset() {
33 events_.clear();
34 }
35
36 void OnEvent(ui::Event* event) override {
37 if (event->IsMouseEvent()) {
38 events_.push_back(
39 new ui::MouseEvent(static_cast<ui::MouseEvent&>(*event)));
40 } else if (event->IsTouchEvent()) {
41 events_.push_back(
42 new ui::TouchEvent(static_cast<ui::TouchEvent&>(*event)));
43 } else if (event->IsGestureEvent()) {
44 events_.push_back(
45 new ui::GestureEvent(static_cast<ui::GestureEvent&>(*event)));
46 } else if (event->IsKeyEvent()) {
47 events_.push_back(new ui::KeyEvent(static_cast<ui::KeyEvent&>(*event)));
48 } else {
49 return;
50 }
51 // Stop event propagation so we don't click on random stuff that
52 // might break test assumptions.
53 event->StopPropagation();
54 // If there is a possibility that we're in an infinite loop, we should
55 // exit early with a sensible error rather than letting the test time out.
56 ASSERT_LT(events_.size(), 100u);
57 }
58
59 const ScopedVector<ui::Event>& captured_events() const { return events_; }
60
61 private:
62 ScopedVector<ui::Event> events_;
63
64 DISALLOW_COPY_AND_ASSIGN(EventCapturer);
65 };
66
67 int Factorial(int n) {
68 if (n <= 0)
69 return 0;
70 if (n == 1)
71 return 1;
72 return n * Factorial(n - 1);
73 }
74
75 class MockTouchExplorationControllerDelegate
76 : public ui::TouchExplorationControllerDelegate {
77 public:
78 void SetOutputLevel(int volume) override {
79 volume_changes_.push_back(volume);
80 }
81 void SilenceSpokenFeedback() override {}
82 void PlayVolumeAdjustEarcon() override { ++num_times_adjust_sound_played_; }
83 void PlayPassthroughEarcon() override { ++num_times_passthrough_played_; }
84 void PlayExitScreenEarcon() override { ++num_times_exit_screen_played_; }
85 void PlayEnterScreenEarcon() override { ++num_times_enter_screen_played_; }
86
87 const std::vector<float> VolumeChanges() { return volume_changes_; }
88 size_t NumAdjustSounds() { return num_times_adjust_sound_played_; }
89 size_t NumPassthroughSounds() { return num_times_passthrough_played_; }
90 size_t NumExitScreenSounds() { return num_times_exit_screen_played_; }
91 size_t NumEnterScreenSounds() {
92 return num_times_enter_screen_played_;
93 }
94
95 void ResetCountersToZero() {
96 num_times_adjust_sound_played_ = 0;
97 num_times_passthrough_played_ = 0;
98 num_times_exit_screen_played_ = 0;
99 num_times_enter_screen_played_ = 0;
100 }
101
102 private:
103 std::vector<float> volume_changes_;
104 size_t num_times_adjust_sound_played_ = 0;
105 size_t num_times_passthrough_played_ = 0;
106 size_t num_times_exit_screen_played_ = 0;
107 size_t num_times_enter_screen_played_ = 0;
108 };
109
110 } // namespace
111
112 class TouchExplorationControllerTestApi {
113 public:
114 TouchExplorationControllerTestApi(
115 TouchExplorationController* touch_exploration_controller) {
116 touch_exploration_controller_.reset(touch_exploration_controller);
117 }
118
119 void CallTapTimerNowForTesting() {
120 DCHECK(touch_exploration_controller_->tap_timer_.IsRunning());
121 touch_exploration_controller_->tap_timer_.Stop();
122 touch_exploration_controller_->OnTapTimerFired();
123 }
124
125 void CallPassthroughTimerNowForTesting() {
126 DCHECK(touch_exploration_controller_->passthrough_timer_.IsRunning());
127 touch_exploration_controller_->passthrough_timer_.Stop();
128 touch_exploration_controller_->OnPassthroughTimerFired();
129 }
130
131 void CallTapTimerNowIfRunningForTesting() {
132 if (touch_exploration_controller_->tap_timer_.IsRunning()) {
133 touch_exploration_controller_->tap_timer_.Stop();
134 touch_exploration_controller_->OnTapTimerFired();
135 }
136 }
137
138 bool IsInNoFingersDownStateForTesting() const {
139 return touch_exploration_controller_->state_ ==
140 touch_exploration_controller_->NO_FINGERS_DOWN;
141 }
142
143 bool IsInGestureInProgressStateForTesting() const {
144 return touch_exploration_controller_->state_ ==
145 touch_exploration_controller_->GESTURE_IN_PROGRESS;
146 }
147
148 bool IsInSlideGestureStateForTesting() const {
149 return touch_exploration_controller_->state_ ==
150 touch_exploration_controller_->SLIDE_GESTURE;
151 }
152
153 bool IsInTwoFingerTapStateForTesting() const {
154 return touch_exploration_controller_->state_ ==
155 touch_exploration_controller_->TWO_FINGER_TAP;
156 }
157 bool IsInCornerPassthroughStateForTesting() const {
158 return touch_exploration_controller_->state_ ==
159 touch_exploration_controller_->CORNER_PASSTHROUGH;
160 }
161
162 gfx::Rect BoundsOfRootWindowInDIPForTesting() const {
163 return touch_exploration_controller_->root_window_->GetBoundsInScreen();
164 }
165
166 // VLOGs should be suppressed in tests that generate a lot of logs,
167 // for example permutations of nine touch events.
168 void SuppressVLOGsForTesting(bool suppress) {
169 touch_exploration_controller_->VLOG_on_ = !suppress;
170 }
171
172 float GetMaxDistanceFromEdge() const {
173 return touch_exploration_controller_->kMaxDistanceFromEdge;
174 }
175
176 float GetSlopDistanceFromEdge() const {
177 return touch_exploration_controller_->kSlopDistanceFromEdge;
178 }
179
180 void SetTickClockForTesting(base::TickClock* simulated_clock) {
181 touch_exploration_controller_->tick_clock_ = simulated_clock;
182 }
183
184 private:
185 scoped_ptr<TouchExplorationController> touch_exploration_controller_;
186
187 DISALLOW_COPY_AND_ASSIGN(TouchExplorationControllerTestApi);
188 };
189
190 class TouchExplorationTest : public aura::test::AuraTestBase {
191 public:
192 TouchExplorationTest() : simulated_clock_(new base::SimpleTestTickClock()) {
193 // Tests fail if time is ever 0.
194 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
195 }
196 ~TouchExplorationTest() override {}
197
198 void SetUp() override {
199 if (gfx::GetGLImplementation() == gfx::kGLImplementationNone)
200 gfx::GLSurfaceTestSupport::InitializeOneOff();
201 aura::test::AuraTestBase::SetUp();
202 cursor_client_.reset(new aura::test::TestCursorClient(root_window()));
203 root_window()->AddPreTargetHandler(&event_capturer_);
204 generator_.reset(new test::EventGenerator(root_window()));
205 // The generator takes ownership of the tick clock.
206 generator_->SetTickClock(scoped_ptr<base::TickClock>(simulated_clock_));
207 cursor_client()->ShowCursor();
208 cursor_client()->DisableMouseEvents();
209 }
210
211 void TearDown() override {
212 root_window()->RemovePreTargetHandler(&event_capturer_);
213 SwitchTouchExplorationMode(false);
214 cursor_client_.reset();
215 aura::test::AuraTestBase::TearDown();
216 }
217
218 protected:
219 aura::client::CursorClient* cursor_client() { return cursor_client_.get(); }
220
221 const ScopedVector<ui::Event>& GetCapturedEvents() {
222 return event_capturer_.captured_events();
223 }
224
225 std::vector<ui::LocatedEvent*> GetCapturedLocatedEvents() {
226 const ScopedVector<ui::Event>& all_events = GetCapturedEvents();
227 std::vector<ui::LocatedEvent*> located_events;
228 for (size_t i = 0; i < all_events.size(); ++i) {
229 if (all_events[i]->IsMouseEvent() ||
230 all_events[i]->IsTouchEvent() ||
231 all_events[i]->IsGestureEvent()) {
232 located_events.push_back(static_cast<ui::LocatedEvent*>(all_events[i]));
233 }
234 }
235 return located_events;
236 }
237
238 std::vector<ui::Event*> GetCapturedEventsOfType(int type) {
239 const ScopedVector<ui::Event>& all_events = GetCapturedEvents();
240 std::vector<ui::Event*> events;
241 for (size_t i = 0; i < all_events.size(); ++i) {
242 if (type == all_events[i]->type())
243 events.push_back(all_events[i]);
244 }
245 return events;
246 }
247
248 std::vector<ui::LocatedEvent*> GetCapturedLocatedEventsOfType(int type) {
249 std::vector<ui::LocatedEvent*> located_events = GetCapturedLocatedEvents();
250 std::vector<ui::LocatedEvent*> events;
251 for (size_t i = 0; i < located_events.size(); ++i) {
252 if (type == located_events[i]->type())
253 events.push_back(located_events[i]);
254 }
255 return events;
256 }
257
258 void ClearCapturedEvents() {
259 event_capturer_.Reset();
260 }
261
262 void AdvanceSimulatedTimePastTapDelay() {
263 simulated_clock_->Advance(gesture_detector_config_.double_tap_timeout);
264 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1));
265 touch_exploration_controller_->CallTapTimerNowForTesting();
266 }
267
268 void AdvanceSimulatedTimePastPassthroughDelay() {
269 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
270 touch_exploration_controller_->CallPassthroughTimerNowForTesting();
271 }
272
273 void AdvanceSimulatedTimePastPotentialTapDelay() {
274 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
275 touch_exploration_controller_->CallTapTimerNowIfRunningForTesting();
276 }
277
278 void SuppressVLOGs(bool suppress) {
279 touch_exploration_controller_->SuppressVLOGsForTesting(suppress);
280 }
281
282 void SetTickClock() {
283 touch_exploration_controller_->SetTickClockForTesting(
284 static_cast<base::TickClock*>(simulated_clock_));
285 }
286
287 void SwitchTouchExplorationMode(bool on) {
288 if (!on && touch_exploration_controller_.get()) {
289 touch_exploration_controller_.reset();
290 } else if (on && !touch_exploration_controller_.get()) {
291 touch_exploration_controller_.reset(
292 new ui::TouchExplorationControllerTestApi(
293 new TouchExplorationController(root_window(), &delegate_)));
294 cursor_client()->ShowCursor();
295 cursor_client()->DisableMouseEvents();
296 }
297 }
298
299 void EnterTouchExplorationModeAtLocation(gfx::Point tap_location) {
300 ui::TouchEvent touch_press(ui::ET_TOUCH_PRESSED, tap_location, 0, Now());
301 generator_->Dispatch(&touch_press);
302 AdvanceSimulatedTimePastTapDelay();
303 EXPECT_TRUE(IsInTouchToMouseMode());
304 }
305
306 // Checks that Corner Passthrough is working. Assumes that corner is the
307 // bottom left corner or the bottom right corner.
308 void AssertCornerPassthroughWorking(gfx::Point corner) {
309 ASSERT_EQ(0U, delegate_.NumPassthroughSounds());
310
311 ui::TouchEvent first_press(ui::ET_TOUCH_PRESSED, corner, 0, Now());
312 generator_->Dispatch(&first_press);
313
314 AdvanceSimulatedTimePastPassthroughDelay();
315 EXPECT_FALSE(IsInGestureInProgressState());
316 EXPECT_FALSE(IsInSlideGestureState());
317 EXPECT_FALSE(IsInTouchToMouseMode());
318 EXPECT_TRUE(IsInCornerPassthroughState());
319
320 gfx::Rect window = BoundsOfRootWindowInDIP();
321 // The following events should be passed through.
322 gfx::Point passthrough(window.right() / 2, window.bottom() / 2);
323 ui::TouchEvent passthrough_press(
324 ui::ET_TOUCH_PRESSED, passthrough, 1, Now());
325 ASSERT_EQ(1U, delegate_.NumPassthroughSounds());
326 generator_->Dispatch(&passthrough_press);
327 generator_->ReleaseTouchId(1);
328 generator_->PressTouchId(1);
329 EXPECT_FALSE(IsInGestureInProgressState());
330 EXPECT_FALSE(IsInSlideGestureState());
331 EXPECT_TRUE(IsInCornerPassthroughState());
332
333 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
334 ASSERT_EQ(3U, captured_events.size());
335 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
336 EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
337 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[2]->type());
338 generator_->ReleaseTouchId(1);
339 ClearCapturedEvents();
340
341 generator_->ReleaseTouchId(0);
342 captured_events = GetCapturedLocatedEvents();
343 ASSERT_EQ(0U, captured_events.size());
344 EXPECT_FALSE(IsInTouchToMouseMode());
345 EXPECT_FALSE(IsInCornerPassthroughState());
346 ClearCapturedEvents();
347 }
348
349 bool IsInTouchToMouseMode() {
350 aura::client::CursorClient* cursor_client =
351 aura::client::GetCursorClient(root_window());
352 return cursor_client &&
353 cursor_client->IsMouseEventsEnabled() &&
354 !cursor_client->IsCursorVisible();
355 }
356
357 bool IsInNoFingersDownState() {
358 return touch_exploration_controller_->IsInNoFingersDownStateForTesting();
359 }
360
361 bool IsInGestureInProgressState() {
362 return touch_exploration_controller_
363 ->IsInGestureInProgressStateForTesting();
364 }
365
366 bool IsInSlideGestureState() {
367 return touch_exploration_controller_->IsInSlideGestureStateForTesting();
368 }
369
370 bool IsInTwoFingerTapState() {
371 return touch_exploration_controller_->IsInTwoFingerTapStateForTesting();
372 }
373
374 bool IsInCornerPassthroughState() {
375 return touch_exploration_controller_
376 ->IsInCornerPassthroughStateForTesting();
377 }
378
379 gfx::Rect BoundsOfRootWindowInDIP() {
380 return touch_exploration_controller_->BoundsOfRootWindowInDIPForTesting();
381 }
382
383 float GetMaxDistanceFromEdge() const {
384 return touch_exploration_controller_->GetMaxDistanceFromEdge();
385 }
386
387 float GetSlopDistanceFromEdge() const {
388 return touch_exploration_controller_->GetSlopDistanceFromEdge();
389 }
390
391 base::TimeDelta Now() {
392 // This is the same as what EventTimeForNow() does, but here we do it
393 // with our simulated clock.
394 return base::TimeDelta::FromInternalValue(
395 simulated_clock_->NowTicks().ToInternalValue());
396 }
397
398 scoped_ptr<test::EventGenerator> generator_;
399 ui::GestureDetector::Config gesture_detector_config_;
400 // Owned by |generator_|.
401 base::SimpleTestTickClock* simulated_clock_;
402 MockTouchExplorationControllerDelegate delegate_;
403
404 private:
405 EventCapturer event_capturer_;
406 scoped_ptr<TouchExplorationControllerTestApi>
407 touch_exploration_controller_;
408 scoped_ptr<aura::test::TestCursorClient> cursor_client_;
409
410 DISALLOW_COPY_AND_ASSIGN(TouchExplorationTest);
411 };
412
413 // Executes a number of assertions to confirm that |e1| and |e2| are touch
414 // events and are equal to each other.
415 void ConfirmEventsAreTouchAndEqual(ui::Event* e1, ui::Event* e2) {
416 ASSERT_TRUE(e1->IsTouchEvent());
417 ASSERT_TRUE(e2->IsTouchEvent());
418 ui::TouchEvent* touch_event1 = static_cast<ui::TouchEvent*>(e1);
419 ui::TouchEvent* touch_event2 = static_cast<ui::TouchEvent*>(e2);
420 EXPECT_EQ(touch_event1->type(), touch_event2->type());
421 EXPECT_EQ(touch_event1->location(), touch_event2->location());
422 EXPECT_EQ(touch_event1->touch_id(), touch_event2->touch_id());
423 EXPECT_EQ(touch_event1->flags(), touch_event2->flags());
424 EXPECT_EQ(touch_event1->time_stamp(), touch_event2->time_stamp());
425 }
426
427 // Executes a number of assertions to confirm that |e1| and |e2| are mouse
428 // events and are equal to each other.
429 void ConfirmEventsAreMouseAndEqual(ui::Event* e1, ui::Event* e2) {
430 ASSERT_TRUE(e1->IsMouseEvent());
431 ASSERT_TRUE(e2->IsMouseEvent());
432 ui::MouseEvent* mouse_event1 = static_cast<ui::MouseEvent*>(e1);
433 ui::MouseEvent* mouse_event2 = static_cast<ui::MouseEvent*>(e2);
434 EXPECT_EQ(mouse_event1->type(), mouse_event2->type());
435 EXPECT_EQ(mouse_event1->location(), mouse_event2->location());
436 EXPECT_EQ(mouse_event1->root_location(), mouse_event2->root_location());
437 EXPECT_EQ(mouse_event1->flags(), mouse_event2->flags());
438 }
439
440 // Executes a number of assertions to confirm that |e1| and |e2| are key events
441 // and are equal to each other.
442 void ConfirmEventsAreKeyAndEqual(ui::Event* e1, ui::Event* e2) {
443 ASSERT_TRUE(e1->IsKeyEvent());
444 ASSERT_TRUE(e2->IsKeyEvent());
445 ui::KeyEvent* key_event1 = static_cast<ui::KeyEvent*>(e1);
446 ui::KeyEvent* key_event2 = static_cast<ui::KeyEvent*>(e2);
447 EXPECT_EQ(key_event1->type(), key_event2->type());
448 EXPECT_EQ(key_event1->key_code(), key_event2->key_code());
449 EXPECT_EQ(key_event1->code(), key_event2->code());
450 EXPECT_EQ(key_event1->flags(), key_event2->flags());
451 }
452
453 #define CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(e1, e2) \
454 ASSERT_NO_FATAL_FAILURE(ConfirmEventsAreTouchAndEqual(e1, e2))
455
456 #define CONFIRM_EVENTS_ARE_MOUSE_AND_EQUAL(e1, e2) \
457 ASSERT_NO_FATAL_FAILURE(ConfirmEventsAreMouseAndEqual(e1, e2))
458
459 #define CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(e1, e2) \
460 ASSERT_NO_FATAL_FAILURE(ConfirmEventsAreKeyAndEqual(e1, e2))
461
462 // TODO(mfomitchev): Need to investigate why we don't get mouse enter/exit
463 // events when running these tests as part of ui_base_unittests. We do get them
464 // when the tests are run as part of ash unit tests.
465
466 // If a swipe has been successfully completed, then six key events will be
467 // dispatched that correspond to shift+search+direction
468 void AssertDirectionalNavigationEvents(const ScopedVector<ui::Event>& events,
469 ui::KeyboardCode direction) {
470 ASSERT_EQ(6U, events.size());
471 ui::KeyEvent shift_pressed(
472 ui::ET_KEY_PRESSED, ui::VKEY_SHIFT, ui::EF_SHIFT_DOWN);
473 ui::KeyEvent search_pressed(
474 ui::ET_KEY_PRESSED, ui::VKEY_LWIN, ui::EF_SHIFT_DOWN);
475 ui::KeyEvent direction_pressed(
476 ui::ET_KEY_PRESSED, direction, ui::EF_SHIFT_DOWN);
477 ui::KeyEvent direction_released(
478 ui::ET_KEY_RELEASED, direction, ui::EF_SHIFT_DOWN);
479 ui::KeyEvent search_released(
480 ui::ET_KEY_RELEASED, VKEY_LWIN, ui::EF_SHIFT_DOWN);
481 ui::KeyEvent shift_released(
482 ui::ET_KEY_RELEASED, ui::VKEY_SHIFT, ui::EF_NONE);
483 CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&shift_pressed, events[0]);
484 CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&search_pressed, events[1]);
485 CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&direction_pressed, events[2]);
486 CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&direction_released, events[3]);
487 CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&search_released, events[4]);
488 CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&shift_released, events[5]);
489 }
490
491 TEST_F(TouchExplorationTest, EntersTouchToMouseModeAfterPressAndDelay) {
492 SwitchTouchExplorationMode(true);
493 EXPECT_FALSE(IsInTouchToMouseMode());
494 generator_->PressTouch();
495 AdvanceSimulatedTimePastTapDelay();
496 EXPECT_TRUE(IsInTouchToMouseMode());
497 }
498
499 TEST_F(TouchExplorationTest, EntersTouchToMouseModeAfterMoveOutsideSlop) {
500 int slop = gesture_detector_config_.touch_slop;
501 int half_slop = slop / 2;
502
503 SwitchTouchExplorationMode(true);
504 EXPECT_FALSE(IsInTouchToMouseMode());
505 generator_->set_current_location(gfx::Point(11, 12));
506 generator_->PressTouch();
507 generator_->MoveTouch(gfx::Point(11 + half_slop, 12));
508 EXPECT_FALSE(IsInTouchToMouseMode());
509 generator_->MoveTouch(gfx::Point(11, 12 + half_slop));
510 EXPECT_FALSE(IsInTouchToMouseMode());
511 AdvanceSimulatedTimePastTapDelay();
512 generator_->MoveTouch(gfx::Point(11 + slop + 1, 12));
513 EXPECT_TRUE(IsInTouchToMouseMode());
514 }
515
516 TEST_F(TouchExplorationTest, OneFingerTap) {
517 SwitchTouchExplorationMode(true);
518 gfx::Point location(11, 12);
519 generator_->set_current_location(location);
520 generator_->PressTouch();
521 generator_->ReleaseTouch();
522 AdvanceSimulatedTimePastTapDelay();
523
524 std::vector<ui::LocatedEvent*> events =
525 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
526 ASSERT_EQ(1U, events.size());
527
528 EXPECT_EQ(location, events[0]->location());
529 EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
530 EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
531 EXPECT_TRUE(IsInNoFingersDownState());
532 }
533
534 TEST_F(TouchExplorationTest, ActualMouseMovesUnaffected) {
535 SwitchTouchExplorationMode(true);
536
537 gfx::Point location_start(11, 12);
538 gfx::Point location_end(13, 14);
539 generator_->set_current_location(location_start);
540 generator_->PressTouch();
541 AdvanceSimulatedTimePastTapDelay();
542 generator_->MoveTouch(location_end);
543
544 gfx::Point location_real_mouse_move(15, 16);
545 ui::MouseEvent mouse_move(ui::ET_MOUSE_MOVED, location_real_mouse_move,
546 location_real_mouse_move, ui::EventTimeForNow(), 0,
547 0);
548 generator_->Dispatch(&mouse_move);
549 generator_->ReleaseTouch();
550 AdvanceSimulatedTimePastTapDelay();
551
552 std::vector<ui::LocatedEvent*> events =
553 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
554 ASSERT_EQ(4U, events.size());
555
556 EXPECT_EQ(location_start, events[0]->location());
557 EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
558 EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
559
560 EXPECT_EQ(location_end, events[1]->location());
561 EXPECT_TRUE(events[1]->flags() & ui::EF_IS_SYNTHESIZED);
562 EXPECT_TRUE(events[1]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
563
564 // The real mouse move goes through.
565 EXPECT_EQ(location_real_mouse_move, events[2]->location());
566 CONFIRM_EVENTS_ARE_MOUSE_AND_EQUAL(events[2], &mouse_move);
567 EXPECT_FALSE(events[2]->flags() & ui::EF_IS_SYNTHESIZED);
568 EXPECT_FALSE(events[2]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
569
570 // The touch release gets written as a mouse move.
571 EXPECT_EQ(location_end, events[3]->location());
572 EXPECT_TRUE(events[3]->flags() & ui::EF_IS_SYNTHESIZED);
573 EXPECT_TRUE(events[3]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
574 EXPECT_TRUE(IsInNoFingersDownState());
575 }
576
577 // Turn the touch exploration mode on in the middle of the touch gesture.
578 // Confirm that events from the finger which was touching when the mode was
579 // turned on don't get rewritten.
580 TEST_F(TouchExplorationTest, TurnOnMidTouch) {
581 SwitchTouchExplorationMode(false);
582 generator_->PressTouchId(1);
583 EXPECT_TRUE(cursor_client()->IsCursorVisible());
584 ClearCapturedEvents();
585
586 // Enable touch exploration mode while the first finger is touching the
587 // screen. Ensure that subsequent events from that first finger are not
588 // affected by the touch exploration mode, while the touch events from another
589 // finger get rewritten.
590 SwitchTouchExplorationMode(true);
591 ui::TouchEvent touch_move(ui::ET_TOUCH_MOVED,
592 gfx::Point(11, 12),
593 1,
594 Now());
595 generator_->Dispatch(&touch_move);
596 EXPECT_TRUE(cursor_client()->IsCursorVisible());
597 EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
598 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
599 ASSERT_EQ(1u, captured_events.size());
600 CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_move);
601 ClearCapturedEvents();
602
603 // The press from the second finger should get rewritten.
604 generator_->PressTouchId(2);
605 AdvanceSimulatedTimePastTapDelay();
606 EXPECT_TRUE(IsInTouchToMouseMode());
607 captured_events = GetCapturedLocatedEvents();
608 std::vector<ui::LocatedEvent*>::const_iterator it;
609 for (it = captured_events.begin(); it != captured_events.end(); ++it) {
610 if ((*it)->type() == ui::ET_MOUSE_MOVED)
611 break;
612 }
613 EXPECT_NE(captured_events.end(), it);
614 ClearCapturedEvents();
615
616 // The release of the first finger shouldn't be affected.
617 ui::TouchEvent touch_release(ui::ET_TOUCH_RELEASED,
618 gfx::Point(11, 12),
619 1,
620 Now());
621 generator_->Dispatch(&touch_release);
622 captured_events = GetCapturedLocatedEvents();
623 ASSERT_EQ(1u, captured_events.size());
624 CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_release);
625 ClearCapturedEvents();
626
627 // The move and release from the second finger should get rewritten.
628 generator_->MoveTouchId(gfx::Point(13, 14), 2);
629 generator_->ReleaseTouchId(2);
630 AdvanceSimulatedTimePastTapDelay();
631 captured_events = GetCapturedLocatedEvents();
632 ASSERT_EQ(2u, captured_events.size());
633 EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());
634 EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[1]->type());
635 EXPECT_TRUE(IsInNoFingersDownState());
636 }
637
638 // If an event is received after the double-tap timeout has elapsed, but
639 // before the timer has fired, a mouse move should still be generated.
640 TEST_F(TouchExplorationTest, TimerFiresLateDuringTouchExploration) {
641 SwitchTouchExplorationMode(true);
642
643 // Make sure the touch is not in a corner of the screen.
644 generator_->MoveTouch(gfx::Point(100, 200));
645
646 // Send a press, then add another finger after the double-tap timeout.
647 generator_->PressTouchId(1);
648 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
649 generator_->PressTouchId(2);
650 std::vector<ui::LocatedEvent*> events =
651 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
652 ASSERT_EQ(1U, events.size());
653 EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
654 EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
655
656 generator_->ReleaseTouchId(2);
657 generator_->ReleaseTouchId(1);
658 AdvanceSimulatedTimePastTapDelay();
659 EXPECT_TRUE(IsInNoFingersDownState());
660 }
661
662 // If a new tap is received after the double-tap timeout has elapsed from
663 // a previous tap, but before the timer has fired, a mouse move should
664 // still be generated from the old tap.
665 TEST_F(TouchExplorationTest, TimerFiresLateAfterTap) {
666 SwitchTouchExplorationMode(true);
667
668 // Send a tap at location1.
669 gfx::Point location0(11, 12);
670 generator_->set_current_location(location0);
671 generator_->PressTouch();
672 generator_->ReleaseTouch();
673
674 // Send a tap at location2, after the double-tap timeout, but before the
675 // timer fires.
676 gfx::Point location1(33, 34);
677 generator_->set_current_location(location1);
678 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(301));
679 generator_->PressTouch();
680 generator_->ReleaseTouch();
681 AdvanceSimulatedTimePastTapDelay();
682
683 std::vector<ui::LocatedEvent*> events =
684 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
685 ASSERT_EQ(2U, events.size());
686 EXPECT_EQ(location0, events[0]->location());
687 EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
688 EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
689 EXPECT_EQ(location1, events[1]->location());
690 EXPECT_TRUE(events[1]->flags() & ui::EF_IS_SYNTHESIZED);
691 EXPECT_TRUE(events[1]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
692 EXPECT_TRUE(IsInNoFingersDownState());
693 }
694
695 // Double-tapping should send a touch press and release through to the location
696 // of the last successful touch exploration.
697 TEST_F(TouchExplorationTest, DoubleTap) {
698 SwitchTouchExplorationMode(true);
699
700 // Tap at one location, and get a mouse move event.
701 gfx::Point tap_location(51, 52);
702 generator_->set_current_location(tap_location);
703 generator_->PressTouchId(1);
704 generator_->ReleaseTouchId(1);
705 AdvanceSimulatedTimePastTapDelay();
706
707 std::vector<ui::LocatedEvent*> events =
708 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
709 ASSERT_EQ(1U, events.size());
710
711 EXPECT_EQ(tap_location, events[0]->location());
712 EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
713 EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
714 ClearCapturedEvents();
715
716 // Now double-tap at a different location. This should result in
717 // a single touch press and release at the location of the tap,
718 // not at the location of the double-tap.
719 gfx::Point double_tap_location(33, 34);
720 generator_->set_current_location(double_tap_location);
721 generator_->PressTouch();
722 generator_->ReleaseTouch();
723 generator_->PressTouch();
724 generator_->ReleaseTouch();
725
726 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
727 ASSERT_EQ(2U, captured_events.size());
728 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
729 EXPECT_EQ(tap_location, captured_events[0]->location());
730 EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
731 EXPECT_EQ(tap_location, captured_events[1]->location());
732 EXPECT_TRUE(IsInNoFingersDownState());
733 }
734
735 // Double-tapping where the user holds their finger down for the second time
736 // for a longer press should send a touch press and passthrough all further
737 // events from that finger. Other finger presses should be ignored.
738 TEST_F(TouchExplorationTest, DoubleTapPassthrough) {
739 SwitchTouchExplorationMode(true);
740
741 // Tap at one location, and get a mouse move event.
742 gfx::Point tap_location(11, 12);
743 generator_->set_current_location(tap_location);
744 generator_->PressTouch();
745 generator_->ReleaseTouch();
746 AdvanceSimulatedTimePastTapDelay();
747
748 std::vector<ui::LocatedEvent*> events =
749 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
750 ASSERT_EQ(1U, events.size());
751
752 EXPECT_EQ(tap_location, events[0]->location());
753 EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
754 EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
755 ClearCapturedEvents();
756
757 // Now double-tap and hold at a different location.
758 // This should result in a single touch press at the location of the tap,
759 // not at the location of the double-tap.
760 gfx::Point first_tap_location(13, 14);
761 generator_->set_current_location(first_tap_location);
762 generator_->PressTouchId(1);
763 generator_->ReleaseTouchId(1);
764 gfx::Point second_tap_location(15, 16);
765 generator_->set_current_location(second_tap_location);
766 generator_->PressTouchId(1);
767 // Advance to the finger passing through.
768 AdvanceSimulatedTimePastTapDelay();
769
770 gfx::Vector2d passthrough_offset = second_tap_location - tap_location;
771
772 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
773 ASSERT_EQ(1U, captured_events.size());
774 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
775 EXPECT_EQ(second_tap_location - passthrough_offset,
776 captured_events[0]->location());
777
778 ClearCapturedEvents();
779
780 // All events for the first finger should pass through now, displaced
781 // relative to the last touch exploration location.
782 gfx::Point first_move_location(17, 18);
783 generator_->MoveTouchId(first_move_location, 1);
784 gfx::Point second_move_location(12, 13);
785 generator_->MoveTouchId(second_move_location, 1);
786
787 captured_events = GetCapturedLocatedEvents();
788 ASSERT_EQ(2U, captured_events.size());
789 EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[0]->type());
790 EXPECT_EQ(first_move_location - passthrough_offset,
791 captured_events[0]->location());
792 EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[1]->type());
793 EXPECT_EQ(second_move_location - passthrough_offset,
794 captured_events[1]->location());
795
796 ClearCapturedEvents();
797
798 // Events for other fingers should do nothing.
799 generator_->PressTouchId(2);
800 generator_->PressTouchId(3);
801 generator_->MoveTouchId(gfx::Point(34, 36), 2);
802 generator_->ReleaseTouchId(2);
803 captured_events = GetCapturedLocatedEvents();
804 ASSERT_EQ(0U, captured_events.size());
805
806 // Even with finger 3 still down, events for the first finger should still
807 // pass through.
808 gfx::Point third_move_location(14, 15);
809 generator_->MoveTouchId(third_move_location, 1);
810 captured_events = GetCapturedLocatedEvents();
811 ASSERT_EQ(1U, captured_events.size());
812 EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[0]->type());
813 EXPECT_EQ(third_move_location - passthrough_offset,
814 captured_events[0]->location());
815
816 // No fingers down state is only reached when every finger is lifted.
817 generator_->ReleaseTouchId(1);
818 EXPECT_FALSE(IsInNoFingersDownState());
819 generator_->ReleaseTouchId(3);
820 EXPECT_TRUE(IsInNoFingersDownState());
821 }
822
823 // Double-tapping, going into passthrough, and holding for the longpress
824 // time should send a touch press and released (right click)
825 // to the location of the last successful touch exploration.
826 TEST_F(TouchExplorationTest, DoubleTapLongPress) {
827 SwitchTouchExplorationMode(true);
828 SetTickClock();
829 // Tap at one location, and get a mouse move event.
830 gfx::Point tap_location(11, 12);
831 generator_->set_current_location(tap_location);
832 generator_->PressTouch();
833 generator_->ReleaseTouch();
834 AdvanceSimulatedTimePastTapDelay();
835
836 std::vector<ui::LocatedEvent*> events =
837 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
838 ASSERT_EQ(1U, events.size());
839 EXPECT_EQ(tap_location, events[0]->location());
840 EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
841 EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
842 ClearCapturedEvents();
843
844 // Now double-tap and hold at a different location.
845 // This should result in a single touch long press and release
846 // at the location of the tap, not at the location of the double-tap.
847 // There should be a time delay between the touch press and release.
848 gfx::Point first_tap_location(33, 34);
849 generator_->set_current_location(first_tap_location);
850 generator_->PressTouch();
851 generator_->ReleaseTouch();
852 gfx::Point second_tap_location(23, 24);
853 generator_->set_current_location(second_tap_location);
854 generator_->PressTouch();
855 // Advance to the finger passing through, and then to the longpress timeout.
856 AdvanceSimulatedTimePastTapDelay();
857 simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
858 generator_->ReleaseTouch();
859
860 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
861 ASSERT_EQ(2U, captured_events.size());
862 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
863 EXPECT_EQ(tap_location, captured_events[0]->location());
864 base::TimeDelta pressed_time = captured_events[0]->time_stamp();
865 EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
866 EXPECT_EQ(tap_location, captured_events[1]->location());
867 base::TimeDelta released_time = captured_events[1]->time_stamp();
868 EXPECT_EQ(released_time - pressed_time,
869 gesture_detector_config_.longpress_timeout);
870 }
871
872 // Single-tapping should send a touch press and release through to the location
873 // of the last successful touch exploration if the grace period has not
874 // elapsed.
875 TEST_F(TouchExplorationTest, SingleTap) {
876 SwitchTouchExplorationMode(true);
877
878 // Tap once to simulate a mouse moved event.
879 gfx::Point initial_location(11, 12);
880 generator_->set_current_location(initial_location);
881 generator_->PressTouch();
882 AdvanceSimulatedTimePastTapDelay();
883 ClearCapturedEvents();
884
885 // Move to another location for single tap
886 gfx::Point tap_location(22, 23);
887 generator_->MoveTouch(tap_location);
888 generator_->ReleaseTouch();
889
890 // Allow time to pass within the grace period of releasing before
891 // tapping again.
892 gfx::Point final_location(33, 34);
893 generator_->set_current_location(final_location);
894 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(250));
895 generator_->PressTouch();
896 generator_->ReleaseTouch();
897
898 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
899 ASSERT_EQ(4U, captured_events.size());
900 EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());
901 EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[1]->type());
902 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[2]->type());
903 EXPECT_EQ(tap_location, captured_events[2]->location());
904 EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[3]->type());
905 EXPECT_EQ(tap_location, captured_events[3]->location());
906 }
907
908 // Double-tapping without coming from touch exploration (no previous touch
909 // exploration event) should not generate any events.
910 TEST_F(TouchExplorationTest, DoubleTapNoTouchExplore) {
911 SwitchTouchExplorationMode(true);
912
913 // Double-tap without any previous touch.
914 // Touch exploration mode has not been entered, so there is no previous
915 // touch exploration event. The double-tap should be discarded, and no events
916 // should be generated at all.
917 gfx::Point double_tap_location(33, 34);
918 generator_->set_current_location(double_tap_location);
919 generator_->PressTouch();
920 generator_->ReleaseTouch();
921 generator_->PressTouch();
922 // Since the state stays in single_tap_released, we need to make sure the
923 // tap timer doesn't fire and set the state to no fingers down (since there
924 // is still a finger down).
925 AdvanceSimulatedTimePastPotentialTapDelay();
926 EXPECT_FALSE(IsInNoFingersDownState());
927 generator_->ReleaseTouch();
928 EXPECT_TRUE(IsInNoFingersDownState());
929
930 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
931 ASSERT_EQ(0U, captured_events.size());
932 }
933
934 // Tapping and releasing with a second finger when in touch exploration mode
935 // should send a touch press and released to the location of the last
936 // successful touch exploration and return to touch explore.
937 TEST_F(TouchExplorationTest, SplitTap) {
938 SwitchTouchExplorationMode(true);
939 gfx::Point initial_touch_location(11, 12);
940 gfx::Point second_touch_location(33, 34);
941
942 // Tap and hold at one location, and get a mouse move event in touch explore.
943 EnterTouchExplorationModeAtLocation(initial_touch_location);
944 std::vector<ui::LocatedEvent*> events =
945 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
946 ASSERT_EQ(1U, events.size());
947
948 EXPECT_EQ(initial_touch_location, events[0]->location());
949 EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
950 EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
951 ClearCapturedEvents();
952 EXPECT_TRUE(IsInTouchToMouseMode());
953
954 // Now tap and release at a different location. This should result in a
955 // single touch and release at the location of the first (held) tap,
956 // not at the location of the second tap and release.
957 // After the release, there is still a finger in touch explore mode.
958 ui::TouchEvent split_tap_press(
959 ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
960 generator_->Dispatch(&split_tap_press);
961 // To simulate the behavior of the real device, we manually disable
962 // mouse events. To not rely on manually setting the state, this is also
963 // tested in touch_exploration_controller_browsertest.
964 cursor_client()->DisableMouseEvents();
965 EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
966 EXPECT_FALSE(cursor_client()->IsCursorVisible());
967 EXPECT_FALSE(IsInGestureInProgressState());
968 ui::TouchEvent split_tap_release(
969 ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());
970 generator_->Dispatch(&split_tap_release);
971 // Releasing the second finger should re-enable mouse events putting us
972 // back into the touch exploration mode.
973 EXPECT_TRUE(IsInTouchToMouseMode());
974 EXPECT_FALSE(IsInNoFingersDownState());
975
976 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
977 ASSERT_EQ(2U, captured_events.size());
978 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
979 EXPECT_EQ(initial_touch_location, captured_events[0]->location());
980 EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
981 EXPECT_EQ(initial_touch_location, captured_events[1]->location());
982 ClearCapturedEvents();
983
984 ui::TouchEvent touch_explore_release(
985 ui::ET_TOUCH_RELEASED, initial_touch_location, 0, Now());
986 generator_->Dispatch(&touch_explore_release);
987 AdvanceSimulatedTimePastTapDelay();
988 EXPECT_TRUE(IsInNoFingersDownState());
989 }
990
991 // If split tap is started but the touch explore finger is released first,
992 // there should still be a touch press and release sent to the location of
993 // the last successful touch exploration.
994 // Both fingers should be released after the click goes through.
995 TEST_F(TouchExplorationTest, SplitTapRelease) {
996 SwitchTouchExplorationMode(true);
997
998 gfx::Point initial_touch_location(11, 12);
999 gfx::Point second_touch_location(33, 34);
1000
1001 // Tap and hold at one location, and get a mouse move event in touch explore.
1002 EnterTouchExplorationModeAtLocation(initial_touch_location);
1003
1004 std::vector<ui::LocatedEvent*> events =
1005 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
1006 ASSERT_EQ(1U, events.size());
1007
1008 ClearCapturedEvents();
1009
1010 // Now tap at a different location. Release at the first location,
1011 // then release at the second. This should result in a
1012 // single touch and release at the location of the first (held) tap,
1013 // not at the location of the second tap and release.
1014 ui::TouchEvent split_tap_press(
1015 ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
1016 generator_->Dispatch(&split_tap_press);
1017 ui::TouchEvent touch_explore_release(
1018 ui::ET_TOUCH_RELEASED, initial_touch_location, 0, Now());
1019 generator_->Dispatch(&touch_explore_release);
1020 ui::TouchEvent split_tap_release(
1021 ui::ET_TOUCH_RELEASED, second_touch_location , 1, Now());
1022 generator_->Dispatch(&split_tap_release);
1023 EXPECT_TRUE(IsInNoFingersDownState());
1024
1025 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
1026 ASSERT_EQ(2U, captured_events.size());
1027 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
1028 EXPECT_EQ(initial_touch_location, captured_events[0]->location());
1029 EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
1030 EXPECT_EQ(initial_touch_location, captured_events[1]->location());
1031 }
1032
1033 // When in touch exploration mode, making a long press with a second finger
1034 // should send a touch press and released to the location of the last
1035 // successful touch exploration. There should be a delay between the
1036 // touch and release events (right click).
1037 TEST_F(TouchExplorationTest, SplitTapLongPress) {
1038 SwitchTouchExplorationMode(true);
1039 gfx::Point initial_touch_location(11, 12);
1040 gfx::Point second_touch_location(33, 34);
1041
1042 // Tap and hold at one location, and get a mouse move event in touch explore.
1043 EnterTouchExplorationModeAtLocation(initial_touch_location);
1044 std::vector<ui::LocatedEvent*> events =
1045 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
1046 ASSERT_EQ(1U, events.size());
1047
1048 ClearCapturedEvents();
1049
1050 // Now tap, hold, and release at a different location. This should result
1051 // in a single touch and release (long press) at the location of the first
1052 // (held) tap, not at the location of the second tap and release.
1053 ui::TouchEvent split_tap_press(
1054 ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
1055 generator_->Dispatch(&split_tap_press);
1056 // To simulate the behavior of the real device, we manually disable
1057 // mouse events, like in the SplitTap test.
1058 cursor_client()->DisableMouseEvents();
1059 EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
1060 EXPECT_FALSE(cursor_client()->IsCursorVisible());
1061 EXPECT_FALSE(IsInGestureInProgressState());
1062 simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
1063 // After the release, there is still a finger in touch exploration, and
1064 // mouse events should be enabled again.
1065 ui::TouchEvent split_tap_release(
1066 ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());
1067 generator_->Dispatch(&split_tap_release);
1068 EXPECT_FALSE(IsInNoFingersDownState());
1069 EXPECT_TRUE(IsInTouchToMouseMode());
1070
1071 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
1072 ASSERT_EQ(2U, captured_events.size());
1073 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
1074 EXPECT_EQ(initial_touch_location, captured_events[0]->location());
1075 base::TimeDelta pressed_time = captured_events[0]->time_stamp();
1076 EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
1077 EXPECT_EQ(initial_touch_location, captured_events[1]->location());
1078 base::TimeDelta released_time = captured_events[1]->time_stamp();
1079 EXPECT_EQ(gesture_detector_config_.longpress_timeout,
1080 released_time - pressed_time);
1081 }
1082
1083 // If split tap is started but the touch explore finger is released first,
1084 // there should still be a touch press and release sent to the location of
1085 // the last successful touch exploration. If the remaining finger is held
1086 // as a longpress, there should be a delay between the sent touch and release
1087 // events (right click).All fingers should be released after the click
1088 // goes through.
1089 TEST_F(TouchExplorationTest, SplitTapReleaseLongPress) {
1090 SwitchTouchExplorationMode(true);
1091 gfx::Point initial_touch_location(11, 12);
1092 gfx::Point second_touch_location(33, 34);
1093
1094 // Tap and hold at one location, and get a mouse move event in touch explore.
1095 EnterTouchExplorationModeAtLocation(initial_touch_location);
1096 std::vector<ui::LocatedEvent*> events =
1097 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
1098 ASSERT_EQ(1U, events.size());
1099 ClearCapturedEvents();
1100
1101 // Now tap at a different location. Release at the first location,
1102 // then release at the second. This should result in a
1103 // single touch and release at the location of the first (held) tap,
1104 // not at the location of the second tap and release.
1105 // After the release, TouchToMouseMode should still be on.
1106 ui::TouchEvent split_tap_press(
1107 ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
1108 generator_->Dispatch(&split_tap_press);
1109 ui::TouchEvent touch_explore_release(
1110 ui::ET_TOUCH_RELEASED, initial_touch_location, 0, Now());
1111 generator_->Dispatch(&touch_explore_release);
1112 simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
1113 ui::TouchEvent split_tap_release(
1114 ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());
1115 generator_->Dispatch(&split_tap_release);
1116 EXPECT_TRUE(IsInTouchToMouseMode());
1117
1118 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
1119 ASSERT_EQ(2U, captured_events.size());
1120 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
1121 EXPECT_EQ(initial_touch_location, captured_events[0]->location());
1122 base::TimeDelta pressed_time = captured_events[0]->time_stamp();
1123 EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
1124 EXPECT_EQ(initial_touch_location, captured_events[1]->location());
1125 base::TimeDelta released_time = captured_events[1]->time_stamp();
1126 EXPECT_EQ(gesture_detector_config_.longpress_timeout,
1127 released_time - pressed_time);
1128 }
1129
1130 TEST_F(TouchExplorationTest, SplitTapMultiFinger) {
1131 SwitchTouchExplorationMode(true);
1132 gfx::Point initial_touch_location(11, 12);
1133 gfx::Point second_touch_location(33, 34);
1134 gfx::Point third_touch_location(16, 17);
1135
1136 // Tap and hold at one location, and get a mouse move event in touch explore.
1137 EnterTouchExplorationModeAtLocation(initial_touch_location);
1138
1139 std::vector<ui::LocatedEvent*> events =
1140 GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
1141 ASSERT_EQ(1U, events.size());
1142
1143 EXPECT_EQ(initial_touch_location, events[0]->location());
1144 EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);
1145 EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
1146 ClearCapturedEvents();
1147
1148 // Now tap at a different location and hold for long press.
1149 ui::TouchEvent split_tap_press(
1150 ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
1151 generator_->Dispatch(&split_tap_press);
1152 simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);
1153
1154 // Placing a third finger on the screen should cancel the initial press and
1155 // enter the wait state.
1156 ui::TouchEvent third_press(
1157 ui::ET_TOUCH_PRESSED, third_touch_location, 2, Now());
1158 generator_->Dispatch(&third_press);
1159
1160 // When all three fingers are released, the only events captured should be a
1161 // press and touch cancel. All fingers should then be up.
1162 ui::TouchEvent touch_explore_release(
1163 ui::ET_TOUCH_RELEASED, initial_touch_location, 0, Now());
1164 generator_->Dispatch(&touch_explore_release);
1165 ui::TouchEvent split_tap_release(
1166 ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());
1167 generator_->Dispatch(&split_tap_release);
1168 ui::TouchEvent third_tap_release(
1169 ui::ET_TOUCH_RELEASED, third_touch_location, 2, Now());
1170 generator_->Dispatch(&third_tap_release);
1171
1172 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
1173 ASSERT_EQ(2U, captured_events.size());
1174 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
1175 EXPECT_EQ(initial_touch_location, captured_events[0]->location());
1176 EXPECT_EQ(ui::ET_TOUCH_CANCELLED, captured_events[1]->type());
1177 EXPECT_EQ(initial_touch_location, captured_events[1]->location());
1178 EXPECT_TRUE(IsInNoFingersDownState());
1179 }
1180
1181
1182 TEST_F(TouchExplorationTest, SplitTapLeaveSlop) {
1183 SwitchTouchExplorationMode(true);
1184 gfx::Point first_touch_location(11, 12);
1185 gfx::Point second_touch_location(33, 34);
1186 gfx::Point first_move_location(
1187 first_touch_location.x() + gesture_detector_config_.touch_slop * 3 + 1,
1188 first_touch_location.y());
1189 gfx::Point second_move_location(
1190 second_touch_location.x() + gesture_detector_config_.touch_slop * 3 + 1,
1191 second_touch_location.y());
1192
1193 // Tap and hold at one location, and get a mouse move event in touch explore.
1194 EnterTouchExplorationModeAtLocation(first_touch_location);
1195 ClearCapturedEvents();
1196
1197 // Now tap at a different location for split tap.
1198 ui::TouchEvent split_tap_press(
1199 ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
1200 generator_->Dispatch(&split_tap_press);
1201
1202 // Move the first finger out of slop and release both fingers. The split
1203 // tap should have been cancelled, so a touch press and touch cancel event
1204 // should go through at the last touch exploration location (the first press).
1205 ui::TouchEvent first_touch_move(
1206 ui::ET_TOUCH_MOVED, first_move_location, 0, Now());
1207 generator_->Dispatch(&first_touch_move);
1208 ui::TouchEvent first_touch_release(
1209 ui::ET_TOUCH_RELEASED, first_move_location, 0, Now());
1210 generator_->Dispatch(&first_touch_release);
1211 ui::TouchEvent second_touch_release(
1212 ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());
1213 generator_->Dispatch(&second_touch_release);
1214
1215 std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
1216 ASSERT_EQ(2U, captured_events.size());
1217 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
1218 EXPECT_EQ(first_touch_location, captured_events[0]->location());
1219 EXPECT_EQ(ui::ET_TOUCH_CANCELLED, captured_events[1]->type());
1220 EXPECT_EQ(first_touch_location, captured_events[1]->location());
1221 EXPECT_TRUE(IsInNoFingersDownState());
1222
1223 // Now do the same, but moving the split tap finger out of slop
1224 EnterTouchExplorationModeAtLocation(first_touch_location);
1225 ClearCapturedEvents();
1226 ui::TouchEvent split_tap_press2(
1227 ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
1228 generator_->Dispatch(&split_tap_press2);
1229
1230 // Move the second finger out of slop and release both fingers. The split
1231 // tap should have been cancelled, so a touch press and touch cancel event
1232 // should go through at the last touch exploration location (the first press).
1233 ui::TouchEvent second_touch_move2(
1234 ui::ET_TOUCH_MOVED, second_move_location, 1, Now());
1235 generator_->Dispatch(&second_touch_move2);
1236 ui::TouchEvent first_touch_release2(
1237 ui::ET_TOUCH_RELEASED, first_touch_location, 0, Now());
1238 generator_->Dispatch(&first_touch_release2);
1239 ui::TouchEvent second_touch_release2(
1240 ui::ET_TOUCH_RELEASED, second_move_location, 1, Now());
1241 generator_->Dispatch(&second_touch_release2);
1242
1243 captured_events = GetCapturedLocatedEvents();
1244 ASSERT_EQ(2U, captured_events.size());
1245 EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());
1246 EXPECT_EQ(first_touch_location, captured_events[0]->location());
1247 EXPECT_EQ(ui::ET_TOUCH_CANCELLED, captured_events[1]->type());
1248 EXPECT_EQ(first_touch_location, captured_events[1]->location());
1249 EXPECT_TRUE(IsInNoFingersDownState());
1250 }
1251
1252 // Finger must have moved more than slop, faster than the minimum swipe
1253 // velocity, and before the tap timer fires in order to enter
1254 // GestureInProgress state. Otherwise, if the tap timer fires before the a
1255 // gesture is completed, enter touch exploration.
1256 TEST_F(TouchExplorationTest, EnterGestureInProgressState) {
1257 SwitchTouchExplorationMode(true);
1258 EXPECT_FALSE(IsInTouchToMouseMode());
1259 EXPECT_FALSE(IsInGestureInProgressState());
1260
1261 float distance = gesture_detector_config_.touch_slop + 1;
1262 ui::TouchEvent first_press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 1), 0, Now());
1263 gfx::Point second_location(distance / 2, 1);
1264 gfx::Point third_location(distance, 1);
1265 gfx::Point touch_exploration_location(20, 21);
1266
1267 generator_->Dispatch(&first_press);
1268 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
1269 // Since we are not out of the touch slop yet, we should not be in gesture in
1270 // progress.
1271 generator_->MoveTouch(second_location);
1272 EXPECT_FALSE(IsInTouchToMouseMode());
1273 EXPECT_FALSE(IsInGestureInProgressState());
1274 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
1275
1276 // Once we are out of slop, we should be in GestureInProgress.
1277 generator_->MoveTouch(third_location);
1278 EXPECT_TRUE(IsInGestureInProgressState());
1279 EXPECT_FALSE(IsInTouchToMouseMode());
1280 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1281 ASSERT_EQ(0U, captured_events.size());
1282
1283 // Exit out of gesture mode once grace period is over and enter touch
1284 // exploration. There should be a move when entering touch exploration and
1285 // also for the touch move.
1286 AdvanceSimulatedTimePastTapDelay();
1287 generator_->MoveTouch(touch_exploration_location);
1288 ASSERT_EQ(2U, captured_events.size());
1289 EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());
1290 EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[1]->type());
1291 EXPECT_TRUE(IsInTouchToMouseMode());
1292 EXPECT_FALSE(IsInGestureInProgressState());
1293 }
1294
1295 // A swipe+direction gesture should trigger a Shift+Search+Direction
1296 // keyboard event.
1297 TEST_F(TouchExplorationTest, GestureSwipe) {
1298 SwitchTouchExplorationMode(true);
1299 std::vector<ui::KeyboardCode> directions;
1300 directions.push_back(ui::VKEY_RIGHT);
1301 directions.push_back(ui::VKEY_LEFT);
1302 directions.push_back(ui::VKEY_UP);
1303 directions.push_back(ui::VKEY_DOWN);
1304
1305 // This value was taken from gesture_recognizer_unittest.cc in a swipe
1306 // detector test, since it seems to be about the right amount to get a swipe.
1307 const int kSteps = 15;
1308
1309 // There are gestures supported with up to four fingers.
1310 for (int num_fingers = 1; num_fingers <= 4; num_fingers++) {
1311 std::vector<gfx::Point> start_points;
1312 for (int j = 0; j < num_fingers; j++) {
1313 start_points.push_back(gfx::Point(j * 10 + 100, j * 10 + 200));
1314 }
1315 gfx::Point* start_points_array = &start_points[0];
1316 const float distance = gesture_detector_config_.touch_slop + 1;
1317 // Iterate through each swipe direction for this number of fingers.
1318 for (std::vector<ui::KeyboardCode>::const_iterator it = directions.begin();
1319 it != directions.end();
1320 ++it) {
1321 int move_x = 0;
1322 int move_y = 0;
1323 ui::KeyboardCode direction = *it;
1324 switch (direction) {
1325 case ui::VKEY_RIGHT:
1326 move_x = distance;
1327 break;
1328 case ui::VKEY_LEFT:
1329 move_x = 0 - distance;
1330 break;
1331 case ui::VKEY_UP:
1332 move_y = 0 - distance;
1333 break;
1334 case ui::VKEY_DOWN:
1335 move_y = distance;
1336 break;
1337 default:
1338 return;
1339 }
1340
1341 // A swipe is made when a fling starts
1342 float delta_time =
1343 distance / gesture_detector_config_.maximum_fling_velocity;
1344 // delta_time is in seconds, so we convert to ms.
1345 int delta_time_ms = floor(delta_time * 1000);
1346 generator_->GestureMultiFingerScroll(num_fingers,
1347 start_points_array,
1348 delta_time_ms,
1349 kSteps,
1350 move_x * 2,
1351 move_y * 2);
1352
1353 // The swipe registered and sent the appropriate key events.
1354 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1355 if (num_fingers == 1)
1356 AssertDirectionalNavigationEvents(captured_events, direction);
1357 else {
1358 // Most of the time this is 2 right now, but two of the two finger
1359 // swipes are mapped to chromevox commands which dispatch 6 key events,
1360 // and these will probably be remapped a lot as we're developing.
1361 ASSERT_GE(captured_events.size(), 2U);
1362 std::vector<ui::Event>::size_type i;
1363 for (i = 0; i != captured_events.size(); i++) {
1364 EXPECT_TRUE(captured_events[i]->IsKeyEvent());
1365 }
1366 }
1367 EXPECT_TRUE(IsInNoFingersDownState());
1368 EXPECT_FALSE(IsInTouchToMouseMode());
1369 EXPECT_FALSE(IsInGestureInProgressState());
1370 ClearCapturedEvents();
1371 }
1372 }
1373 }
1374
1375 // Since there are so many permutations, this test is fairly slow. Therefore, it
1376 // is disabled and will be turned on to check during development.
1377
1378 TEST_F(TouchExplorationTest, DISABLED_AllFingerPermutations) {
1379 SwitchTouchExplorationMode(true);
1380 SuppressVLOGs(true);
1381 // We will test all permutations of events from three different fingers
1382 // to ensure that we return to NO_FINGERS_DOWN when fingers have been
1383 // released.
1384 ScopedVector<ui::TouchEvent> all_events;
1385 for (int touch_id = 0; touch_id < 3; touch_id++){
1386 int x = 10*touch_id + 1;
1387 int y = 10*touch_id + 2;
1388 all_events.push_back(new TouchEvent(
1389 ui::ET_TOUCH_PRESSED, gfx::Point(x++, y++), touch_id, Now()));
1390 all_events.push_back(new TouchEvent(
1391 ui::ET_TOUCH_MOVED, gfx::Point(x++, y++), touch_id, Now()));
1392 all_events.push_back(new TouchEvent(
1393 ui::ET_TOUCH_RELEASED, gfx::Point(x, y), touch_id, Now()));
1394 }
1395
1396 // I'm going to explain this algorithm, and use an example in parentheses.
1397 // The example will be all permutations of a b c d.
1398 // There are four letters and 4! = 24 permutations.
1399 const int num_events = all_events.size();
1400 const int num_permutations = Factorial(num_events);
1401
1402 for (int p = 0; p < num_permutations; p++) {
1403 std::vector<ui::TouchEvent*> queued_events = all_events.get();
1404 std::vector<bool> fingers_pressed(3, false);
1405
1406 int current_num_permutations = num_permutations;
1407 for (int events_left = num_events; events_left > 0; events_left--) {
1408 // |p| indexes to each permutation when there are num_permutations
1409 // permutations. (e.g. 0 is abcd, 1 is abdc, 2 is acbd, 3 is acdb...)
1410 // But how do we find the index for the current number of permutations?
1411 // To find the permutation within the part of the sequence we're
1412 // currently looking at, we need a number between 0 and
1413 // |current_num_permutations| - 1.
1414 // (e.g. if we already chose the first letter, there are 3! = 6
1415 // options left, so we do p % 6. So |current_permutation| would go
1416 // from 0 to 5 and then reset to 0 again, for all combinations of
1417 // whichever three letters are remaining, as we loop through the
1418 // permutations)
1419 int current_permutation = p % current_num_permutations;
1420
1421 // Since this is is the total number of permutations starting with
1422 // this event and including future events, there could be multiple
1423 // values of current_permutation that will generate the same event
1424 // in this iteration.
1425 // (e.g. If we chose 'a' but have b c d to choose from, we choose b when
1426 // |current_permutation| = 0, 1 and c when |current_permutation| = 2, 3.
1427 // Note that each letter gets two numbers, which is the next
1428 // current_num_permutations, 2! for the two letters left.)
1429
1430 // Branching out from the first event, there are num_permutations
1431 // permutations, and each value of |p| is associated with one of these
1432 // permutations. However, once the first event is chosen, there
1433 // are now |num_events| - 1 events left, so the number of permutations
1434 // for the rest of the events changes, and will always be equal to
1435 // the factorial of the events_left.
1436 // (e.g. There are 3! = 6 permutations that start with 'a', so if we
1437 // start with 'a' there will be 6 ways to then choose from b c d.)
1438 // So we now set-up for the next iteration by setting
1439 // current_num_permutations to the factorial of the next number of
1440 // events left.
1441 current_num_permutations /= events_left;
1442
1443 // To figure out what current event we want to choose, we integer
1444 // divide the current permutation by the next current_num_permutations.
1445 // (e.g. If there are 4 letters a b c d and 24 permutations, we divide
1446 // by 24/4 = 6. Values 0 to 5 when divided by 6 equals 0, so the first
1447 // 6 permutations start with 'a', and the last 6 will start with 'd'.
1448 // Note that there are 6 that start with 'a' because there are 6
1449 // permutations for the next three letters that follow 'a'.)
1450 int index = current_permutation / current_num_permutations;
1451
1452 ui::TouchEvent* next_dispatch = queued_events[index];
1453 ASSERT_TRUE(next_dispatch != NULL);
1454
1455 // |next_dispatch| has to be put in this container so that its time
1456 // stamp can be changed to this point in the test, when it is being
1457 // dispatched..
1458 EventTestApi test_dispatch(next_dispatch);
1459 test_dispatch.set_time_stamp(Now());
1460 generator_->Dispatch(next_dispatch);
1461 queued_events.erase(queued_events.begin() + index);
1462
1463 // Keep track of what fingers have been pressed, to release
1464 // only those fingers at the end, so the check for being in
1465 // no fingers down can be accurate.
1466 if (next_dispatch->type() == ET_TOUCH_PRESSED) {
1467 fingers_pressed[next_dispatch->touch_id()] = true;
1468 } else if (next_dispatch->type() == ET_TOUCH_RELEASED) {
1469 fingers_pressed[next_dispatch->touch_id()] = false;
1470 }
1471 }
1472 ASSERT_EQ(queued_events.size(), 0u);
1473
1474 // Release fingers recorded as pressed.
1475 for(int j = 0; j < int(fingers_pressed.size()); j++){
1476 if (fingers_pressed[j] == true) {
1477 generator_->ReleaseTouchId(j);
1478 fingers_pressed[j] = false;
1479 }
1480 }
1481 AdvanceSimulatedTimePastPotentialTapDelay();
1482 EXPECT_TRUE(IsInNoFingersDownState());
1483 ClearCapturedEvents();
1484 }
1485 }
1486
1487 // With the simple swipe gestures, if additional fingers are added and the tap
1488 // timer times out, then the state should change to the wait for one finger
1489 // state.
1490 TEST_F(TouchExplorationTest, GestureAddedFinger) {
1491 SwitchTouchExplorationMode(true);
1492 EXPECT_FALSE(IsInTouchToMouseMode());
1493 EXPECT_FALSE(IsInGestureInProgressState());
1494
1495 float distance = gesture_detector_config_.touch_slop + 1;
1496 ui::TouchEvent first_press(
1497 ui::ET_TOUCH_PRESSED, gfx::Point(100, 200), 0, Now());
1498 generator_->Dispatch(&first_press);
1499 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
1500 gfx::Point second_location(100 + distance, 200);
1501 generator_->MoveTouch(second_location);
1502 EXPECT_TRUE(IsInGestureInProgressState());
1503 EXPECT_FALSE(IsInTouchToMouseMode());
1504 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1505 ASSERT_EQ(0U, captured_events.size());
1506
1507 // Generate a second press, but time out past the gesture period so that
1508 // gestures are prevented from continuing to go through.
1509 ui::TouchEvent second_press(
1510 ui::ET_TOUCH_PRESSED, gfx::Point(20, 21), 1, Now());
1511 generator_->Dispatch(&second_press);
1512 AdvanceSimulatedTimePastTapDelay();
1513 EXPECT_FALSE(IsInGestureInProgressState());
1514 EXPECT_FALSE(IsInTouchToMouseMode());
1515 ASSERT_EQ(0U, captured_events.size());
1516 }
1517
1518 TEST_F(TouchExplorationTest, EnterSlideGestureState) {
1519 SwitchTouchExplorationMode(true);
1520 EXPECT_FALSE(IsInTouchToMouseMode());
1521 EXPECT_FALSE(IsInGestureInProgressState());
1522
1523 int window_right = BoundsOfRootWindowInDIP().right();
1524 float distance = gesture_detector_config_.touch_slop + 1;
1525 ui::TouchEvent first_press(
1526 ui::ET_TOUCH_PRESSED, gfx::Point(window_right, 1), 0, Now());
1527 gfx::Point second_location(window_right, 1 + distance / 2);
1528 gfx::Point third_location(window_right, 1 + distance);
1529 gfx::Point fourth_location(window_right, 35);
1530
1531 generator_->Dispatch(&first_press);
1532 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
1533
1534 // Since we haven't moved past slop yet, we should not be in slide gesture.
1535 generator_->MoveTouch(second_location);
1536 EXPECT_FALSE(IsInTouchToMouseMode());
1537 EXPECT_FALSE(IsInGestureInProgressState());
1538 EXPECT_FALSE(IsInSlideGestureState());
1539 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
1540
1541 // Once we are out of slop, we should be in slide gesture since we are along
1542 // the edge of the screen.
1543 generator_->MoveTouch(third_location);
1544 EXPECT_FALSE(IsInGestureInProgressState());
1545 EXPECT_TRUE(IsInSlideGestureState());
1546 EXPECT_FALSE(IsInTouchToMouseMode());
1547
1548 // Now that we are in slide gesture, we can adjust the volume.
1549 generator_->MoveTouch(fourth_location);
1550 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1551 ASSERT_EQ(0U, captured_events.size());
1552
1553 // Since we are at the right edge of the screen, but the sound timer has not
1554 // elapsed, there should have been a sound that fired and a volume
1555 // change.
1556 size_t num_adjust_sounds = delegate_.NumAdjustSounds();
1557 ASSERT_EQ(1U, num_adjust_sounds);
1558 ASSERT_EQ(1U, delegate_.VolumeChanges().size());
1559
1560 // Exit out of slide gesture once touch is lifted, but not before even if the
1561 // grace period is over.
1562 AdvanceSimulatedTimePastPotentialTapDelay();
1563 ASSERT_EQ(0U, captured_events.size());
1564 EXPECT_FALSE(IsInTouchToMouseMode());
1565 EXPECT_FALSE(IsInGestureInProgressState());
1566 EXPECT_TRUE(IsInSlideGestureState());
1567
1568 generator_->ReleaseTouch();
1569 ASSERT_EQ(0U, captured_events.size());
1570 EXPECT_FALSE(IsInTouchToMouseMode());
1571 EXPECT_FALSE(IsInGestureInProgressState());
1572 EXPECT_FALSE(IsInSlideGestureState());
1573 }
1574
1575 // If a press + move occurred outside the boundaries, but within the slop
1576 // boundaries and then moved into the boundaries of an edge, there still should
1577 // not be a slide gesture.
1578 TEST_F(TouchExplorationTest, AvoidEnteringSlideGesture) {
1579 SwitchTouchExplorationMode(true);
1580
1581 gfx::Rect window = BoundsOfRootWindowInDIP();
1582 float distance = gesture_detector_config_.touch_slop + 1;
1583 ui::TouchEvent first_press(
1584 ui::ET_TOUCH_PRESSED,
1585 gfx::Point(window.right() - GetSlopDistanceFromEdge(), 1),
1586 0,
1587 Now());
1588 gfx::Point out_of_slop(window.right() - GetSlopDistanceFromEdge() + distance,
1589 1);
1590 gfx::Point into_boundaries(window.right() - GetMaxDistanceFromEdge() / 2, 1);
1591
1592 generator_->Dispatch(&first_press);
1593 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
1594
1595 generator_->MoveTouch(out_of_slop);
1596 EXPECT_FALSE(IsInTouchToMouseMode());
1597 EXPECT_TRUE(IsInGestureInProgressState());
1598 EXPECT_FALSE(IsInSlideGestureState());
1599 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
1600
1601 // Since we did not start moving while in the boundaries, we should not be in
1602 // slide gestures.
1603 generator_->MoveTouch(into_boundaries);
1604 EXPECT_TRUE(IsInGestureInProgressState());
1605 EXPECT_FALSE(IsInSlideGestureState());
1606 EXPECT_FALSE(IsInTouchToMouseMode());
1607 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1608 ASSERT_EQ(0U, captured_events.size());
1609
1610 generator_->ReleaseTouch();
1611 }
1612
1613 // If the slide gesture begins within the boundaries and then moves
1614 // SlopDistanceFromEdge there should still be a sound change. If the finger
1615 // moves into the center screen, there should no longer be a sound change but it
1616 // should still be in slide gesture. If the finger moves back into the edges
1617 // without lifting, it should start changing sound again.
1618 TEST_F(TouchExplorationTest, TestingBoundaries) {
1619 SwitchTouchExplorationMode(true);
1620
1621 gfx::Rect window = BoundsOfRootWindowInDIP();
1622 gfx::Point initial_press(window.right() - GetMaxDistanceFromEdge() / 2, 1);
1623
1624 gfx::Point center_screen(window.right() / 2, window.bottom() / 2);
1625
1626 ui::TouchEvent first_press(ui::ET_TOUCH_PRESSED, initial_press, 0, Now());
1627 generator_->Dispatch(&first_press);
1628 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
1629 EXPECT_FALSE(IsInGestureInProgressState());
1630 EXPECT_FALSE(IsInSlideGestureState());
1631 EXPECT_FALSE(IsInTouchToMouseMode());
1632
1633 // Move past the touch slop to begin slide gestures.
1634 // + slop + 1 to actually leave slop.
1635 gfx::Point touch_move(
1636 initial_press.x(),
1637 initial_press.y() + gesture_detector_config_.touch_slop + 1);
1638 generator_->MoveTouch(touch_move);
1639 EXPECT_FALSE(IsInGestureInProgressState());
1640 EXPECT_TRUE(IsInSlideGestureState());
1641 EXPECT_FALSE(IsInTouchToMouseMode());
1642 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
1643
1644 // Move the touch into slop boundaries. It should still be in slide gestures
1645 // and adjust the volume.
1646 gfx::Point into_slop_boundaries(
1647 window.right() - GetSlopDistanceFromEdge() / 2, 1);
1648 generator_->MoveTouch(into_slop_boundaries);
1649 EXPECT_FALSE(IsInGestureInProgressState());
1650 EXPECT_TRUE(IsInSlideGestureState());
1651 EXPECT_FALSE(IsInTouchToMouseMode());
1652
1653 // The sound is rate limiting so it only activates every 150ms.
1654 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(200));
1655
1656 size_t num_adjust_sounds = delegate_.NumAdjustSounds();
1657 ASSERT_EQ(1U, num_adjust_sounds);
1658 ASSERT_EQ(1U, delegate_.VolumeChanges().size());
1659
1660 // Move the touch into the center of the window. It should still be in slide
1661 // gestures, but there should not be anymore volume adjustments.
1662 generator_->MoveTouch(center_screen);
1663 EXPECT_FALSE(IsInGestureInProgressState());
1664 EXPECT_TRUE(IsInSlideGestureState());
1665 EXPECT_FALSE(IsInTouchToMouseMode());
1666
1667 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(200));
1668 num_adjust_sounds = delegate_.NumAdjustSounds();
1669 ASSERT_EQ(1U, num_adjust_sounds);
1670 ASSERT_EQ(1U, delegate_.VolumeChanges().size());
1671
1672 // Move the touch back into slop edge distance and volume should be changing
1673 // again, one volume change for each new move.
1674 generator_->MoveTouch(into_slop_boundaries);
1675 EXPECT_FALSE(IsInGestureInProgressState());
1676 EXPECT_TRUE(IsInSlideGestureState());
1677 EXPECT_FALSE(IsInTouchToMouseMode());
1678
1679 generator_->MoveTouch(
1680 gfx::Point(into_slop_boundaries.x() + gesture_detector_config_.touch_slop,
1681 into_slop_boundaries.y()));
1682 simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(200));
1683
1684 num_adjust_sounds = delegate_.NumAdjustSounds();
1685 ASSERT_EQ(2U, num_adjust_sounds);
1686 ASSERT_EQ(3U, delegate_.VolumeChanges().size());
1687
1688 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1689 ASSERT_EQ(0U, captured_events.size());
1690
1691 generator_->ReleaseTouch();
1692 }
1693
1694 // Even if the gesture starts within bounds, if it has not moved past slop
1695 // within the grace period, it should go to touch exploration.
1696 TEST_F(TouchExplorationTest, InBoundariesTouchExploration) {
1697 SwitchTouchExplorationMode(true);
1698
1699 gfx::Rect window = BoundsOfRootWindowInDIP();
1700 gfx::Point initial_press(window.right() - GetMaxDistanceFromEdge() / 2, 1);
1701 ui::TouchEvent first_press(
1702 ui::ET_TOUCH_PRESSED,
1703 initial_press,
1704 0,
1705 Now());
1706 generator_->Dispatch(&first_press);
1707 EXPECT_FALSE(IsInGestureInProgressState());
1708 EXPECT_FALSE(IsInSlideGestureState());
1709 EXPECT_FALSE(IsInTouchToMouseMode());
1710
1711 AdvanceSimulatedTimePastTapDelay();
1712 EXPECT_FALSE(IsInGestureInProgressState());
1713 EXPECT_FALSE(IsInSlideGestureState());
1714 EXPECT_TRUE(IsInTouchToMouseMode());
1715 }
1716
1717 // If two fingers tap the screen at the same time and release before the tap
1718 // timer runs out, a control key event should be sent to silence chromevox.
1719 TEST_F(TouchExplorationTest, TwoFingerTap) {
1720 SwitchTouchExplorationMode(true);
1721
1722 generator_->set_current_location(gfx::Point(101, 102));
1723 generator_->PressTouchId(1);
1724 EXPECT_FALSE(IsInTwoFingerTapState());
1725
1726 generator_->PressTouchId(2);
1727 EXPECT_TRUE(IsInTwoFingerTapState());
1728
1729 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1730 ASSERT_EQ(0U, captured_events.size());
1731
1732 generator_->ReleaseTouchId(1);
1733 EXPECT_TRUE(IsInTwoFingerTapState());
1734 generator_->ReleaseTouchId(2);
1735
1736 // Two key events should have been sent to silence the feedback.
1737 EXPECT_EQ(2U, captured_events.size());
1738 }
1739
1740 // If the fingers are not released before the tap timer runs out, a control
1741 // keyevent is not sent and the state will no longer be in two finger tap.
1742 TEST_F(TouchExplorationTest, TwoFingerTapAndHold) {
1743 SwitchTouchExplorationMode(true);
1744
1745 generator_->PressTouchId(1);
1746 EXPECT_FALSE(IsInTwoFingerTapState());
1747
1748 generator_->PressTouchId(2);
1749 EXPECT_TRUE(IsInTwoFingerTapState());
1750
1751 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1752 ASSERT_EQ(0U, captured_events.size());
1753
1754 AdvanceSimulatedTimePastTapDelay();
1755 // Since the tap delay has elapsed, it should no longer be in two finger tap.
1756 EXPECT_FALSE(IsInTwoFingerTapState());
1757 }
1758
1759 // The next two tests set up two finger swipes to happen. If one of the fingers
1760 // moves out of slop before the tap timer fires, a two finger tap is not made.
1761 // In this first test, the first finger placed will move out of slop.
1762 TEST_F(TouchExplorationTest, TwoFingerTapAndMoveFirstFinger) {
1763 SwitchTouchExplorationMode(true);
1764
1765 // Once one of the fingers leaves slop, it should no longer be in two finger
1766 // tap.
1767 ui::TouchEvent first_press_id_1(
1768 ui::ET_TOUCH_PRESSED, gfx::Point(100, 200), 1, Now());
1769 ui::TouchEvent first_press_id_2(
1770 ui::ET_TOUCH_PRESSED, gfx::Point(110, 200), 2, Now());
1771
1772 ui::TouchEvent slop_move_id_1(
1773 ui::ET_TOUCH_MOVED,
1774 gfx::Point(100 + gesture_detector_config_.touch_slop, 200),
1775 1,
1776 Now());
1777 ui::TouchEvent slop_move_id_2(
1778 ui::ET_TOUCH_MOVED,
1779 gfx::Point(110 + gesture_detector_config_.touch_slop, 200),
1780 2,
1781 Now());
1782
1783 ui::TouchEvent out_slop_id_1(
1784 ui::ET_TOUCH_MOVED,
1785 gfx::Point(100 + gesture_detector_config_.touch_slop + 1, 200),
1786 1,
1787 Now());
1788
1789 // Dispatch the inital presses.
1790 generator_->Dispatch(&first_press_id_1);
1791 EXPECT_FALSE(IsInTwoFingerTapState());
1792 generator_->Dispatch(&first_press_id_2);
1793 EXPECT_TRUE(IsInTwoFingerTapState());
1794
1795 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1796 ASSERT_EQ(0U, captured_events.size());
1797
1798 // The presses have not moved out of slop yet so it should still be in
1799 // TwoFingerTap.
1800 generator_->Dispatch(&slop_move_id_1);
1801 EXPECT_TRUE(IsInTwoFingerTapState());
1802 generator_->Dispatch(&slop_move_id_2);
1803 EXPECT_TRUE(IsInTwoFingerTapState());
1804
1805 // Once one of the fingers moves out of slop, we are no longer in
1806 // TwoFingerTap.
1807 generator_->Dispatch(&out_slop_id_1);
1808 EXPECT_FALSE(IsInTwoFingerTapState());
1809 }
1810
1811 // Similar test to the previous test except the second finger placed will be the
1812 // one to move out of slop.
1813 TEST_F(TouchExplorationTest, TwoFingerTapAndMoveSecondFinger) {
1814 SwitchTouchExplorationMode(true);
1815
1816 // Once one of the fingers leaves slop, it should no longer be in two finger
1817 // tap.
1818 ui::TouchEvent first_press_id_1(
1819 ui::ET_TOUCH_PRESSED, gfx::Point(100, 200), 1, Now());
1820 ui::TouchEvent first_press_id_2(
1821 ui::ET_TOUCH_PRESSED, gfx::Point(110, 200), 2, Now());
1822
1823 ui::TouchEvent out_slop_id_2(
1824 ui::ET_TOUCH_MOVED,
1825 gfx::Point(100 + gesture_detector_config_.touch_slop + 1, 200),
1826 1,
1827 Now());
1828
1829 generator_->Dispatch(&first_press_id_1);
1830 EXPECT_FALSE(IsInTwoFingerTapState());
1831
1832 generator_->Dispatch(&first_press_id_2);
1833 EXPECT_TRUE(IsInTwoFingerTapState());
1834
1835 const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
1836 ASSERT_EQ(0U, captured_events.size());
1837
1838 generator_->Dispatch(&out_slop_id_2);
1839 EXPECT_FALSE(IsInTwoFingerTapState());
1840 }
1841
1842 // Corner passthrough should turn on if the user first holds down on either the
1843 // right or left corner past a delay and then places a finger anywhere else on
1844 // the screen.
1845 TEST_F(TouchExplorationTest, ActivateLeftCornerPassthrough) {
1846 SwitchTouchExplorationMode(true);
1847
1848 gfx::Rect window = BoundsOfRootWindowInDIP();
1849 gfx::Point left_corner(10, window.bottom() - GetMaxDistanceFromEdge() / 2);
1850 AssertCornerPassthroughWorking(left_corner);
1851 }
1852
1853 TEST_F(TouchExplorationTest, ActivateRightCornerPassthrough) {
1854 SwitchTouchExplorationMode(true);
1855
1856 gfx::Rect window = BoundsOfRootWindowInDIP();
1857 gfx::Point right_corner(window.right() - GetMaxDistanceFromEdge() / 2,
1858 window.bottom() - GetMaxDistanceFromEdge() / 2);
1859 AssertCornerPassthroughWorking(right_corner);
1860 }
1861
1862 // Earcons should play if the user slides off the screen or enters the screen
1863 // from the edge.
1864 TEST_F(TouchExplorationTest, EnterEarconPlays) {
1865 SwitchTouchExplorationMode(true);
1866
1867 gfx::Rect window = BoundsOfRootWindowInDIP();
1868
1869 gfx::Point upper_left_corner(0, 0);
1870 gfx::Point upper_right_corner(window.right(), 0);
1871 gfx::Point lower_left_corner(0, window.bottom());
1872 gfx::Point lower_right_corner(window.right(), window.bottom());
1873 gfx::Point left_edge(0, 30);
1874 gfx::Point right_edge(window.right(), 30);
1875 gfx::Point top_edge(30, 0);
1876 gfx::Point bottom_edge(30, window.bottom());
1877
1878 std::vector<gfx::Point> locations;
1879 locations.push_back(upper_left_corner);
1880 locations.push_back(upper_right_corner);
1881 locations.push_back(lower_left_corner);
1882 locations.push_back(lower_right_corner);
1883 locations.push_back(left_edge);
1884 locations.push_back(right_edge);
1885 locations.push_back(top_edge);
1886 locations.push_back(bottom_edge);
1887
1888 for (std::vector<gfx::Point>::const_iterator point = locations.begin();
1889 point != locations.end();
1890 ++point) {
1891 ui::TouchEvent touch_event(ui::ET_TOUCH_PRESSED, *point, 1, Now());
1892
1893 generator_->Dispatch(&touch_event);
1894 ASSERT_EQ(1U, delegate_.NumEnterScreenSounds());
1895 generator_->ReleaseTouchId(1);
1896 delegate_.ResetCountersToZero();
1897 }
1898 }
1899
1900 TEST_F(TouchExplorationTest, ExitEarconPlays) {
1901 SwitchTouchExplorationMode(true);
1902
1903 // On the device, it cannot actually tell if the finger has left the screen or
1904 // not. If the finger has left the screen, it reads it as a release that
1905 // occurred very close to the edge of the screen even if the finger is still
1906 // technically touching the moniter. To simulate this, a release that occurs
1907 // close to the edge is dispatched.
1908 gfx::Point initial_press(100, 200);
1909 gfx::Rect window = BoundsOfRootWindowInDIP();
1910
1911 gfx::Point upper_left_corner(0, 0);
1912 gfx::Point upper_right_corner(window.right(), 0);
1913 gfx::Point lower_left_corner(0, window.bottom());
1914 gfx::Point lower_right_corner(window.right(), window.bottom());
1915 gfx::Point left_edge(0, 30);
1916 gfx::Point right_edge(window.right(), 30);
1917 gfx::Point top_edge(30, 0);
1918 gfx::Point bottom_edge(30, window.bottom());
1919
1920 std::vector<gfx::Point> locations;
1921 locations.push_back(upper_left_corner);
1922 locations.push_back(upper_right_corner);
1923 locations.push_back(lower_left_corner);
1924 locations.push_back(lower_right_corner);
1925 locations.push_back(left_edge);
1926 locations.push_back(right_edge);
1927 locations.push_back(top_edge);
1928 locations.push_back(bottom_edge);
1929
1930 for (std::vector<gfx::Point>::const_iterator point = locations.begin();
1931 point != locations.end();
1932 ++point) {
1933 generator_->PressTouch();
1934 generator_->MoveTouch(initial_press);
1935 generator_->MoveTouch(*point);
1936 generator_->ReleaseTouch();
1937 ASSERT_EQ(1U, delegate_.NumExitScreenSounds());
1938 delegate_.ResetCountersToZero();
1939 }
1940 }
1941
1942 } // namespace ui