Add id properties to PointerEvent

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 <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 112 matching lines @@
 
   if (passthrough_timer_.IsRunning() &&
       event.time_stamp() - initial_press_->time_stamp() >
           gesture_detector_config_.longpress_timeout) {
     passthrough_timer_.Stop();
     OnPassthroughTimerFired();
   }
 
   const ui::EventType type = touch_event.type();
   const gfx::PointF& location = touch_event.location_f();
-  const int touch_id = touch_event.touch_id();
+  const int touch_id = touch_event.pointer_details().id;
 
   // Always update touch ids and touch locations, so we can use those
   // no matter what state we're in.
   if (type == ui::ET_TOUCH_PRESSED) {
     current_touch_ids_.push_back(touch_id);
     touch_locations_.insert(std::pair<int, gfx::PointF>(touch_id, location));
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     std::vector<int>::iterator it = std::find(
         current_touch_ids_.begin(), current_touch_ids_.end(), touch_id);
 
@@ skipping 132 matching lines @@
   bool in_a_bottom_corner =
       (BOTTOM_LEFT_CORNER == location) || (BOTTOM_RIGHT_CORNER == location);
   if (in_a_bottom_corner) {
     passthrough_timer_.Start(
         FROM_HERE,
         gesture_detector_config_.longpress_timeout,
         this,
         &TouchExplorationController::OnPassthroughTimerFired);
   }
   initial_press_.reset(new TouchEvent(event));
-  initial_presses_[event.touch_id()] = event.location();
+  initial_presses_[event.pointer_details().id] = event.location();
   last_unused_finger_event_.reset(new TouchEvent(event));
   StartTapTimer();
   SET_STATE(SINGLE_TAP_PRESSED);
   return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapPressed(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
 
   int location = FindEdgesWithinBounds(event.location(), kMaxDistanceFromEdge);
   bool in_a_bottom_corner =
       (location == BOTTOM_LEFT_CORNER) || (location == BOTTOM_RIGHT_CORNER);
   // If the event is from the initial press and the location is no longer in the
   // corner, then we are not waiting for a corner passthrough anymore.
-  if (event.touch_id() == initial_press_->touch_id() && !in_a_bottom_corner) {
+  if (event.pointer_details().id == initial_press_->pointer_details().id &&
+      !in_a_bottom_corner) {
     if (passthrough_timer_.IsRunning()) {
       passthrough_timer_.Stop();
       // Since the long press timer has been running, it is possible that the
       // tap timer has timed out before the long press timer has. If the tap
       // timer timeout has elapsed, then fire the tap timer.
       if (event.time_stamp() - initial_press_->time_stamp() >
           gesture_detector_config_.double_tap_timeout) {
         OnTapTimerFired();
       }
     }
   }
 
   if (type == ui::ET_TOUCH_PRESSED) {
-    initial_presses_[event.touch_id()] = event.location();
+    initial_presses_[event.pointer_details().id] = event.location();
     SET_STATE(TWO_FINGER_TAP);
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (passthrough_timer_.IsRunning())
       passthrough_timer_.Stop();
     if (current_touch_ids_.size() == 0 &&
-        event.touch_id() == initial_press_->touch_id()) {
+        event.pointer_details().id == initial_press_->pointer_details().id) {
       SET_STATE(SINGLE_TAP_RELEASED);
     } else if (current_touch_ids_.size() == 0) {
       SET_STATE(NO_FINGERS_DOWN);
     }
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
     float distance = (event.location() - initial_press_->location()).Length();
     // If the user does not move far enough from the original position, then the
     // resulting movement should not be considered to be a deliberate gesture or
     // touch exploration.
@@ skipping 164 matching lines @@
   }
   return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InCornerPassthrough(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
 
   // If the first finger has left the corner, then exit passthrough.
-  if (event.touch_id() == initial_press_->touch_id()) {
+  if (event.pointer_details().id == initial_press_->pointer_details().id) {
     int edges = FindEdgesWithinBounds(event.location(), kSlopDistanceFromEdge);
     bool in_a_bottom_corner = (edges == BOTTOM_LEFT_CORNER) ||
                               (edges == BOTTOM_RIGHT_CORNER);
     if (type == ui::ET_TOUCH_MOVED && in_a_bottom_corner)
       return ui::EVENT_REWRITE_DISCARD;
 
     if (current_touch_ids_.size() == 0) {
       SET_STATE(NO_FINGERS_DOWN);
       return ui::EVENT_REWRITE_DISCARD;
     }
     SET_STATE(WAIT_FOR_NO_FINGERS);
     return ui::EVENT_REWRITE_DISCARD;
   }
 
   std::unique_ptr<ui::TouchEvent> new_event(new ui::TouchEvent(
-      type, gfx::Point(), event.touch_id(), event.time_stamp()));
+      type, gfx::Point(), event.pointer_details().id, event.time_stamp()));
   new_event->set_location_f(event.location_f());
   new_event->set_root_location_f(event.location_f());
   new_event->set_flags(event.flags());
   *rewritten_event = std::move(new_event);
 
   if (current_touch_ids_.size() == 0)
     SET_STATE(NO_FINGERS_DOWN);
 
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InOneFingerPassthrough(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
-  if (event.touch_id() != initial_press_->touch_id()) {
+  if (event.pointer_details().id != initial_press_->pointer_details().id) {
     if (current_touch_ids_.size() == 0) {
       SET_STATE(NO_FINGERS_DOWN);
     }
     return ui::EVENT_REWRITE_DISCARD;
   }
-  std::unique_ptr<ui::TouchEvent> new_event(new ui::TouchEvent(
-      event.type(), gfx::Point(), event.touch_id(), event.time_stamp()));
+  std::unique_ptr<ui::TouchEvent> new_event(
+      new ui::TouchEvent(event.type(), gfx::Point(), event.pointer_details().id,
+                         event.time_stamp()));
   new_event->set_location_f(event.location_f() - passthrough_offset_);
   new_event->set_root_location_f(event.location_f() - passthrough_offset_);
   new_event->set_flags(event.flags());
   *rewritten_event = std::move(new_event);
   if (current_touch_ids_.size() == 0) {
     SET_STATE(NO_FINGERS_DOWN);
   }
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InTouchExploreSecondPress(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     // A third finger being pressed means that a split tap can no longer go
     // through. The user enters the wait state, Since there has already been
     // a press dispatched when split tap began, the touch needs to be
     // cancelled.
-    std::unique_ptr<ui::TouchEvent> new_event(
-        new ui::TouchEvent(ui::ET_TOUCH_CANCELLED, gfx::Point(),
-                           initial_press_->touch_id(), event.time_stamp()));
+    std::unique_ptr<ui::TouchEvent> new_event(new ui::TouchEvent(
+        ui::ET_TOUCH_CANCELLED, gfx::Point(),
+        initial_press_->pointer_details().id, event.time_stamp()));
     // TODO(dmazzoni): fix for multiple displays. http://crbug.com/616793
     new_event->set_location_f(anchor_point_);
     new_event->set_root_location_f(anchor_point_);
     new_event->set_flags(event.flags());
     *rewritten_event = std::move(new_event);
     SET_STATE(WAIT_FOR_NO_FINGERS);
     return ui::EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_MOVED) {
     // If the fingers have moved too far from their original locations,
     // the user can no longer split tap.
     ui::TouchEvent* original_touch;
-    if (event.touch_id() == last_touch_exploration_->touch_id()) {
+    if (event.pointer_details().id ==
+        last_touch_exploration_->pointer_details().id) {
       original_touch = last_touch_exploration_.get();
-    } else if (event.touch_id() == initial_press_->touch_id()) {
+    } else if (event.pointer_details().id ==
+               initial_press_->pointer_details().id) {
       original_touch = initial_press_.get();
     } else {
       NOTREACHED();
       SET_STATE(WAIT_FOR_NO_FINGERS);
       return ui::EVENT_REWRITE_DISCARD;
     }
     // Check the distance between the current finger location and the original
     // location. The slop for this is a bit more generous since keeping two
     // fingers in place is a bit harder. If the user has left the slop, the
     // user enters the wait state.
     if ((event.location_f() - original_touch->location_f()).Length() >
         GetSplitTapTouchSlop()) {
       SET_STATE(WAIT_FOR_NO_FINGERS);
     }
     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()) {
+    if (event.pointer_details().id ==
+        last_touch_exploration_->pointer_details().id) {
       SET_STATE(TOUCH_RELEASE_PENDING);
       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;
 
     SendSimulatedClick();
@@ skipping 26 matching lines @@
     return;
   }
 
   // If we don't have an anchor point, we can't send a simulated click.
   if (anchor_point_state_ == ANCHOR_POINT_NONE)
     return;
 
   // Otherwise send a simulated press/release at the anchor point.
   std::unique_ptr<ui::TouchEvent> touch_press;
   touch_press.reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(),
-                                       initial_press_->touch_id(), Now()));
+                                       initial_press_->pointer_details().id,
+                                       Now()));
   touch_press->set_location_f(anchor_point_);
   touch_press->set_root_location_f(anchor_point_);
   DispatchEvent(touch_press.get());
 
   std::unique_ptr<ui::TouchEvent> touch_release;
   touch_release.reset(new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(),
-                                         initial_press_->touch_id(), Now()));
+                                         initial_press_->pointer_details().id,
+                                         Now()));
   touch_release->set_location_f(anchor_point_);
   touch_release->set_root_location_f(anchor_point_);
   DispatchEvent(touch_release.get());
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSlideGesture(
     const ui::TouchEvent& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   // The timer should not fire when sliding.
   tap_timer_.Stop();
 
   ui::EventType type = event.type();
   // If additional fingers are added before a swipe gesture has been registered,
   // then wait until all fingers have been lifted.
   if (type == ui::ET_TOUCH_PRESSED ||
-      event.touch_id() != initial_press_->touch_id()) {
+      event.pointer_details().id != initial_press_->pointer_details().id) {
     if (sound_timer_.IsRunning())
       sound_timer_.Stop();
     SET_STATE(WAIT_FOR_NO_FINGERS);
     return EVENT_REWRITE_DISCARD;
   }
 
   // There should not be more than one finger down.
   DCHECK_LE(current_touch_ids_.size(), 1U);
 
   // Allows user to return to the edge to adjust the sound if they have left the
@@ skipping 26 matching lines @@
     std::unique_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     // This is now a three finger gesture.
     SET_STATE(GESTURE_IN_PROGRESS);
     return ui::EVENT_REWRITE_DISCARD;
   }
 
   if (type == ui::ET_TOUCH_MOVED) {
     // Determine if it was a swipe.
-    gfx::Point original_location = initial_presses_[event.touch_id()];
+    gfx::Point original_location = initial_presses_[event.pointer_details().id];
     float distance = (event.location() - original_location).Length();
     // If the user moves too far from the original position, consider the
     // movement a swipe.
     if (distance > gesture_detector_config_.touch_slop) {
       SET_STATE(GESTURE_IN_PROGRESS);
     }
     return ui::EVENT_REWRITE_DISCARD;
   }
 
   if (current_touch_ids_.size() != 0)
