[Android] Map raw touch coordinates to global gesture locations

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 29 matching lines @@
                             diameter));
   }
   return bounds;
 }
 
 GestureEventData CreateGesture(const GestureEventDetails& details,
                                int motion_event_id,
                                base::TimeTicks time,
                                float x,
                                float y,
+                               float raw_x,
+                               float raw_y,
                                size_t touch_point_count,
                                const gfx::RectF& bounding_box) {
   return GestureEventData(details,
                           motion_event_id,
                           time,
                           x,
                           y,
-                          static_cast<int>(touch_point_count),
+                          raw_x,
+                          raw_y,
+                          touch_point_count,
                           bounding_box);
 }
 
 GestureEventData CreateGesture(EventType type,
                                int motion_event_id,
                                base::TimeTicks time,
                                float x,
                                float y,
+                               float raw_x,
+                               float raw_y,
                                size_t touch_point_count,
                                const gfx::RectF& bounding_box) {
-  return GestureEventData(type,
+  return GestureEventData(GestureEventDetails(type, 0, 0),
                           motion_event_id,
                           time,
                           x,
                           y,
-                          static_cast<int>(touch_point_count),
+                          raw_x,
+                          raw_y,
+                          touch_point_count,
                           bounding_box);
 }
 
 GestureEventData CreateGesture(const GestureEventDetails& details,
                                const MotionEvent& event) {
-  return CreateGesture(details,
-                       event.GetId(),
-                       event.GetEventTime(),
-                       event.GetX(),
-                       event.GetY(),
-                       event.GetPointerCount(),
-                       GetBoundingBox(event));
+  return GestureEventData(details,
+                          event.GetId(),
+                          event.GetEventTime(),
+                          event.GetX(),
+                          event.GetY(),
+                          event.GetRawX(),
+                          event.GetRawY(),
+                          event.GetPointerCount(),
+                          GetBoundingBox(event));
 }
 
-GestureEventData CreateGesture(EventType type,
-                               const MotionEvent& event) {
-  return CreateGesture(type,
-                       event.GetId(),
-                       event.GetEventTime(),
-                       event.GetX(),
-                       event.GetY(),
-                       event.GetPointerCount(),
-                       GetBoundingBox(event));
+GestureEventData CreateGesture(EventType type, const MotionEvent& event) {
+  return CreateGesture(GestureEventDetails(type, 0, 0), event);
 }
 
 GestureEventDetails CreateTapGestureDetails(EventType type) {
   // 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);
   return tap_details;
 }
 
@@ skipping 40 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,
-                                  e.GetPointerCount(),
-                                  GetBoundingBox(e)));
+    provider_->Send(CreateGesture(ET_GESTURE_PINCH_END, e));
     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.GetFocusX() + e.GetRawOffsetX(),
+                                    detector.GetFocusY() + e.GetRawOffsetY(),
                                     e.GetPointerCount(),
                                     GetBoundingBox(e)));
     }
 
     if (std::abs(detector.GetCurrentSpan() - detector.GetPreviousSpan()) <
         min_pinch_update_span_delta_) {
       return false;
     }
 
     float scale = detector.GetScaleFactor();
@@ skipping 11 matching lines @@
       scale = std::pow(scale > 1 ? 1.0f + kDoubleTapDragZoomSpeed
                                  : 1.0f - kDoubleTapDragZoomSpeed,
                        std::abs(dy));
     }
     GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE, scale, 0);
     provider_->Send(CreateGesture(pinch_details,
                                   e.GetId(),
                                   detector.GetEventTime(),
                                   detector.GetFocusX(),
                                   detector.GetFocusY(),
+                                  detector.GetFocusX() + e.GetRawOffsetX(),
+                                  detector.GetFocusY() + e.GetRawOffsetY(),
                                   e.GetPointerCount(),
                                   GetBoundingBox(e)));
     return true;
   }
 
   void SetDoubleTapEnabled(bool enabled) {
     DCHECK(!IsDoubleTapInProgress());
     scale_gesture_detector_.SetQuickScaleEnabled(enabled);
   }
 
