ui::GestureProvider gives GestureEventData the number of touch points.

ui/events/gesture_detection/gesture_provider.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/gesture_provider.h"
 
 #include <cmath>
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
@@ skipping 17 matching lines @@
     case MotionEvent::ACTION_MOVE:         return "ACTION_MOVE";
   }
   return "";
 }
 
 GestureEventData CreateGesture(EventType type,
                                int motion_event_id,
                                base::TimeTicks time,
                                float x,
                                float y,
+                               size_t touch_point_count,
                                const GestureEventDetails& details) {
-  return GestureEventData(type, motion_event_id, time, x, y, details);
+  return GestureEventData(type,
+                          motion_event_id,
+                          time,
+                          x,
+                          y,
+                          static_cast<int>(touch_point_count),
+                          details);
 }
 
 GestureEventData CreateGesture(EventType type,
                                int motion_event_id,
                                base::TimeTicks time,
                                float x,
-                               float y) {
-  return GestureEventData(type, motion_event_id, time, x, y);
+                               float y,
+                               size_t touch_point_count) {
+  return GestureEventData(
+      type, motion_event_id, time, x, y, static_cast<int>(touch_point_count));
 }
 
 GestureEventData CreateGesture(EventType type,
                                const MotionEvent& event,
                                const GestureEventDetails& details) {
   return CreateGesture(type,
                        event.GetId(),
                        event.GetEventTime(),
                        event.GetX(),
                        event.GetY(),
+                       event.GetPointerCount(),
                        details);
 }
 
 GestureEventData CreateGesture(EventType type,
                                const MotionEvent& event) {
-  return CreateGesture(
-      type, event.GetId(), event.GetEventTime(), event.GetX(), event.GetY());
+  return CreateGesture(type,
+                       event.GetId(),
+                       event.GetEventTime(),
+                       event.GetX(),
+                       event.GetY(),
+                       event.GetPointerCount());
 }
 
 GestureEventDetails CreateTapGestureDetails(EventType type,
                                             const MotionEvent& event) {
   // Set the tap count to 1 even for ET_GESTURE_DOUBLE_TAP, in order to be
   // consistent with double tap behavior on a mobile viewport. See
   // crbug.com/234986 for context.
   GestureEventDetails tap_details(type, 1, 0);
   tap_details.set_bounding_box(
       gfx::RectF(event.GetTouchMajor(), event.GetTouchMajor()));
@@ skipping 41 matching lines @@
     if (ignore_multitouch_events_ && !detector.InDoubleTapMode())
       return false;
     pinch_event_sent_ = false;
     return true;
   }
 
   virtual void OnScaleEnd(const ScaleGestureDetector& detector,
                           const MotionEvent& e) OVERRIDE {
     if (!pinch_event_sent_)
       return;
-    provider_->Send(CreateGesture(
-        ET_GESTURE_PINCH_END, e.GetId(), detector.GetEventTime(), 0, 0));
+    provider_->Send(CreateGesture(ET_GESTURE_PINCH_END,
+                                  e.GetId(),
+                                  detector.GetEventTime(),
+                                  0,
+                                  0,
+                                  e.GetPointerCount()));
     pinch_event_sent_ = false;
   }
 
   virtual bool OnScale(const ScaleGestureDetector& detector,
                        const MotionEvent& e) OVERRIDE {
     if (ignore_multitouch_events_ && !detector.InDoubleTapMode())
       return false;
     if (!pinch_event_sent_) {
       pinch_event_sent_ = true;
       provider_->Send(CreateGesture(ET_GESTURE_PINCH_BEGIN,
                                     e.GetId(),
                                     detector.GetEventTime(),
                                     detector.GetFocusX(),
-                                    detector.GetFocusY()));
+                                    detector.GetFocusY(),
+                                    e.GetPointerCount()));
     }
 
     float scale = detector.GetScaleFactor();
     if (scale == 1)
       return true;
 
     if (detector.InDoubleTapMode()) {
       // Relative changes in the double-tap scale factor computed by |detector|
       // diminish as the touch moves away from the original double-tap focus.
       // For historical reasons, Chrome has instead adopted a scale factor
       // computation that is invariant to the focal distance, where
       // the scale delta remains constant if the touch velocity is constant.
       float dy =
           (detector.GetCurrentSpanY() - detector.GetPreviousSpanY()) * 0.5f;
       scale = std::pow(scale > 1 ? 1.0f + kDoubleTapDragZoomSpeed
                                  : 1.0f - kDoubleTapDragZoomSpeed,
                        std::abs(dy * px_to_dp_));
     }
     GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE, scale, 0);
     provider_->Send(CreateGesture(ET_GESTURE_PINCH_UPDATE,
                                   e.GetId(),
                                   detector.GetEventTime(),
                                   detector.GetFocusX(),
                                   detector.GetFocusY(),
+                                  e.GetPointerCount(),
                                   pinch_details));
     return true;
   }
 
   void SetDoubleTapEnabled(bool enabled) {
     DCHECK(!IsDoubleTapInProgress());
     scale_gesture_detector_.SetQuickScaleEnabled(enabled);
   }
 
   void SetMultiTouchEnabled(bool value) {
@@ skipping 122 matching lines @@
       }
     }
 
     last_raw_x_ = e2.GetRawX();
     last_raw_y_ = e2.GetRawY();
     if (!provider_->IsScrollInProgress()) {
       // Note that scroll start hints are in distance traveled, where
       // scroll deltas are in the opposite direction.
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_BEGIN, -raw_distance_x, -raw_distance_y);
+
+      // Use the co-ordinates from the touch down, as these co-ordinates are
+      // used to determine which layer the scroll should affect.
       provider_->Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN,
                                     e2.GetId(),
                                     e2.GetEventTime(),
                                     e1.GetX(),
                                     e1.GetY(),