@@ skipping 32 matching lines @@
     case TOUCH_EXPLORE_RELEASED:
       SET_STATE(NO_FINGERS_DOWN);
       last_touch_exploration_.reset(new TouchEvent(*initial_press_));
       anchor_point_ = last_touch_exploration_->location_f();
       anchor_point_state_ = ANCHOR_POINT_FROM_TOUCH_EXPLORATION;
       return;
     case DOUBLE_TAP_PENDING: {
       SET_STATE(ONE_FINGER_PASSTHROUGH);
       passthrough_offset_ =
           last_unused_finger_event_->location_f() - anchor_point_;
-      std::unique_ptr<ui::TouchEvent> passthrough_press(
-          new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(),
-                             last_unused_finger_event_->touch_id(), Now()));
+      std::unique_ptr<ui::TouchEvent> passthrough_press(new ui::TouchEvent(
+          ui::ET_TOUCH_PRESSED, gfx::Point(),
+          last_unused_finger_event_->pointer_details().id, Now()));
       passthrough_press->set_location_f(anchor_point_);
       passthrough_press->set_root_location_f(anchor_point_);
       DispatchEvent(passthrough_press.get());
       return;
     }
     case SINGLE_TAP_PRESSED:
       if (passthrough_timer_.IsRunning())
         return;
     case GESTURE_IN_PROGRESS:
       // If only one finger is down, go into touch exploration.
