Added split tap to TouchExplorationController

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 112 matching lines @@
     case SINGLE_TAP_PRESSED:
       return InSingleTapPressed(touch_event, rewritten_event);
     case SINGLE_TAP_RELEASED:
       return InSingleTapReleased(touch_event, rewritten_event);
     case DOUBLE_TAP_PRESSED:
       return InDoubleTapPressed(touch_event, rewritten_event);
     case TOUCH_EXPLORATION:
       return InTouchExploration(touch_event, rewritten_event);
     case PASSTHROUGH_MINUS_ONE:
       return InPassthroughMinusOne(touch_event, rewritten_event);
+    case TE_SECOND_PRESS:
+      return InTouchExplSecondPress(touch_event, rewritten_event);
   }
 
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::NextDispatchEvent(
     const ui::Event& last_event, scoped_ptr<ui::Event>* new_event) {
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InNoFingersDown(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
+    // If this is the first ever touch, initialize last_touch_exploration_

[aboxhall, 2014/06/13 17:06:48]

This seems odd to me. If this isn't a touch exploration, why is it going to be
effectively treated as one iff it's the first touch?

In what circumstances is accessing last_touch_exploration_ causing a NPR - i.e.
how can it get to a state where last_touch_exploration_ is being checked before
it's initialized? Does this mean that it's sometimes using an out of date
last_touch_exploration_ value?  I'd consider doing a
CHECK(last_touch_exploration_) wherever it's referenced and fixing the NPR where
it occurs, rather than doing this.

Also, note that in Chromium code style, the braces in this one-line if block are
optional - feel free to leave them in, though.
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Condit...

[evy, 2014/06/13 17:48:59]

This will happen if the user hasn't entered touch exploration, but tries to do a
double tap (or double tap press). I've moved the code into InSingleTapReleased,
where it is decided that there will be a double tap, and if there is no last
touch exploration declared at this point, I just make it where the second tap
is.
Would it still be good to add the CHECK(last_touch_exploration_) where I
reference it elsewhere?

[aboxhall, 2014/06/13 18:20:00]

I see, so this would be the case where a user double taps somewhere on the
screen before ever doing a touch explore in this session - definitely an unusual
but not impossible case :)
You probably don't need to do that if that's definitely the only situation where
this can happen.

+    // to avoid null pointer references later.
+    if (last_touch_exploration_ == NULL) {
+      last_touch_exploration_.reset(new TouchEvent(event));
+    }
     initial_press_.reset(new TouchEvent(event));
     tap_timer_.Start(FROM_HERE,
                      gesture_detector_config_.double_tap_timeout,
                      this,
                      &TouchExplorationController::OnTapTimerFired);
     state_ = SINGLE_TAP_PRESSED;
     VLOG_STATE();
     return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED();
@@ skipping 34 matching lines @@
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapReleased(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     // This is the second tap in a double-tap (or double tap-hold).
     // Rewrite at location of last touch exploration.
     ui::TouchEvent* rewritten_press_event = new ui::TouchEvent(
         ui::ET_TOUCH_PRESSED,
-        last_touch_exploration_location_,
+        last_touch_exploration_->location(),
         event.touch_id(),
         event.time_stamp());
     rewritten_press_event->set_flags(event.flags());
     rewritten_event->reset(rewritten_press_event);
     state_ = DOUBLE_TAP_PRESSED;
     VLOG_STATE();
     return ui::EVENT_REWRITE_REWRITTEN;
   }
 
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InDoubleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() != 0)
       return EVENT_REWRITE_DISCARD;
 
     // Rewrite at location of last touch exploration.
     ui::TouchEvent* rewritten_release_event = new ui::TouchEvent(
         ui::ET_TOUCH_RELEASED,
-        last_touch_exploration_location_,
+        last_touch_exploration_->location(),
         event.touch_id(),
         event.time_stamp());
     rewritten_release_event->set_flags(event.flags());
     rewritten_event->reset(rewritten_release_event);
     ResetToNoFingersDown();
     return ui::EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_MOVED) {
     return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InTouchExploration(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
-
-    // Ignore any additional fingers when we're already in touch exploration
-    // mode. TODO(evy, lisayin): Support "split-tap" here instead.
-    return ui::EVENT_REWRITE_DISCARD;
+    // Split-tap
+    initial_press_.reset(new TouchEvent(event));
+    if (tap_timer_.IsRunning())
+      tap_timer_.Stop();
+    ui::TouchEvent* rewritten_touch_event =
+        new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
+                           last_touch_exploration_->location(),
+                           event.touch_id(),
+                           event.time_stamp());
+    rewritten_touch_event->set_flags(event.flags());
+    rewritten_event->reset(rewritten_touch_event);
+    state_ = TE_SECOND_PRESS;
+    VLOG_STATE();
+    return ui::EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() == 0)
       ResetToNoFingersDown();
   } else if (type != ui::ET_TOUCH_MOVED) {
     NOTREACHED() << "Unexpected event type received.";
     return ui::EVENT_REWRITE_CONTINUE;
   }
 
   // Rewrite as a mouse-move event.
   *rewritten_event = CreateMouseMoveEvent(event.location(), event.flags());
