Fix Touch Exploration tests so they don't break eager gesture detection.

ui/chromeos/touch_exploration_controller_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/chromeos/touch_exploration_controller.h"
 
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/test/aura_test_base.h"
@@ skipping 94 matching lines @@
     touch_exploration_controller_->OnTapTimerFired();
   }
 
   void CallTapTimerNowIfRunningForTesting() {
     if (touch_exploration_controller_->tap_timer_.IsRunning()) {
       touch_exploration_controller_->tap_timer_.Stop();
       touch_exploration_controller_->OnTapTimerFired();
     }
   }
 
-  void SetEventHandlerForTesting(
-      ui::EventHandler* event_handler_for_testing) {
-    touch_exploration_controller_->event_handler_for_testing_ =
-        event_handler_for_testing;
-  }
-
   bool IsInNoFingersDownStateForTesting() const {
     return touch_exploration_controller_->state_ ==
            touch_exploration_controller_->NO_FINGERS_DOWN;
   }
 
   bool IsInGestureInProgressStateForTesting() const {
     return touch_exploration_controller_->state_ ==
            touch_exploration_controller_->GESTURE_IN_PROGRESS;
   }
 
@@ skipping 112 matching lines @@
     touch_exploration_controller_->SuppressVLOGsForTesting(suppress);
   }
 
   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::TouchExplorationControllerTestApi(
               new TouchExplorationController(root_window(), &delegate_)));
