Store the id of a contributing motion event in GestureEventData

ui/events/gesture_detection/scale_gesture_detector.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/events/gesture_detection/scale_gesture_detector.h"
 
 #include <limits.h>
 #include <cmath>
 
 #include "base/float_util.h"
@@ skipping 15 matching lines @@
 // Note: These constants were taken directly from the default (unscaled)
 // versions found in Android's ViewConfiguration.
 ScaleGestureDetector::Config::Config()
     : quick_scale_enabled(true),
       min_scaling_touch_major(48),
       min_scaling_span(200) {}
 
 ScaleGestureDetector::Config::~Config() {}
 
 bool ScaleGestureDetector::SimpleScaleGestureListener::OnScale(
-    const ScaleGestureDetector&) {
+    const ScaleGestureDetector&, const MotionEvent&) {
   return false;
 }
 
 bool ScaleGestureDetector::SimpleScaleGestureListener::OnScaleBegin(
-    const ScaleGestureDetector&) {
+    const ScaleGestureDetector&, const MotionEvent&) {
   return true;
 }
 
 void ScaleGestureDetector::SimpleScaleGestureListener::OnScaleEnd(
-    const ScaleGestureDetector&) {}
+    const ScaleGestureDetector&, const MotionEvent&) {}
 
 ScaleGestureDetector::ScaleGestureDetector(const Config& config,
                                            ScaleGestureListener* listener)
     : listener_(listener),
       config_(config),
       focus_x_(0),
       focus_y_(0),
       quick_scale_enabled_(false),
       curr_span_(0),
       prev_span_(0),
@@ skipping 35 matching lines @@
   }
 
   const bool stream_complete =
       action == MotionEvent::ACTION_UP || action == MotionEvent::ACTION_CANCEL;
 
   if (action == MotionEvent::ACTION_DOWN || stream_complete) {
     // Reset any scale in progress with the listener.
     // If it's an ACTION_DOWN we're beginning a new event stream.
     // This means the app probably didn't give us all the events. Shame on it.
     if (in_progress_) {
-      listener_->OnScaleEnd(*this);
+      listener_->OnScaleEnd(*this, event);
       in_progress_ = false;
       initial_span_ = 0;
       double_tap_mode_ = DOUBLE_TAP_MODE_NONE;
     } else if (double_tap_mode_ == DOUBLE_TAP_MODE_IN_PROGRESS &&
                stream_complete) {
       in_progress_ = false;
       initial_span_ = 0;
       double_tap_mode_ = DOUBLE_TAP_MODE_NONE;
     }
 
@@ skipping 67 matching lines @@
   }
 
   // Dispatch begin/end events as needed.
   // If the configuration changes, notify the app to reset its current state by
   // beginning a fresh scale event stream.
   const bool was_in_progress = in_progress_;
   focus_x_ = focus_x;
   focus_y_ = focus_y;
   if (!InDoubleTapMode() && in_progress_ &&
       (span < min_span_ || config_changed)) {
-    listener_->OnScaleEnd(*this);
+    listener_->OnScaleEnd(*this, event);
     in_progress_ = false;
     initial_span_ = span;
     double_tap_mode_ = DOUBLE_TAP_MODE_NONE;
   }
   if (config_changed) {
     prev_span_x_ = curr_span_x_ = span_x;
     prev_span_y_ = curr_span_y_ = span_y;
     initial_span_ = prev_span_ = curr_span_ = span;
   }
 
   const int min_span = InDoubleTapMode() ? span_slop_ : min_span_;
   if (!in_progress_ && span >= min_span &&
       (was_in_progress || std::abs(span - initial_span_) > span_slop_)) {
     prev_span_x_ = curr_span_x_ = span_x;
     prev_span_y_ = curr_span_y_ = span_y;
     prev_span_ = curr_span_ = span;
     prev_time_ = curr_time_;
-    in_progress_ = listener_->OnScaleBegin(*this);
+    in_progress_ = listener_->OnScaleBegin(*this, event);
   }
 
   // Handle motion; focal point and span/scale factor are changing.
   if (action == MotionEvent::ACTION_MOVE) {
     curr_span_x_ = span_x;
     curr_span_y_ = span_y;
     curr_span_ = span;
 
     bool update_prev = true;
 
     if (in_progress_) {
-      update_prev = listener_->OnScale(*this);
+      update_prev = listener_->OnScale(*this, event);
     }
 
     if (update_prev) {
       prev_span_x_ = curr_span_x_;
       prev_span_y_ = curr_span_y_;
       prev_span_ = curr_span_;
       prev_time_ = curr_time_;
     }
   }
 
@@ skipping 127 matching lines @@
 
 void ScaleGestureDetector::ClearTouchHistory() {
   touch_upper_ = std::numeric_limits<float>::quiet_NaN();
   touch_lower_ = std::numeric_limits<float>::quiet_NaN();
   touch_history_last_accepted_ = std::numeric_limits<float>::quiet_NaN();
   touch_history_direction_ = 0;
   touch_history_last_accepted_time_ = base::TimeTicks();
 }
 
 }  // namespace ui