Added accurate TouchToMouseMode testing to SplitTap

ui/chromeos/touch_exploration_controller.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/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
@@ skipping 28 matching lines @@
 TouchExplorationController::~TouchExplorationController() {
   root_window_->GetHost()->GetEventSource()->RemoveEventRewriter(this);
 }
 
 void TouchExplorationController::CallTapTimerNowForTesting() {
   DCHECK(tap_timer_.IsRunning());
   tap_timer_.Stop();
   OnTapTimerFired();
 }
 
 void TouchExplorationController::CallTapTimerNowIfRunningForTesting() {

[mfomitchev, 2014/07/09 19:20:37]

Do we really need both of these methods? Seems like
CallTapTimerNowIfRunningForTesting() alone should do.

[evy, 2014/07/09 19:36:00]

The IfRunning version was added in the last CL I committed, where I run a bunch
of permutations of different touch events. In these cases I didn't want to keep
track of if the timer was running, but wanted to call it when the sequence of
events were done. 

For the most part, though, I think it's better to only call the tap timer in
unit tests if we know it's definitely running, which has been the case so far.
If the timer actually isn't running, the DCHECK fails and that could be useful.

   if (tap_timer_.IsRunning()) {
     tap_timer_.Stop();
     OnTapTimerFired();
   }
 }
 
 void TouchExplorationController::SetEventHandlerForTesting(
     ui::EventHandler* event_handler_for_testing) {
   event_handler_for_testing_ = event_handler_for_testing;
 }
 
 bool TouchExplorationController::IsInNoFingersDownStateForTesting() const {
   return state_ == NO_FINGERS_DOWN;
 }
 
 bool TouchExplorationController::IsInGestureInProgressStateForTesting() const {
   return state_ == GESTURE_IN_PROGRESS;
 }
 
 void TouchExplorationController::SuppressVLOGsForTesting(bool suppress) {

[mfomitchev, 2014/07/09 19:20:37]

Why do we need to suppress logging for testing?

PS: Realized that this line and the previous one I commented on weren't part of
the your change - guess they appeared in the diff because of the rebase. So you
don't need to fix this in this CL.

[evy, 2014/07/09 19:36:00]

Yeah - also part of the permutations test CL. 
There are over 30000 touch events dispatched and I was manually turning off
logging, but they still run by default and in the trybot tests so Dominic
suggested I just write a function to make it so they're never called.

[mfomitchev, 2014/07/09 20:47:21]

Ok. We are starting to get a lot of these ForTesting methods, polluting the
interface and making it more difficult to figure out what this class actually
does. It would be good to create a wrapper class for testing and put all these
methods in there - see ui/aura/test/window_test_api for example.

[evy, 2014/07/09 21:32:09]

That's a good idea - I think I'll start it in a new branch because it isn't
really related to this bug. Would you like me to add you as a reviewer on that,
or is it fine to just get my hosts to look it over?

[mfomitchev, 2014/07/09 21:53:03]

Yup, doing it in a separate CL makes sense. Feel free to add me as a reviewer if
you want, but you don't need to.

[evy, 2014/07/10 02:44:20]

Sounds good - thanks for the suggestion!

     VLOG_on_ = !suppress;
 }
 
 ui::EventRewriteStatus TouchExplorationController::RewriteEvent(
     const ui::Event& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   if (!event.IsTouchEvent()) {
     if (event.IsKeyEvent()) {
       const ui::KeyEvent& key_event = static_cast<const ui::KeyEvent&>(event);
       VLOG(0) << "\nKeyboard event: " << key_event.name()
@@ skipping 415 matching lines @@
     if (current_touch_ids_.size() != 1)
       return EVENT_REWRITE_DISCARD;
 
     // Rewrite at location of last touch exploration.
     rewritten_event->reset(
         new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
                            last_touch_exploration_->location(),
                            initial_press_->touch_id(),
                            event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
+    state_ = TOUCH_EXPLORATION;
     EnterTouchToMouseMode();
-    state_ = TOUCH_EXPLORATION;
     VLOG_STATE();
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED() << "Unexpected event type received: " << event.name();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForRelease(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
@@ skipping 206 matching lines @@
       return "TWO_TO_ONE_FINGER";
     case PASSTHROUGH:
       return "PASSTHROUGH";
     case WAIT_FOR_RELEASE:
       return "WAIT_FOR_RELEASE";
   }
   return "Not a state";
 }
 
 }  // namespace ui