@@ skipping 21 matching lines @@
   anchor_point_state_ = ANCHOR_POINT_FROM_TOUCH_EXPLORATION;
 }
 
 void TouchExplorationController::OnPassthroughTimerFired() {
   // The passthrough timer will only fire if if the user has held a finger in
   // one of the passthrough corners for the duration of the passthrough timeout.
 
   // Check that initial press isn't null. Also a check that if the initial
   // corner press was released, then it should not be in corner passthrough.
   if (!initial_press_ ||
-      touch_locations_.find(initial_press_->touch_id()) !=
+      touch_locations_.find(initial_press_->pointer_details().id) !=
           touch_locations_.end()) {
   }
 
   gfx::Point location =
-      ToRoundedPoint(touch_locations_[initial_press_->touch_id()]);
+      ToRoundedPoint(touch_locations_[initial_press_->pointer_details().id]);
   int corner = FindEdgesWithinBounds(location, kSlopDistanceFromEdge);
   if (corner != BOTTOM_LEFT_CORNER && corner != BOTTOM_RIGHT_CORNER)
     return;
 
   if (sound_timer_.IsRunning())
     sound_timer_.Stop();
   delegate_->PlayPassthroughEarcon();
   SET_STATE(CORNER_PASSTHROUGH);
   return;
 }