-      touch_exploration_controller_->SetEventHandlerForTesting(
-          &event_capturer_);
       cursor_client()->ShowCursor();
       cursor_client()->DisableMouseEvents();
     }
   }
 
   void EnterTouchExplorationModeAtLocation(gfx::Point tap_location) {
     ui::TouchEvent touch_press(ui::ET_TOUCH_PRESSED, tap_location, 0, Now());
     generator_->Dispatch(&touch_press);
     AdvanceSimulatedTimePastTapDelay();
     EXPECT_TRUE(IsInTouchToMouseMode());
@@ skipping 163 matching lines @@
   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());
 }
 
 TEST_F(TouchExplorationTest, OneFingerTap) {
   SwitchTouchExplorationMode(true);
+  cursor_client()->EnableMouseEvents();

[tdresser, 2014/07/28 18:31:43]

I'm not super clear what's going on here. Is it OK to forcibly enable mouse
events?

I would have thought that they should be enabled by the
TouchExplorationController, but that doesn't appear to be happening.

[lisayin, 2014/07/28 19:14:54]

By default, passing true to SwitchTouchExplorationMode will disable mouse
events.

Currently, mouse events are only turned on if the state changes to
TOUCH_EXPLORATION. I think that the name of the function might be a little
misleading since it doesn't actually switch the state to TOUCH_EXPLORATION, it
makes a new controller to handle the accessible touch events. 

Although, Dominic, it doesn't look like mouse events are ever disabled after
they're turned on once. Should this be the case?

[dmazzoni, 2014/07/28 19:28:37]

Yes, could we rename that?
I'm pretty sure they get re-enabled again automatically. Mikhail can explain
better.

   gfx::Point location(11, 12);
   generator_->set_current_location(location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   AdvanceSimulatedTimePastTapDelay();
 
   std::vector<ui::LocatedEvent*> events =
       GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
   ASSERT_EQ(1U, events.size());
 
@@ skipping 131 matching lines @@
   generator_->ReleaseTouchId(1);
   AdvanceSimulatedTimePastTapDelay();
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
 // If a new tap is received after the double-tap timeout has elapsed from
 // a previous tap, but before the timer has fired, a mouse move should
 // still be generated from the old tap.
 TEST_F(TouchExplorationTest, TimerFiresLateAfterTap) {
   SwitchTouchExplorationMode(true);
+  cursor_client()->EnableMouseEvents();
 
   // Send a tap at location1.
   gfx::Point location0(11, 12);
   generator_->set_current_location(location0);
   generator_->PressTouch();
   generator_->ReleaseTouch();
 
   // Send a tap at location2, after the double-tap timeout, but before the
   // timer fires.
   gfx::Point location1(33, 34);
@@ skipping 12 matching lines @@
   EXPECT_EQ(location1, events[1]->location());
   EXPECT_TRUE(events[1]->flags() & ui::EF_IS_SYNTHESIZED);
   EXPECT_TRUE(events[1]->flags() & ui::EF_TOUCH_ACCESSIBILITY);
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
 // Double-tapping should send a touch press and release through to the location
 // of the last successful touch exploration.
 TEST_F(TouchExplorationTest, DoubleTap) {
   SwitchTouchExplorationMode(true);
+  cursor_client()->EnableMouseEvents();
 
   // Tap at one location, and get a mouse move event.
   gfx::Point tap_location(11, 12);
   generator_->set_current_location(tap_location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   AdvanceSimulatedTimePastTapDelay();
 
   std::vector<ui::LocatedEvent*> events =
       GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
@@ skipping 21 matching lines @@
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[1]->type());
   EXPECT_EQ(tap_location, captured_events[1]->location());
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
 // Double-tapping where the user holds their finger down for the second time
 // for a longer press should send a touch press and released (right click)
 // to the location of the last successful touch exploration.
 TEST_F(TouchExplorationTest, DoubleTapLongPress) {
   SwitchTouchExplorationMode(true);
+  cursor_client()->EnableMouseEvents();
 
   // Tap at one location, and get a mouse move event.
   gfx::Point tap_location(11, 12);
   generator_->set_current_location(tap_location);
   generator_->PressTouch();
   generator_->ReleaseTouch();
   AdvanceSimulatedTimePastTapDelay();
 
   std::vector<ui::LocatedEvent*> events =
       GetCapturedLocatedEventsOfType(ui::ET_MOUSE_MOVED);
@@ skipping 428 matching lines @@
       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());
 }
 
 // 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) {
-  std::vector<ui::LocatedEvent*> captured_events = GetCapturedLocatedEvents();
+  SwitchTouchExplorationMode(true);
+  std::vector<ui::LocatedEvent*> captured_events;
 
   gfx::Point first_touch_location = gfx::Point(11,12);
+  ui::TouchEvent first_touch_press(
+      ui::ET_TOUCH_PRESSED, first_touch_location, 0, Now());
+  generator_->Dispatch(&first_touch_press);
+
   gfx::Point second_touch_location = gfx::Point(21, 22);
-  EnterTwoToOne(first_touch_location, second_touch_location);
+  ui::TouchEvent second_touch_press(
+      ui::ET_TOUCH_PRESSED, second_touch_location, 1, Now());
+  generator_->Dispatch(&second_touch_press);
+
   captured_events = GetCapturedLocatedEvents();
   ASSERT_EQ(captured_events.size(), 1u);
 
   gfx::Point third_touch_location = gfx::Point(31, 32);
   ui::TouchEvent third_touch_press(
       ui::ET_TOUCH_PRESSED, third_touch_location, 2, Now());
   generator_->Dispatch(&third_touch_press);
   captured_events = GetCapturedLocatedEvents();
   // Now all fingers are registered as pressed.
-  ASSERT_EQ(captured_events.size(), 3u);
+  ASSERT_EQ(3u, captured_events.size());
   ClearCapturedEvents();
 
   // All fingers should be passed through.
   first_touch_location = gfx::Point(13, 14);
   second_touch_location = gfx::Point(23, 24);
   third_touch_location = gfx::Point(33, 34);
   ui::TouchEvent first_touch_first_move(
       ui::ET_TOUCH_MOVED, first_touch_location, 0, Now());
   ui::TouchEvent second_touch_first_move(
       ui::ET_TOUCH_MOVED, second_touch_location, 1, Now());
   ui::TouchEvent third_touch_first_move(
       ui::ET_TOUCH_MOVED, third_touch_location, 2, Now());
   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);
+  ASSERT_EQ(3u, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[0]->type());
   EXPECT_EQ(first_touch_location, captured_events[0]->location());
   EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[1]->type());
   EXPECT_EQ(second_touch_location, captured_events[1]->location());
   EXPECT_EQ(ui::ET_TOUCH_MOVED, captured_events[2]->type());
   EXPECT_EQ(third_touch_location, captured_events[2]->location());
   ClearCapturedEvents();
 
   // When we release the third finger, the other fingers should still be
   // passed through.
@@ skipping 482 matching lines @@
   EXPECT_FALSE(IsInSlideGestureState());
   EXPECT_FALSE(IsInTouchToMouseMode());
 
   AdvanceSimulatedTimePastTapDelay();
   EXPECT_FALSE(IsInGestureInProgressState());
   EXPECT_FALSE(IsInSlideGestureState());
   EXPECT_TRUE(IsInTouchToMouseMode());
 }
 
 }  // namespace ui