+                                    e2.GetPointerCount(),
                                     scroll_details));
     }
 
     // distance_x and distance_y is the scrolling offset since last OnScroll.
     // Because we are passing integers to Blink, this could introduce
     // rounding errors. The rounding errors will accumulate overtime.
     // To solve this, we should be adding back the rounding errors each time
     // when we calculate the new offset.
     // TODO(jdduke): Determine if we can simpy use floating point deltas, as
     // WebGestureEvent also takes floating point deltas for GestureScrollUpdate.
@@ skipping 211 matching lines @@
       gesture_begin_end_types_enabled_(config.gesture_begin_end_types_enabled) {
   DCHECK(client);
   InitGestureDetectors(config);
 }
 
 GestureProvider::~GestureProvider() {}
 
 bool GestureProvider::OnTouchEvent(const MotionEvent& event) {
   TRACE_EVENT1("input", "GestureProvider::OnTouchEvent",
                "action", GetMotionEventActionName(event.GetAction()));
+
+  DCHECK_NE(0u, event.GetPointerCount());
+
   if (!CanHandle(event))
     return false;
 
   const bool in_scale_gesture =
       scale_gesture_listener_->IsScaleGestureDetectionInProgress();
 
   OnTouchEventHandlingBegin(event);
   gesture_listener_->OnTouchEvent(event, in_scale_gesture);
   scale_gesture_listener_->OnTouchEvent(event);
   OnTouchEventHandlingEnd(event);
@@ skipping 108 matching lines @@
       DCHECK(!touch_scroll_in_progress_);
       touch_scroll_in_progress_ = true;
       break;
     case ET_GESTURE_SCROLL_END:
       DCHECK(touch_scroll_in_progress_);
       if (pinch_in_progress_)
         Send(CreateGesture(ET_GESTURE_PINCH_END,
                            gesture.motion_event_id,
                            gesture.time,
                            gesture.x,
-                           gesture.y));
+                           gesture.y,
+                           gesture.details.touch_points()));
       touch_scroll_in_progress_ = false;
       break;
     case ET_GESTURE_PINCH_BEGIN:
       DCHECK(!pinch_in_progress_);
       if (!touch_scroll_in_progress_)
         Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN,
                            gesture.motion_event_id,
                            gesture.time,
                            gesture.x,
-                           gesture.y));
+                           gesture.y,
+                           gesture.details.touch_points()));
       pinch_in_progress_ = true;
       break;
     case ET_GESTURE_PINCH_END:
       DCHECK(pinch_in_progress_);
       pinch_in_progress_ = false;
       break;
     case ET_GESTURE_SHOW_PRESS:
       // It's possible that a double-tap drag zoom (from ScaleGestureDetector)
       // will start before the press gesture fires (from GestureDetector), in
       // which case the press should simply be dropped.
@@ skipping 79 matching lines @@
         Send(CreateGesture(ET_GESTURE_END, event));
       break;
     case MotionEvent::ACTION_DOWN:
     case MotionEvent::ACTION_POINTER_DOWN:
     case MotionEvent::ACTION_MOVE:
       break;
   }
 }
 
 }  //  namespace ui