@@ skipping 293 matching lines @@
   VLOG(1) << "\n Function name: " << function_name
           << "\n State: " << state_string;
 }
 
 void TouchExplorationController::VlogEvent(const ui::TouchEvent& touch_event,
                                            const char* function_name) {
   if (!VLOG_on_)
     return;
 
   if (prev_event_ && prev_event_->type() == touch_event.type() &&
-      prev_event_->touch_id() == touch_event.touch_id()) {
+      prev_event_->pointer_details().id == touch_event.pointer_details().id) {
     return;
   }
   // The above statement prevents events of the same type and id from being
   // printed in a row. However, if two fingers are down, they would both be
   // moving and alternating printing move events unless we check for this.
   if (prev_event_ && prev_event_->type() == ET_TOUCH_MOVED &&
       touch_event.type() == ET_TOUCH_MOVED) {
     return;
   }
 
   const std::string& type = touch_event.name();
   const gfx::PointF& location = touch_event.location_f();
-  const int touch_id = touch_event.touch_id();
+  const int touch_id = touch_event.pointer_details().id;
 
   VLOG(1) << "\n Function name: " << function_name << "\n Event Type: " << type
           << "\n Location: " << location.ToString()
           << "\n Touch ID: " << touch_id;
   prev_event_.reset(new TouchEvent(touch_event));
 }
 
 const char* TouchExplorationController::EnumStateToString(State state) {
   switch (state) {
     case NO_FINGERS_DOWN:
@@ skipping 26 matching lines @@
       return "TWO_FINGER_TAP";
   }
   return "Not a state";
 }
 
 float TouchExplorationController::GetSplitTapTouchSlop() {
   return gesture_detector_config_.touch_slop * 3;
 }
 
 }  // namespace ui