ui/chromeos/touch_exploration_controller_unittest.cc - Issue 330763007: Swipe Gestures for Accessibility

Unified Diff: ui/chromeos/touch_exploration_controller_unittest.cc

Issue 330763007: Swipe Gestures for Accessibility (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@gesture-vlogs

Patch Set: Addressed Alice's comments and changed how gesture events are processed. Created 6 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: ui/chromeos/touch_exploration_controller_unittest.cc

diff --git a/ui/chromeos/touch_exploration_controller_unittest.cc b/ui/chromeos/touch_exploration_controller_unittest.cc

index 10da4b1f3a7f5a272d86d88d1a10daae2f1d1e22..6b3ecae7926a46d0944099b2c991df180a7e5fee 100644

--- a/ui/chromeos/touch_exploration_controller_unittest.cc

+++ b/ui/chromeos/touch_exploration_controller_unittest.cc

@@ -13,6 +13,7 @@

#include "ui/aura/window.h"

#include "ui/events/event.h"

#include "ui/events/event_utils.h"

+#include "ui/events/gestures/gesture_provider_aura.h"

#include "ui/gfx/geometry/point.h"

#include "ui/gl/gl_implementation.h"

#include "ui/gl/gl_surface.h"

@@ -20,7 +21,7 @@

namespace ui {

namespace {

-// Records all mouse and touch events.

+// Records all mouse, touch, gesture, and key events.

class EventCapturer : public ui::EventHandler {

public:

EventCapturer() {}

@@ -37,6 +38,11 @@ class EventCapturer : public ui::EventHandler {

} else if (event->IsTouchEvent()) {

events_.push_back(

new ui::TouchEvent(static_cast<ui::TouchEvent&>(*event)));

+ } else if (event->IsGestureEvent()) {

+ events_.push_back(

+ new ui::GestureEvent(static_cast<ui::GestureEvent&>(*event)));

+ } else if (event->IsKeyEvent()) {

+ events_.push_back(new ui::KeyEvent(static_cast<ui::KeyEvent&>(*event)));

} else {

return;

}

@@ -47,12 +53,11 @@ class EventCapturer : public ui::EventHandler {

// exit early with a sensible error rather than letting the test time out.

ASSERT_LT(events_.size(), 100u);

}

- const ScopedVector<ui::LocatedEvent>& captured_events() const {

- return events_;

- }

+ const ScopedVector<ui::Event>& captured_events() const { return events_; }

private:

- ScopedVector<ui::LocatedEvent> events_;

+ ScopedVector<ui::Event> events_;

DISALLOW_COPY_AND_ASSIGN(EventCapturer);

};

@@ -88,13 +93,26 @@ class TouchExplorationTest : public aura::test::AuraTestBase {

protected:

aura::client::CursorClient* cursor_client() { return cursor_client_.get(); }

- const ScopedVector<ui::LocatedEvent>& GetCapturedEvents() {

+ const ScopedVector<ui::Event>& GetCapturedEvents() {

return event_capturer_.captured_events();

}

- std::vector<ui::LocatedEvent*> GetCapturedEventsOfType(int type) {

- const ScopedVector<ui::LocatedEvent>& all_events = GetCapturedEvents();

- std::vector<ui::LocatedEvent*> events;

+ std::vector<ui::LocatedEvent*> GetCapturedLocatedEvents() {

+ const ScopedVector<ui::Event>& all_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> located_events;

+ for (size_t i = 0; i < all_events.size(); ++i) {

+ if (all_events[i]->IsMouseEvent() ||

+ all_events[i]->IsTouchEvent() ||

+ all_events[i]->IsGestureEvent()) {

+ located_events.push_back(static_cast<ui::LocatedEvent*>(all_events[i]));

+ }

+ return located_events;

+ }

+ std::vector<ui::Event*> GetCapturedEventsOfType(int type) {

+ const ScopedVector<ui::Event>& all_events = GetCapturedEvents();

+ std::vector<ui::Event*> events;

for (size_t i = 0; i < all_events.size(); ++i) {

if (type == all_events[i]->type())

events.push_back(all_events[i]);

@@ -102,6 +120,16 @@ class TouchExplorationTest : public aura::test::AuraTestBase {

return events;

}

+ std::vector<ui::LocatedEvent*> GetCapturedLocatedEventsOfType(int type) {

+ std::vector<ui::LocatedEvent*> located_events = GetCapturedLocatedEvents();

+ std::vector<ui::LocatedEvent*> events;

+ for (size_t i = 0; i < located_events.size(); ++i) {

+ if (type == located_events[i]->type())

+ events.push_back(located_events[i]);

+ }

+ return events;

+ }

void ClearCapturedEvents() {

event_capturer_.Reset();

}

@@ -154,6 +182,11 @@ class TouchExplorationTest : public aura::test::AuraTestBase {

return touch_exploration_controller_->IsInNoFingersDownStateForTesting();

}

+ bool IsInGestureInProgressState() {

+ return touch_exploration_controller_

+ ->IsInGestureInProgressStateForTesting();

+ }

base::TimeDelta Now() {

// This is the same as what EventTimeForNow() does, but here we do it

// with our simulated clock.

@@ -201,16 +234,63 @@ void ConfirmEventsAreMouseAndEqual(ui::Event* e1, ui::Event* e2) {

EXPECT_EQ(mouse_event1->flags(), mouse_event2->flags());

}

+// Executes a number of assertions to confirm that |e1| and |e2| are key events

+// and are equal to each other.

+void ConfirmEventsAreKeyAndEqual(ui::Event* e1, ui::Event* e2) {

+ ASSERT_TRUE(e1->IsKeyEvent());

+ ASSERT_TRUE(e2->IsKeyEvent());

+ ui::KeyEvent* key_event1 = static_cast<ui::KeyEvent*>(e1);

+ ui::KeyEvent* key_event2 = static_cast<ui::KeyEvent*>(e2);

+ EXPECT_EQ(key_event1->type(), key_event2->type());

+ EXPECT_EQ(key_event1->key_code(), key_event2->key_code());

+ EXPECT_EQ(key_event1->code(), key_event2->code());

+ EXPECT_EQ(key_event1->flags(), key_event2->flags());

#define CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(e1, e2) \

ASSERT_NO_FATAL_FAILURE(ConfirmEventsAreTouchAndEqual(e1, e2))

#define CONFIRM_EVENTS_ARE_MOUSE_AND_EQUAL(e1, e2) \

ASSERT_NO_FATAL_FAILURE(ConfirmEventsAreMouseAndEqual(e1, e2))

+#define CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(e1, e2) \

+ ASSERT_NO_FATAL_FAILURE(ConfirmEventsAreKeyAndEqual(e1, e2))

// TODO(mfomitchev): Need to investigate why we don't get mouse enter/exit

// events when running these tests as part of ui_unittests. We do get them when

// the tests are run as part of ash unit tests.

+// If a swipe has been successfully completed, then six key events will be

+// dispatched that correspond to shift+search+direction

+void AssertDirectionalNavigationEvents(const ScopedVector<ui::Event>& events,

+ ui::KeyboardCode direction) {

+ ASSERT_EQ(6U, events.size());

+ ui::KeyEvent shift_pressed(

aboxhall 2014/07/02 18:00:14 You could pull all these KeyEvents out as constant

lisayin 2014/07/02 18:21:05 ConfirmEvents...() doesn't take constant Events.

+ ui::ET_KEY_PRESSED, ui::VKEY_SHIFT, ui::EF_SHIFT_DOWN, false);

+ ui::KeyEvent search_pressed(

+ ui::ET_KEY_PRESSED, ui::VKEY_LWIN, ui::EF_SHIFT_DOWN, false);

+ ui::KeyEvent direction_pressed(

+ ui::ET_KEY_PRESSED, direction, ui::EF_SHIFT_DOWN, false);

+ ui::KeyEvent direction_released(

+ ui::ET_KEY_RELEASED, direction, ui::EF_SHIFT_DOWN, false);

+ ui::KeyEvent search_released(

+ ui::ET_KEY_RELEASED, VKEY_LWIN, ui::EF_SHIFT_DOWN, false);

+ ui::KeyEvent shift_released(

+ ui::ET_KEY_RELEASED, ui::VKEY_SHIFT, ui::EF_NONE, false);

+ CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&shift_pressed,

+ static_cast<ui::KeyEvent*>(events[0]));

aboxhall 2014/07/02 18:00:13 You shouldn't need to static_cast these since Conf

lisayin 2014/07/02 18:21:05 Done.

+ CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&search_pressed,

+ static_cast<ui::KeyEvent*>(events[1]));

+ CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&direction_pressed,

+ static_cast<ui::KeyEvent*>(events[2]));

+ CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&direction_released,

+ static_cast<ui::KeyEvent*>(events[3]));

+ CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&search_released,

+ static_cast<ui::KeyEvent*>(events[4]));

+ CONFIRM_EVENTS_ARE_KEY_AND_EQUAL(&shift_released,

+ static_cast<ui::KeyEvent*>(events[5]));

TEST_F(TouchExplorationTest, EntersTouchToMouseModeAfterPressAndDelay) {

SwitchTouchExplorationMode(true);

EXPECT_FALSE(IsInTouchToMouseMode());

@@ -231,6 +311,7 @@ TEST_F(TouchExplorationTest, EntersTouchToMouseModeAfterMoveOutsideSlop) {

EXPECT_FALSE(IsInTouchToMouseMode());

generator_->MoveTouch(gfx::Point(11, 12 + half_slop));

EXPECT_FALSE(IsInTouchToMouseMode());

+ AdvanceSimulatedTimePastTapDelay();

generator_->MoveTouch(gfx::Point(11 + slop + 1, 12));

EXPECT_TRUE(IsInTouchToMouseMode());

}

@@ -244,7 +325,7 @@ TEST_F(TouchExplorationTest, OneFingerTap) {

AdvanceSimulatedTimePastTapDelay();

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(1U, events.size());

EXPECT_EQ(location, events[0]->location());

@@ -274,7 +355,7 @@ TEST_F(TouchExplorationTest, ActualMouseMovesUnaffected) {

AdvanceSimulatedTimePastTapDelay();

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(4U, events.size());

EXPECT_EQ(location_start, events[0]->location());

@@ -319,7 +400,7 @@ TEST_F(TouchExplorationTest, TurnOnMidTouch) {

generator_->Dispatch(&touch_move);

EXPECT_TRUE(cursor_client()->IsCursorVisible());

EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(1u, captured_events.size());

CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_move);

ClearCapturedEvents();

@@ -328,7 +409,8 @@ TEST_F(TouchExplorationTest, TurnOnMidTouch) {

generator_->PressTouchId(2);

AdvanceSimulatedTimePastTapDelay();

EXPECT_TRUE(IsInTouchToMouseMode());

- ScopedVector<ui::LocatedEvent>::const_iterator it;

+ captured_events = GetCapturedLocatedEvents();

+ std::vector<ui::LocatedEvent*>::const_iterator it;

for (it = captured_events.begin(); it != captured_events.end(); ++it) {

if ((*it)->type() == ui::ET_MOUSE_MOVED)

break;

@@ -342,6 +424,7 @@ TEST_F(TouchExplorationTest, TurnOnMidTouch) {

Now());

generator_->Dispatch(&touch_release);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(1u, captured_events.size());

CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_release);

ClearCapturedEvents();

@@ -350,7 +433,7 @@ TEST_F(TouchExplorationTest, TurnOnMidTouch) {

generator_->MoveTouchId(gfx::Point(13, 14), 2);

generator_->ReleaseTouchId(2);

AdvanceSimulatedTimePastTapDelay();

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(2u, captured_events.size());

EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());

EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[1]->type());

@@ -367,7 +450,7 @@ TEST_F(TouchExplorationTest, TimerFiresLateDuringTouchExploration) {

simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));

generator_->PressTouchId(2);

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(1U, events.size());

EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);

EXPECT_TRUE(events[0]->flags() & ui::EF_TOUCH_ACCESSIBILITY);

@@ -400,7 +483,7 @@ TEST_F(TouchExplorationTest, TimerFiresLateAfterTap) {

AdvanceSimulatedTimePastTapDelay();

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(2U, events.size());

EXPECT_EQ(location0, events[0]->location());

EXPECT_TRUE(events[0]->flags() & ui::EF_IS_SYNTHESIZED);

@@ -424,7 +507,7 @@ TEST_F(TouchExplorationTest, DoubleTap) {

AdvanceSimulatedTimePastTapDelay();

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(1U, events.size());

EXPECT_EQ(tap_location, events[0]->location());

@@ -442,7 +525,7 @@ TEST_F(TouchExplorationTest, DoubleTap) {

generator_->PressTouch();

generator_->ReleaseTouch();

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(2U, captured_events.size());

EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());

EXPECT_EQ(tap_location, captured_events[0]->location());

@@ -465,7 +548,7 @@ TEST_F(TouchExplorationTest, DoubleTapLongPress) {

AdvanceSimulatedTimePastTapDelay();

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(1U, events.size());

EXPECT_EQ(tap_location, events[0]->location());

@@ -487,7 +570,7 @@ TEST_F(TouchExplorationTest, DoubleTapLongPress) {

simulated_clock_->Advance(gesture_detector_config_.longpress_timeout);

generator_->ReleaseTouch();

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(2U, captured_events.size());

EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());

EXPECT_EQ(tap_location, captured_events[0]->location());

@@ -509,6 +592,8 @@ TEST_F(TouchExplorationTest, SingleTap) {

gfx::Point initial_location(11, 12);

generator_->set_current_location(initial_location);

generator_->PressTouch();

+ AdvanceSimulatedTimePastTapDelay();

+ ClearCapturedEvents();

// Move to another location for single tap

gfx::Point tap_location(22, 23);

@@ -523,7 +608,7 @@ TEST_F(TouchExplorationTest, SingleTap) {

generator_->PressTouch();

generator_->ReleaseTouch();

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(4U, captured_events.size());

EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());

EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[1]->type());

@@ -549,7 +634,7 @@ TEST_F(TouchExplorationTest, DoubleTapNoTouchExplore) {

generator_->PressTouch();

generator_->ReleaseTouch();

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(0U, captured_events.size());

}

@@ -564,7 +649,7 @@ TEST_F(TouchExplorationTest, SplitTap) {

// Tap and hold at one location, and get a mouse move event in touch explore.

EnterTouchExplorationModeAtLocation(initial_touch_location);

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(1U, events.size());

EXPECT_EQ(initial_touch_location, events[0]->location());

@@ -579,12 +664,13 @@ TEST_F(TouchExplorationTest, SplitTap) {

ui::TouchEvent split_tap_press(

ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());

generator_->Dispatch(&split_tap_press);

+ EXPECT_FALSE(IsInGestureInProgressState());

ui::TouchEvent split_tap_release(

ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());

generator_->Dispatch(&split_tap_release);

EXPECT_FALSE(IsInNoFingersDownState());

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(2U, captured_events.size());

EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());

EXPECT_EQ(initial_touch_location, captured_events[0]->location());

@@ -606,7 +692,7 @@ TEST_F(TouchExplorationTest, SplitTapRelease) {

EnterTouchExplorationModeAtLocation(initial_touch_location);

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(1U, events.size());

ClearCapturedEvents();

@@ -626,7 +712,7 @@ TEST_F(TouchExplorationTest, SplitTapRelease) {

generator_->Dispatch(&split_tap_release);

EXPECT_TRUE(IsInNoFingersDownState());

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(2U, captured_events.size());

EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());

EXPECT_EQ(initial_touch_location, captured_events[0]->location());

@@ -646,7 +732,7 @@ TEST_F(TouchExplorationTest, SplitTapLongPress) {

// Tap and hold at one location, and get a mouse move event in touch explore.

EnterTouchExplorationModeAtLocation(initial_touch_location);

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(1U, events.size());

ClearCapturedEvents();

@@ -664,7 +750,7 @@ TEST_F(TouchExplorationTest, SplitTapLongPress) {

generator_->Dispatch(&split_tap_release);

EXPECT_FALSE(IsInNoFingersDownState());

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(2U, captured_events.size());

EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());

EXPECT_EQ(initial_touch_location, captured_events[0]->location());

@@ -690,7 +776,7 @@ TEST_F(TouchExplorationTest, SplitTapReleaseLongPress) {

// Tap and hold at one location, and get a mouse move event in touch explore.

EnterTouchExplorationModeAtLocation(initial_touch_location);

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(1U, events.size());

ClearCapturedEvents();

@@ -711,7 +797,7 @@ TEST_F(TouchExplorationTest, SplitTapReleaseLongPress) {

generator_->Dispatch(&split_tap_release);

EXPECT_TRUE(IsInTouchToMouseMode());

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(2U, captured_events.size());

EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());

EXPECT_EQ(initial_touch_location, captured_events[0]->location());

@@ -733,7 +819,7 @@ TEST_F(TouchExplorationTest, SplitTapLongPressMultiFinger) {

EnterTouchExplorationModeAtLocation(initial_touch_location);

std::vector<ui::LocatedEvent*> events =

- GetCapturedEventsOfType(ui::ET_MOUSE_MOVED);

+ GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);

ASSERT_EQ(1U, events.size());

EXPECT_EQ(initial_touch_location, events[0]->location());

@@ -765,7 +851,7 @@ TEST_F(TouchExplorationTest, SplitTapLongPressMultiFinger) {

ui::ET_TOUCH_RELEASED, third_touch_location, 2, Now());

generator_->Dispatch(&third_tap_release);

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(2U, captured_events.size());

EXPECT_EQ(ui::ET_TOUCH_PRESSED, captured_events[0]->type());

EXPECT_EQ(initial_touch_location, captured_events[0]->location());

@@ -785,7 +871,7 @@ TEST_F(TouchExplorationTest, TwoToOneFingerReleaseSecond) {

gfx::Point first_touch_location = gfx::Point(7, 7);

gfx::Point second_touch_location = gfx::Point(10, 11);

EnterTwoToOne(first_touch_location, second_touch_location);

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 1u);

ClearCapturedEvents();

@@ -804,7 +890,8 @@ TEST_F(TouchExplorationTest, TwoToOneFingerReleaseSecond) {

// finger is touching.

gfx::Point first_touch_move_location = gfx::Point(15, 16);

generator_->MoveTouchId(first_touch_move_location, 0);

- EXPECT_EQ(0u, GetCapturedEvents().size());

+ captured_events = GetCapturedLocatedEvents();

+ EXPECT_EQ(0u, captured_events.size());

EXPECT_TRUE(cursor_client()->IsCursorVisible());

EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());

@@ -814,6 +901,7 @@ TEST_F(TouchExplorationTest, TwoToOneFingerReleaseSecond) {

ui::ET_TOUCH_RELEASED, second_touch_move_location, 1, Now());

generator_->Dispatch(&second_touch_release);

EXPECT_FALSE(IsInTouchToMouseMode());

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 1u);

ClearCapturedEvents();

@@ -825,7 +913,7 @@ TEST_F(TouchExplorationTest, TwoToOneFingerReleaseSecond) {

ui::TouchEvent first_touch_release(

ui::ET_TOUCH_RELEASED, first_touch_move_location, 0, Now());

generator_->Dispatch(&first_touch_release);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 0u);

EXPECT_TRUE(IsInNoFingersDownState());

}

@@ -836,7 +924,7 @@ TEST_F(TouchExplorationTest, TwoToOneFingerRelaseFirst) {

gfx::Point first_touch_location = gfx::Point(11,12);

gfx::Point second_touch_location = gfx::Point(21, 22);

EnterTwoToOne(first_touch_location, second_touch_location);

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 1u);

ClearCapturedEvents();

@@ -847,6 +935,7 @@ TEST_F(TouchExplorationTest, TwoToOneFingerRelaseFirst) {

ui::TouchEvent first_touch_release(

ui::ET_TOUCH_RELEASED, first_touch_location, 0, Now());

generator_->Dispatch(&first_touch_release);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 1u);

ClearCapturedEvents();

@@ -859,6 +948,7 @@ TEST_F(TouchExplorationTest, TwoToOneFingerRelaseFirst) {

ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());

generator_->Dispatch(&second_touch_release);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 0u);

EXPECT_TRUE(IsInNoFingersDownState());

}

@@ -866,11 +956,12 @@ TEST_F(TouchExplorationTest, TwoToOneFingerRelaseFirst) {

// Placing three fingers should start passthrough, and all fingers should

// continue to be passed through until the last one is released.

TEST_F(TouchExplorationTest, Passthrough) {

- const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();

+ std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();

gfx::Point first_touch_location = gfx::Point(11,12);

gfx::Point second_touch_location = gfx::Point(21, 22);

EnterTwoToOne(first_touch_location, second_touch_location);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 1u);

gfx::Point third_touch_location = gfx::Point(31, 32);

@@ -878,6 +969,7 @@ TEST_F(TouchExplorationTest, Passthrough) {

ui::ET_TOUCH_PRESSED, third_touch_location, 2, Now());

generator_->Dispatch(&third_touch_press);

// Now all fingers are registered as pressed.

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 3u);

ClearCapturedEvents();

@@ -894,6 +986,7 @@ TEST_F(TouchExplorationTest, Passthrough) {

generator_->Dispatch(&first_touch_first_move);

generator_->Dispatch(&second_touch_first_move);

generator_->Dispatch(&third_touch_first_move);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 3u);

EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[0]->type());

EXPECT_EQ(first_touch_location, captured_events[0]->location());

@@ -908,6 +1001,7 @@ TEST_F(TouchExplorationTest, Passthrough) {

ui::TouchEvent third_touch_release(

ui::ET_TOUCH_RELEASED, third_touch_location, 2, Now());

generator_->Dispatch(&third_touch_release);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 1u);

ClearCapturedEvents();

first_touch_location = gfx::Point(15, 16);

@@ -918,6 +1012,7 @@ TEST_F(TouchExplorationTest, Passthrough) {

ui::ET_TOUCH_MOVED, second_touch_location, 1, Now());

generator_->Dispatch(&first_touch_second_move);

generator_->Dispatch(&second_touch_second_move);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 2u);

EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[0]->type());

EXPECT_EQ(first_touch_location, captured_events[0]->location());

@@ -930,12 +1025,14 @@ TEST_F(TouchExplorationTest, Passthrough) {

ui::TouchEvent second_touch_release(

ui::ET_TOUCH_RELEASED, second_touch_location, 1, Now());

generator_->Dispatch(&second_touch_release);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 1u);

ClearCapturedEvents();

first_touch_location = gfx::Point(17, 18);

ui::TouchEvent first_touch_third_move(

ui::ET_TOUCH_MOVED, first_touch_location, 0, Now());

generator_->Dispatch(&first_touch_third_move);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 1u);

EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[0]->type());

EXPECT_EQ(first_touch_location, captured_events[0]->location());

@@ -944,8 +1041,141 @@ TEST_F(TouchExplorationTest, Passthrough) {

ui::TouchEvent first_touch_release(

ui::ET_TOUCH_RELEASED, first_touch_location, 0, Now());

generator_->Dispatch(&first_touch_release);

+ captured_events = GetCapturedLocatedEvents();

ASSERT_EQ(captured_events.size(), 1u);

EXPECT_TRUE(IsInNoFingersDownState());

}

+// Finger must have moved more than slop, faster than the minimum swipe

+// velocity, and before the tap timer fires in order to enter

+// GestureInProgress state. Otherwise, if the tap timer fires before the a

+// gesture is completed, enter touch exploration.

+TEST_F(TouchExplorationTest, EnterGestureInProgressState) {

+ SwitchTouchExplorationMode(true);

+ EXPECT_FALSE(IsInTouchToMouseMode());

+ EXPECT_FALSE(IsInGestureInProgressState());

+ float delta_distance = gesture_detector_config_.touch_slop + 1;

+ ui::TouchEvent first_press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 1), 0, Now());

aboxhall 2014/07/02 18:00:14 While it's usually a good idea to initialize thing

lisayin 2014/07/02 18:21:04 Done.

+ generator_->Dispatch(&first_press);

+ simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));

+ // Since we are not out of the touch slop, we should not be in gesture in

+ // progress.

+ gfx::Point second_location(delta_distance / 2, 1);

+ generator_->MoveTouch(second_location);

+ EXPECT_FALSE(IsInTouchToMouseMode());

+ EXPECT_FALSE(IsInGestureInProgressState());

+ gfx::Point third_location(delta_distance, 1);

+ simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));

+ generator_->MoveTouch(third_location);

+ EXPECT_TRUE(IsInGestureInProgressState());

+ EXPECT_FALSE(IsInTouchToMouseMode());

+ const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();

+ ASSERT_EQ(0U, captured_events.size());

+ // Exit out of gesture mode once grace period is over and enter touch

+ // exploration.

+ AdvanceSimulatedTimePastTapDelay();

+ ASSERT_EQ(1U, captured_events.size());

+ EXPECT_EQ(ui::ET_MOUSE_MOVED, captured_events[0]->type());

+ EXPECT_TRUE(IsInTouchToMouseMode());

+ EXPECT_FALSE(IsInGestureInProgressState());

+// A swipe+direction gesture should trigger a Shift+Search+Direction

+// keyboard event.

+TEST_F(TouchExplorationTest, GestureSwipe) {

+ SwitchTouchExplorationMode(true);

+ std::vector<ui::KeyboardCode> directions;

+ directions.push_back(ui::VKEY_RIGHT);

+ directions.push_back(ui::VKEY_LEFT);

+ directions.push_back(ui::VKEY_UP);

+ directions.push_back(ui::VKEY_DOWN);

+ for (std::vector<ui::KeyboardCode>::const_iterator it = directions.begin();

+ it != directions.end();

+ ++it) {

+ int x = 30;

+ int y = 31;

+ ui::TouchEvent origin(ui::ET_TOUCH_PRESSED, gfx::Point(x, y), 0, Now());

+ generator_->Dispatch(&origin);

+ ui::KeyboardCode direction = *it;

+ float delta_distance = gesture_detector_config_.touch_slop + 1;

aboxhall 2014/07/02 18:00:14 distance? (and everywhere else)

lisayin 2014/07/02 18:21:04 Done.

+ scoped_ptr<gfx::Point> swipe;

+ switch (direction) {

+ case ui::VKEY_RIGHT:

+ swipe.reset(new gfx::Point(x + delta_distance, y));

+ break;

+ case ui::VKEY_LEFT:

+ swipe.reset(new gfx::Point(x - delta_distance, y));

+ break;

+ case ui::VKEY_UP:

+ swipe.reset(new gfx::Point(x, y - delta_distance));

+ break;

+ case ui::VKEY_DOWN:

+ swipe.reset(new gfx::Point(x, y + delta_distance));

+ break;

+ default:

+ return;

+ }

+ // A swipe is made when a fling starts

+ float delta_time =

+ delta_distance / gesture_detector_config_.maximum_fling_velocity;

+ simulated_clock_->Advance(base::TimeDelta::FromSecondsD(delta_time));

+ generator_->MoveTouch(*swipe);

+ EXPECT_TRUE(IsInGestureInProgressState());

+ EXPECT_FALSE(IsInTouchToMouseMode());

+ const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();

+ ASSERT_EQ(0U, captured_events.size());

+ generator_->ReleaseTouch();

+ // The swipe registered and sent the appropriate key events.

+ AssertDirectionalNavigationEvents(captured_events, direction);

+ EXPECT_TRUE(IsInNoFingersDownState());

+ EXPECT_FALSE(IsInTouchToMouseMode());

+ EXPECT_FALSE(IsInGestureInProgressState());

+ ClearCapturedEvents();

+ }

+// With the simple swipe gestures, if additional fingers are added, then the

+// state should change to passthrough.

+TEST_F(TouchExplorationTest, FromGestureToPassthrough) {

+ SwitchTouchExplorationMode(true);

+ EXPECT_FALSE(IsInTouchToMouseMode());

+ EXPECT_FALSE(IsInGestureInProgressState());

+ float delta_distance = gesture_detector_config_.touch_slop + 1;

+ ui::TouchEvent first_press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 1), 0, Now());

+ generator_->Dispatch(&first_press);

+ simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));