-  last_touch_exploration_location_ = event.location();
+  last_touch_exploration_.reset(new TouchEvent(event));
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InPassthroughMinusOne(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
   gfx::PointF location = event.location_f();
 
   if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() == 0)
@@ skipping 30 matching lines @@
         initial_touch_id_passthrough_mapping_,
         event.time_stamp());
     rewritten_passthrough_event->set_flags(event.flags());
     rewritten_event->reset(rewritten_passthrough_event);
     return ui::EVENT_REWRITE_REWRITTEN;
   }
 
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
+ui::EventRewriteStatus TouchExplorationController::InTouchExplSecondPress(
+    const ui::TouchEvent& event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  ui::EventType type = event.type();
+  gfx::PointF location = event.location_f();
+  if (type == ui::ET_TOUCH_PRESSED) {
+    return ui::EVENT_REWRITE_DISCARD;
+  } else if (type == ui::ET_TOUCH_MOVED) {
+    // Currently this is a discard, but could be something like rotor
+    // in the future.
+    return ui::EVENT_REWRITE_DISCARD;
+  } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
+    // If the touch exploration finger is lifted, there is no option to return
+    // to touch explore anymore. The remaining finger acts as a pending
+    // tap or long tap for the last touch explore location.
+    if (event.touch_id() == last_touch_exploration_->touch_id()){
+      state_ = DOUBLE_TAP_PRESSED;
+      VLOG_STATE();
+      return EVENT_REWRITE_DISCARD;
+    }
+
+    // Continue to release the touch only if the touch explore finger is the
+    // only finger remaining.
+    if (current_touch_ids_.size() != 1)
+      return EVENT_REWRITE_DISCARD;
+
+    // Rewrite at location of last touch exploration.
+    ui::TouchEvent* rewritten_release_event = new ui::TouchEvent(
+        ui::ET_TOUCH_RELEASED,
+        last_touch_exploration_->location(),
+        initial_press_->touch_id(),
+        event.time_stamp());
+    rewritten_release_event->set_flags(event.flags());
+    rewritten_event->reset(rewritten_release_event);
+    state_ = TOUCH_EXPLORATION;
+    VLOG_STATE();
+    return ui::EVENT_REWRITE_REWRITTEN;
+  }
+  NOTREACHED() << "Unexpected event type received.";
+  return ui::EVENT_REWRITE_CONTINUE;
+}
+
 void TouchExplorationController::OnTapTimerFired() {
   if (state_ != SINGLE_TAP_RELEASED && state_ != SINGLE_TAP_PRESSED)
     return;
 
   if (state_ == SINGLE_TAP_RELEASED) {
     ResetToNoFingersDown();
   } else {
     EnterTouchToMouseMode();
     state_ = TOUCH_EXPLORATION;
     VLOG_STATE();
   }
 
   scoped_ptr<ui::Event> mouse_move = CreateMouseMoveEvent(
       initial_press_->location(), initial_press_->flags());
   DispatchEvent(mouse_move.get());
-  last_touch_exploration_location_ = initial_press_->location();
+  last_touch_exploration_.reset(new TouchEvent(*initial_press_));
 }
 
 void TouchExplorationController::DispatchEvent(ui::Event* event) {
   if (event_handler_for_testing_) {
     event_handler_for_testing_->OnEvent(event);
     return;
   }
   ui::EventDispatchDetails result ALLOW_UNUSED =
       root_window_->GetHost()->dispatcher()->OnEventFromSource(event);
 }
@@ skipping 61 matching lines @@
     case SINGLE_TAP_PRESSED:
       return "SINGLE_TAP_PRESSED";
     case SINGLE_TAP_RELEASED:
       return "SINGLE_TAP_RELEASED";
     case DOUBLE_TAP_PRESSED:
       return "DOUBLE_TAP_PRESSED";
     case TOUCH_EXPLORATION:
       return "TOUCH_EXPLORATION";
     case PASSTHROUGH_MINUS_ONE:
       return "PASSTHROUGH_MINUS_ONE";
+    case TE_SECOND_PRESS:
+      return "TE_SECOND_PRESS";
   }
   return "Not a state";
 }
 
 const char* TouchExplorationController::EnumEventTypeToString(
     ui::EventType type) {
   // Add more cases later. For now, these are the most frequently seen
   // event types.
   switch (type) {
     case ET_TOUCH_RELEASED:
       return "ET_TOUCH_RELEASED";
     case ET_TOUCH_PRESSED:
       return "ET_TOUCH_PRESSED";
     case ET_TOUCH_MOVED:
       return "ET_TOUCH_MOVED";
     case ET_TOUCH_CANCELLED:
       return "ET_TOUCH_CANCELLED";
     default:
       return base::IntToString(type).c_str();
   }
 }
 
 }  // namespace ui