Implementation of the Touch Exploration Mode - Part I (ui)

ui/chromeos/touch_exploration_controller_unittest.cc

+// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/chromeos/touch_exploration_controller.h"
+
+#include "base/time/time.h"
+#include "ui/aura/client/cursor_client.h"
+#include "ui/aura/test/aura_test_base.h"
+#include "ui/aura/test/event_generator.h"
+#include "ui/aura/test/test_cursor_client.h"
+#include "ui/aura/window.h"
+#include "ui/events/event.h"
+#include "ui/events/event_utils.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_surface.h"
+
+namespace ui {
+
+namespace {
+// Records all mouse and touch events.
+class EventCapturer : public ui::EventHandler {
+ public:
+  EventCapturer() {}
+  virtual ~EventCapturer() {}
+
+  void Reset() {
+    events_.clear();
+  }
+
+  virtual void OnEvent(ui::Event* event) OVERRIDE {
+    if (event->IsMouseEvent()) {
+      events_.push_back(
+          new ui::MouseEvent(static_cast<ui::MouseEvent&>(*event)));
+    } else if (event->IsTouchEvent()) {
+      events_.push_back(
+          new ui::TouchEvent(static_cast<ui::TouchEvent&>(*event)));
+    } else {
+      return;
+    }
+    // Stop event propagation so we don't click on random stuff that
+    // might break test assumptions.
+    event->StopPropagation();
+    // If there is a possibility that we're in an infinite loop, we should
+    // exit early with a sensible error rather than letting the test time out.
+    ASSERT_LT(events_.size(), 100u);
+  }
+  const ScopedVector<ui::LocatedEvent>& captured_events() const {
+    return events_;
+  }
+
+ private:
+  ScopedVector<ui::LocatedEvent> events_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventCapturer);
+};
+
+}  // namespace
+
+class TouchExplorationTest : public aura::test::AuraTestBase {
+ public:
+  TouchExplorationTest() {}
+  virtual ~TouchExplorationTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    if (gfx::GetGLImplementation() == gfx::kGLImplementationNone)
+      gfx::GLSurface::InitializeOneOffForTests();
+    aura::test::AuraTestBase::SetUp();
+    cursor_client_.reset(new aura::test::TestCursorClient(root_window()));
+    root_window()->AddPreTargetHandler(&event_capturer_);
+  }
+
+  virtual void TearDown() OVERRIDE {
+    root_window()->RemovePreTargetHandler(&event_capturer_);
+    SwitchTouchExplorationMode(false);
+    cursor_client_.reset();
+    aura::test::AuraTestBase::TearDown();
+  }
+
+  const ScopedVector<ui::LocatedEvent>& GetCapturedEvents() {
+    return event_capturer_.captured_events();
+  }
+
+  void ClearCapturedEvents() {
+    event_capturer_.Reset();
+  }
+
+ protected:
+  aura::client::CursorClient* cursor_client() { return cursor_client_.get(); }
+
+  void SwitchTouchExplorationMode(bool on) {
+    if (!on && touch_exploration_controller_.get())
+      touch_exploration_controller_.reset();
+    else if (on && !touch_exploration_controller_.get())
+      touch_exploration_controller_.reset(
+          new ui::TouchExplorationController(root_window()));
+  }
+
+  bool IsInTouchToMouseMode() {
+    aura::client::CursorClient* cursor_client =
+        aura::client::GetCursorClient(root_window());
+    return cursor_client &&
+           cursor_client->IsMouseEventsEnabled() &&
+           !cursor_client->IsCursorVisible();
+  }
+
+ private:
+  EventCapturer event_capturer_;
+  scoped_ptr<ui::TouchExplorationController> touch_exploration_controller_;
+  scoped_ptr<aura::test::TestCursorClient> cursor_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(TouchExplorationTest);
+};
+
+// Executes a number of assertions to confirm that |e1| and |e2| are touch
+// events and are equal to each other.
+void ConfirmEventsAreTouchAndEqual(ui::Event* e1, ui::Event* e2) {
+  ASSERT_TRUE(e1->IsTouchEvent());
+  ASSERT_TRUE(e2->IsTouchEvent());
+  ui::TouchEvent* touch_event1 = static_cast<ui::TouchEvent*>(e1);
+  ui::TouchEvent* touch_event2 = static_cast<ui::TouchEvent*>(e2);
+  EXPECT_EQ(touch_event1->type(), touch_event2->type());
+  EXPECT_EQ(touch_event1->location(), touch_event2->location());
+  EXPECT_EQ(touch_event1->touch_id(), touch_event2->touch_id());
+  EXPECT_EQ(touch_event1->flags(), touch_event2->flags());
+  EXPECT_EQ(touch_event1->time_stamp(), touch_event2->time_stamp());
+}
+
+// Executes a number of assertions to confirm that |e1| and |e2| are mouse
+// events and are equal to each other.
+void ConfirmEventsAreMouseAndEqual(ui::Event* e1, ui::Event* e2) {
+  ASSERT_TRUE(e1->IsMouseEvent());
+  ASSERT_TRUE(e2->IsMouseEvent());
+  ui::MouseEvent* mouse_event1 = static_cast<ui::MouseEvent*>(e1);
+  ui::MouseEvent* mouse_event2 = static_cast<ui::MouseEvent*>(e2);
+  EXPECT_EQ(mouse_event1->type(), mouse_event2->type());
+  EXPECT_EQ(mouse_event1->location(), mouse_event2->location());
+  EXPECT_EQ(mouse_event1->root_location(), mouse_event2->root_location());
+  EXPECT_EQ(mouse_event1->flags(), mouse_event2->flags());
+}
+
+#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))
+
+// 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.
+
+// Simple test to confirm one-finger touches are transformed into mouse moves.
+TEST_F(TouchExplorationTest, OneFingerTouch) {
+  SwitchTouchExplorationMode(true);
+  cursor_client()->ShowCursor();
+  cursor_client()->DisableMouseEvents();
+  aura::test::EventGenerator generator(root_window());
+  gfx::Point location_start = generator.current_location();
+  gfx::Point location_end(11, 12);
+  generator.PressTouch();
+  EXPECT_TRUE(IsInTouchToMouseMode());
+  generator.MoveTouch(location_end);
+  // Confirm the actual mouse moves are unaffected.
+  ui::MouseEvent mouse_move(ui::ET_MOUSE_MOVED,
+                            gfx::Point(13, 14),
+                            gfx::Point(13, 14),
+                            0,
+                            0);
+  generator.Dispatch(&mouse_move);
+  generator.ReleaseTouch();
+
+  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  ScopedVector<ui::LocatedEvent>::const_iterator it;
+  // TODO(mfomitchev): mouse enter/exit events
+  int num_mouse_moves = 0;
+  for (it = captured_events.begin(); it != captured_events.end(); ++it) {
+    int type = (*it)->type();
+    // Ignore enter and exit mouse events synthesized when the mouse cursor is
+    // shown or hidden.
+    if (type == ui::ET_MOUSE_ENTERED || type == ui::ET_MOUSE_EXITED)
+      continue;
+    EXPECT_EQ(ui::ET_MOUSE_MOVED, (*it)->type());
+    if (num_mouse_moves == 0)
+      EXPECT_EQ(location_start, (*it)->location());
+    if (num_mouse_moves == 1 || num_mouse_moves == 3)
+      EXPECT_EQ(location_end, (*it)->location());
+    if (num_mouse_moves == 2)
+      CONFIRM_EVENTS_ARE_MOUSE_AND_EQUAL(*it, &mouse_move);
+    if (num_mouse_moves != 2) {
+      EXPECT_TRUE((*it)->flags() & ui::EF_IS_SYNTHESIZED);
+      EXPECT_TRUE((*it)->flags() & ui::EF_FROM_TOUCH);
+    }
+    num_mouse_moves++;
+  }
+  EXPECT_EQ(4, num_mouse_moves);
+}
+
+// Turn the touch exploration mode on in the middle of the touch gesture.
+// Confirm that events from the finger which was touching when the mode was
+// turned on don't get rewritten.
+TEST_F(TouchExplorationTest, TurnOnMidTouch) {
+  SwitchTouchExplorationMode(false);
+  cursor_client()->ShowCursor();
+  cursor_client()->DisableMouseEvents();
+  aura::test::EventGenerator generator(root_window());
+  generator.PressTouchId(1);
+  EXPECT_TRUE(cursor_client()->IsCursorVisible());
+  EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
+  ClearCapturedEvents();
+
+  // Enable touch exploration mode while the first finger is touching the
+  // screen. Ensure that subsequent events from that first finger are not
+  // affected by the touch exploration mode, while the touch events from another
+  // finger get rewritten.
+  SwitchTouchExplorationMode(true);
+  ui::TouchEvent touch_move(ui::ET_TOUCH_MOVED,
+                            gfx::Point(11, 12),
+                            1,
+                            ui::EventTimeForNow());
+  generator.Dispatch(&touch_move);
+  EXPECT_TRUE(cursor_client()->IsCursorVisible());
+  EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
+  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(1u, captured_events.size());
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_move);
+  ClearCapturedEvents();
+
+  // The press from the second finger should get rewritten.
+  generator.PressTouchId(2);
+  EXPECT_TRUE(IsInTouchToMouseMode());
+  // TODO(mfomitchev): mouse enter/exit events
+  ScopedVector<ui::LocatedEvent>::const_iterator it;
+  for (it = captured_events.begin(); it != captured_events.end(); ++it) {
+    if ((*it)->type() == ui::ET_MOUSE_MOVED)
+      break;
+  }
+  EXPECT_NE(captured_events.end(), it);
+  ClearCapturedEvents();
+
+  // The release of the first finger shouldn't be affected.
+  ui::TouchEvent touch_release(ui::ET_TOUCH_RELEASED,
+                               gfx::Point(11, 12),
+                               1,
+                               ui::EventTimeForNow());
+  generator.Dispatch(&touch_release);
+  ASSERT_EQ(1u, captured_events.size());
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_release);
+  ClearCapturedEvents();
+
+  // The move and release from the second finger should get rewritten.
+  generator.MoveTouchId(gfx::Point(13, 14), 2);
+  generator.ReleaseTouchId(2);
+  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());
+}
+
+TEST_F(TouchExplorationTest, TwoFingerTouch) {
+  SwitchTouchExplorationMode(true);
+  aura::test::EventGenerator generator(root_window());
+  generator.PressTouchId(1);
+  ClearCapturedEvents();
+
+  // Confirm events from the second finger go through as is.
+  cursor_client()->ShowCursor();
+  cursor_client()->DisableMouseEvents();
+  ui::TouchEvent touch_press(ui::ET_TOUCH_PRESSED,
+                             gfx::Point(10, 11),
+                             2,
+                             ui::EventTimeForNow());
+  generator.Dispatch(&touch_press);
+  EXPECT_TRUE(cursor_client()->IsCursorVisible());
+  EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
+  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  // TODO(mfomitchev): mouse enter/exit events
+  // There will be a ET_MOUSE_EXITED event synthesized when the mouse cursor is
+  // hidden - ignore it.
+  ScopedVector<ui::LocatedEvent>::const_iterator it;
+  for (it = captured_events.begin(); it != captured_events.end(); ++it) {
+    if ((*it)->type() == ui::ET_TOUCH_PRESSED) {
+      CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(*it, &touch_press);
+      break;
+    }
+  }
+  EXPECT_NE(captured_events.end(), it);
+  ClearCapturedEvents();
+  ui::TouchEvent touch_move(ui::ET_TOUCH_MOVED,
+                            gfx::Point(20, 21),
+                            2,
+                            ui::EventTimeForNow());
+  generator.Dispatch(&touch_move);
+  ASSERT_EQ(1u, captured_events.size());
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_move);
+  ClearCapturedEvents();
+
+  // Confirm mouse moves go through unaffected.
+  ui::MouseEvent mouse_move(ui::ET_MOUSE_MOVED,
+                            gfx::Point(13, 14),
+                            gfx::Point(13, 14),
+                            0,
+                            0);
+  generator.Dispatch(&mouse_move);
+  // TODO(mfomitchev): mouse enter/exit events
+  // Ignore synthesized ET_MOUSE_ENTERED/ET_MOUSE_EXITED
+  for (it = captured_events.begin(); it != captured_events.end(); ++it) {
+    if ((*it)->type() == ui::ET_MOUSE_MOVED) {
+      CONFIRM_EVENTS_ARE_MOUSE_AND_EQUAL(*it, &mouse_move);
+      break;
+    }
+  }
+  EXPECT_NE(captured_events.end(), it);
+  ClearCapturedEvents();
+
+  // Have some other fingers touch/move/release
+  generator.PressTouchId(3);
+  generator.PressTouchId(4);
+  generator.MoveTouchId(gfx::Point(30, 31), 3);
+  generator.ReleaseTouchId(3);
+  generator.ReleaseTouchId(4);
+  ClearCapturedEvents();
+
+  // Events from the first finger should not go through while the second finger
+  // is touching.
+  gfx::Point touch1_location = gfx::Point(15, 16);
+  generator.MoveTouchId(touch1_location, 1);
+  EXPECT_EQ(0u, GetCapturedEvents().size());
+
+  EXPECT_TRUE(cursor_client()->IsCursorVisible());
+  EXPECT_FALSE(cursor_client()->IsMouseEventsEnabled());
+
+  // A release of the second finger should go through, plus there should be a
+  // mouse move at |touch1_location| generated.
+  ui::TouchEvent touch_release(ui::ET_TOUCH_RELEASED,
+                               gfx::Point(25, 26),
+                               2,
+                               ui::EventTimeForNow());
+  generator.Dispatch(&touch_release);
+  EXPECT_TRUE(IsInTouchToMouseMode());
+  ASSERT_GE(captured_events.size(), 2u);
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch_release);
+  // TODO(mfomitchev): mouse enter/exit events
+  // Ignore synthesized ET_MOUSE_ENTERED/ET_MOUSE_EXITED
+  for (it = captured_events.begin(); it != captured_events.end(); ++it) {
+    if ((*it)->type() == ui::ET_MOUSE_MOVED) {
+      EXPECT_EQ(touch1_location, (*it)->location());
+      break;
+    }
+  }
+  EXPECT_NE(captured_events.end(), it);
+}
+
+TEST_F(TouchExplorationTest, MultiFingerTouch) {
+  SwitchTouchExplorationMode(true);
+  aura::test::EventGenerator generator(root_window());
+  generator.PressTouchId(1);
+  generator.PressTouchId(2);
+  ClearCapturedEvents();
+
+  // Confirm events from other fingers go through as is.
+  ui::TouchEvent touch3_press(ui::ET_TOUCH_PRESSED,
+                              gfx::Point(10, 11),
+                              3,
+                              ui::EventTimeForNow());
+  ui::TouchEvent touch3_move1(ui::ET_TOUCH_MOVED,
+                              gfx::Point(12, 13),
+                              3,
+                              ui::EventTimeForNow());
+  ui::TouchEvent touch4_press(ui::ET_TOUCH_PRESSED,
+                              gfx::Point(20, 21),
+                              4,
+                              ui::EventTimeForNow());
+  ui::TouchEvent touch3_move2(ui::ET_TOUCH_MOVED,
+                              gfx::Point(14, 15),
+                              3,
+                              ui::EventTimeForNow());
+  ui::TouchEvent touch4_move(ui::ET_TOUCH_MOVED,
+                             gfx::Point(22, 23),
+                             4,
+                             ui::EventTimeForNow());
+  ui::TouchEvent touch3_release(ui::ET_TOUCH_RELEASED,
+                                gfx::Point(14, 15),
+                                3,
+                                ui::EventTimeForNow());
+  ui::TouchEvent touch4_release(ui::ET_TOUCH_RELEASED,
+                                gfx::Point(22, 23),
+                                4,
+                                ui::EventTimeForNow());
+  generator.Dispatch(&touch3_press);
+  generator.Dispatch(&touch3_move1);
+  generator.Dispatch(&touch4_press);
+  generator.Dispatch(&touch3_move2);
+  generator.Dispatch(&touch4_move);
+  generator.Dispatch(&touch3_release);
+  generator.Dispatch(&touch4_release);
+
+  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(7u, captured_events.size());
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[0], &touch3_press);
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[1], &touch3_move1);
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[2], &touch4_press);
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[3], &touch3_move2);
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[4], &touch4_move);
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[5], &touch3_release);
+  CONFIRM_EVENTS_ARE_TOUCH_AND_EQUAL(captured_events[6], &touch4_release);
+}
+
+// Test the case when there are multiple fingers on the screen and the first
+// finger is released. This should be rewritten as a release of the second
+// finger. Additionally, if the second finger is the only finger left touching,
+// we should enter a mouse move mode, and a mouse move event should be
+// dispatched.
+TEST_F(TouchExplorationTest, FirstFingerLifted) {
+  SwitchTouchExplorationMode(true);
+  aura::test::EventGenerator generator(root_window());
+  generator.PressTouchId(1);
+  generator.PressTouchId(2);
+  gfx::Point touch2_location(10, 11);
+  generator.MoveTouchId(touch2_location, 2);
+  generator.PressTouchId(3);
+  gfx::Point touch3_location(20, 21);
+  generator.MoveTouchId(touch3_location, 3);
+  ClearCapturedEvents();
+
+  // Release of finger 1 should be rewritten as a release of finger 2.
+  generator.ReleaseTouchId(1);
+  const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(1u, captured_events.size());
+  EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[0]->type());
+  ui::TouchEvent* touch_event =
+      static_cast<ui::TouchEvent*>(captured_events[0]);
+  EXPECT_EQ(2, touch_event->touch_id());
+  EXPECT_EQ(touch2_location, touch_event->location());
+  ClearCapturedEvents();
+
+  // Release of finger 2 should be rewritten as a release of finger 3, plus
+  // we should enter the mouse move mode and a mouse move event should be
+  // dispatched.
+  cursor_client()->ShowCursor();
+  cursor_client()->DisableMouseEvents();
+  generator.ReleaseTouchId(2);
+  EXPECT_TRUE(IsInTouchToMouseMode());
+  ASSERT_GE(2u, captured_events.size());
+  EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[0]->type());
+  touch_event = static_cast<ui::TouchEvent*>(captured_events[0]);
+  EXPECT_EQ(3, touch_event->touch_id());
+  EXPECT_EQ(touch3_location, touch_event->location());
+  // TODO(mfomitchev): mouse enter/exit events
+  ScopedVector<ui::LocatedEvent>::const_iterator it;
+  for (it = captured_events.begin(); it != captured_events.end(); ++it) {
+    if ((*it)->type() == ui::ET_MOUSE_MOVED) {
+      EXPECT_EQ(touch3_location, (*it)->location());
+      break;
+    }
+  }
+  EXPECT_NE(captured_events.end(), it);
+}
+
+}  // namespace ui