Also pass unclamped delta and velocity values to GestureEventDetails. (DEPRECATED)

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 300 matching lines @@
       seen_first_scroll_event_ = true;
       double distance =
           std::sqrt(distance_x * distance_x + distance_y * distance_y);
       double epsilon = 1e-3;
       if (distance > epsilon) {
         double ratio = std::max(0., distance - touch_slop_) / distance;
         distance_x *= ratio;
         distance_y *= ratio;
       }
     }
+
+    float ordinal_distance_x = distance_x;

[jdduke (slow), 2014/04/24 19:58:53]

Nit: Let's make these const above and below suggesting they're unmodified. Also,
do you want the slop removed? 

+    float ordinal_distance_y = distance_y;
+
     snap_scroll_controller_.UpdateSnapScrollMode(distance_x, distance_y);
     if (snap_scroll_controller_.IsSnappingScrolls()) {
       if (snap_scroll_controller_.IsSnapHorizontal()) {
         distance_y = 0;
       } else {
         distance_x = 0;
       }
     }
 
     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(),
                                     GetBoundingBox(e2),
                                     scroll_details));
     }
 
     if (distance_x || distance_y) {
-      GestureEventDetails scroll_details(
-          ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
+      GestureEventDetails scroll_details(ET_GESTURE_SCROLL_UPDATE,
+                                         -distance_x,
+                                         -distance_y,
+                                         -ordinal_distance_x,
+                                         -ordinal_distance_y);
       provider_->Send(
           CreateGesture(ET_GESTURE_SCROLL_UPDATE, e2, scroll_details));
     }
 
     return true;
   }
 
   virtual bool OnFling(const MotionEvent& e1,
                        const MotionEvent& e2,
                        float velocity_x,
                        float velocity_y) OVERRIDE {
+    float ordinal_velocity_x = velocity_x;
+    float ordinal_velocity_y = velocity_y;
+
     if (snap_scroll_controller_.IsSnappingScrolls()) {
       if (snap_scroll_controller_.IsSnapHorizontal()) {
         velocity_y = 0;
       } else {
         velocity_x = 0;
       }
     }
 
-    provider_->Fling(e2, velocity_x, velocity_y);
+    provider_->Fling(
+        e2, velocity_x, velocity_y, ordinal_velocity_x, ordinal_velocity_y);
     return true;
   }
 
   virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
     provider_->Send(
         CreateGesture(ET_GESTURE_SHOW_PRESS, e, show_press_details));
   }
 
   virtual bool OnSingleTapUp(const MotionEvent& e) OVERRIDE {
@@ skipping 199 matching lines @@
 
   UpdateDoubleTapDetectionSupport();
 }
 
 bool GestureProvider::CanHandle(const MotionEvent& event) const {
   return event.GetAction() == MotionEvent::ACTION_DOWN || current_down_event_;
 }
 
 void GestureProvider::Fling(const MotionEvent& event,
                             float velocity_x,
-                            float velocity_y) {
+                            float velocity_y,
+                            float ordinal_velocity_x,
+                            float ordinal_velocity_y) {
   if (!velocity_x && !velocity_y) {
     EndTouchScrollIfNecessary(event, true);
     return;
   }
 
   if (!touch_scroll_in_progress_) {
     // The native side needs a ET_GESTURE_SCROLL_BEGIN before
     // ET_SCROLL_FLING_START to send the fling to the correct target. Send if it
     // has not sent.  The distance traveled in one second is a reasonable scroll
     // start hint.
     GestureEventDetails scroll_details(
         ET_GESTURE_SCROLL_BEGIN, velocity_x, velocity_y);
     Send(CreateGesture(ET_GESTURE_SCROLL_BEGIN, event, scroll_details));
   }
   EndTouchScrollIfNecessary(event, false);
 
-  GestureEventDetails fling_details(
-      ET_SCROLL_FLING_START, velocity_x, velocity_y);
+  GestureEventDetails fling_details(ET_SCROLL_FLING_START,
+                                    velocity_x,
+                                    velocity_y,
+                                    ordinal_velocity_x,
+                                    ordinal_velocity_y);
   Send(CreateGesture(
       ET_SCROLL_FLING_START, event, fling_details));
 }
 
 void GestureProvider::Send(const GestureEventData& gesture) {
   DCHECK(!gesture.time.is_null());
   // The only valid events that should be sent without an active touch sequence
   // are SHOW_PRESS and TAP, potentially triggered by the double-tap
   // delay timing out.
   DCHECK(current_down_event_ || gesture.type == ET_GESTURE_TAP ||
@@ skipping 127 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