+ gfx::Point second_location(delta_distance, 1);

+ generator_->MoveTouch(second_location);

+ EXPECT_TRUE(IsInGestureInProgressState());

+ EXPECT_FALSE(IsInTouchToMouseMode());

+ const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();

+ ASSERT_EQ(0U, captured_events.size());

+ // Generate a second press that should go through as is.

+ ui::TouchEvent second_press(

+ ui::ET_TOUCH_PRESSED, gfx::Point(20, 21), 1, Now());

+ generator_->Dispatch(&second_press);

+ EXPECT_FALSE(IsInGestureInProgressState());

+ EXPECT_FALSE(IsInTouchToMouseMode());

aboxhall 2014/07/02 18:00:13 nit: weird outdent

lisayin 2014/07/02 18:21:04 Done.

+ std::vector<ui::LocatedEvent*> captured_located_events =

+ GetCapturedLocatedEvents();

+ ASSERT_EQ(1U, captured_events.size());

+ CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_located_events[0], &second_press);

+ ClearCapturedEvents();

+ // The rest of the events should occur in passthrough.

+ generator_->ReleaseTouchId(0);

+ ASSERT_EQ(1U, captured_events.size());

+ EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[0]->type());

+ ClearCapturedEvents();

+ generator_->ReleaseTouchId(1);

+ ASSERT_EQ(0U, captured_events.size());

} // namespace ui

« ui/chromeos/touch_exploration_controller.cc ('K') | « ui/chromeos/touch_exploration_controller.cc ('k') | no next file » | no next file with comments »