@@ skipping 119 matching lines @@
       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(scroll_details,
                                     e2.GetId(),
                                     e2.GetEventTime(),
                                     e1.GetX(),
                                     e1.GetY(),
+                                    e1.GetRawX(),
+                                    e1.GetRawY(),
                                     e2.GetPointerCount(),
                                     GetBoundingBox(e2)));
     }
 
     if (distance_x || distance_y) {
       const gfx::RectF bounding_box = GetBoundingBox(e2);
+      const gfx::PointF center = bounding_box.CenterPoint();
+      const gfx::PointF raw_center =
+          center + gfx::Vector2dF(e2.GetRawOffsetX(), e2.GetRawOffsetY());
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
       provider_->Send(CreateGesture(scroll_details,
                                     e2.GetId(),
                                     e2.GetEventTime(),
-                                    bounding_box.CenterPoint().x(),
-                                    bounding_box.CenterPoint().y(),
+                                    center.x(),
+                                    center.y(),
+                                    raw_center.x(),
+                                    raw_center.y(),
                                     e2.GetPointerCount(),
                                     bounding_box));
     }
 
     return true;
   }
 
   virtual bool OnFling(const MotionEvent& e1,
                        const MotionEvent& e2,
                        float velocity_x,
@@ skipping 24 matching lines @@
     // The location of the two finger tap event should be the location of the
     // primary pointer.
     GestureEventDetails two_finger_tap_details(ET_GESTURE_TWO_FINGER_TAP,
                                                e1.GetTouchMajor(),
                                                e1.GetTouchMajor());
     provider_->Send(CreateGesture(two_finger_tap_details,
                                   e2.GetId(),
                                   e2.GetEventTime(),
                                   e1.GetX(),
                                   e1.GetY(),
+                                  e1.GetRawX(),
+                                  e1.GetRawY(),
                                   e2.GetPointerCount(),
                                   GetBoundingBox(e2)));
     return true;
   }
 
   virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
     provider_->Send(CreateGesture(show_press_details, e));
   }
 
@@ skipping 249 matching lines @@
     case ET_GESTURE_LONG_TAP:
       current_longpress_time_ = base::TimeTicks();
       break;
     case ET_GESTURE_SCROLL_BEGIN:
       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.details.touch_points(),
-                           gesture.details.bounding_box()));
+        Send(GestureEventData(ET_GESTURE_PINCH_END, gesture));
       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.details.touch_points(),
-                           gesture.details.bounding_box()));
+        Send(GestureEventData(ET_GESTURE_SCROLL_BEGIN, gesture));
       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 31 matching lines @@
     case MotionEvent::ACTION_DOWN:
       current_down_event_ = event.Clone();
       touch_scroll_in_progress_ = false;
       pinch_in_progress_ = false;
       current_longpress_time_ = base::TimeTicks();
       if (gesture_begin_end_types_enabled_)
         Send(CreateGesture(ET_GESTURE_BEGIN, event));
       break;
     case MotionEvent::ACTION_POINTER_DOWN:
       if (gesture_begin_end_types_enabled_) {
+        const int action_index = event.GetActionIndex();
         Send(CreateGesture(ET_GESTURE_BEGIN,
                            event.GetId(),
                            event.GetEventTime(),
-                           event.GetX(event.GetActionIndex()),
-                           event.GetY(event.GetActionIndex()),
+                           event.GetX(action_index),
+                           event.GetY(action_index),
+                           event.GetRawX(action_index),
+                           event.GetRawY(action_index),
                            event.GetPointerCount(),
                            GetBoundingBox(event)));
       }
       break;
     case MotionEvent::ACTION_POINTER_UP:
     case MotionEvent::ACTION_UP:
     case MotionEvent::ACTION_CANCEL:
     case MotionEvent::ACTION_MOVE:
       break;
   }
 }
 
 void GestureProvider::OnTouchEventHandlingEnd(const MotionEvent& event) {
   switch (event.GetAction()) {
     case MotionEvent::ACTION_UP:
     case MotionEvent::ACTION_CANCEL: {
       // Note: This call will have no effect if a fling was just generated, as
       // |Fling()| will have already signalled an end to touch-scrolling.
       EndTouchScrollIfNecessary(event, true);
 
       const gfx::RectF bounding_box = GetBoundingBox(event);
 
       if (gesture_begin_end_types_enabled_) {
         for (size_t i = 0; i < event.GetPointerCount(); ++i) {
           Send(CreateGesture(ET_GESTURE_END,
                              event.GetId(),
                              event.GetEventTime(),
                              event.GetX(i),
                              event.GetY(i),
+                             event.GetRawX(i),
+                             event.GetRawY(i),
                              event.GetPointerCount() - i,
                              bounding_box));
         }
       }
 
       current_down_event_.reset();
 
       UpdateDoubleTapDetectionSupport();
       break;
     }
@@ skipping 15 matching lines @@
   if (current_down_event_)
     return;
 
   const bool double_tap_enabled = double_tap_support_for_page_ &&
                                   double_tap_support_for_platform_;
   gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
   scale_gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui