Implement Wheel Gesture Scrolling on OSX.

ui/events/blink/input_scroll_elasticity_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/events/blink/input_scroll_elasticity_controller.h"
 
 #include <math.h>
 
 #include <algorithm>
 
@@ skipping 149 matching lines @@
                  blink::WebMouseWheelEvent::PhaseEnded) {
         EnterStateInactive();
       }
     case kStateMomentumAnimated:
       // The PhaseMayBegin and PhaseBegan cases are handled at the top of the
       // function.
       break;
   }
 }
 
+void InputScrollElasticityController::ObserveGestureEventAndResult(
+    const blink::WebGestureEvent& gesture_event,
+    const cc::InputHandlerScrollResult& scroll_result) {
+  base::TimeTicks event_timestamp =
+      base::TimeTicks() +
+      base::TimeDelta::FromSecondsD(gesture_event.timeStampSeconds);
+
+  switch (gesture_event.type) {
+    case blink::WebInputEvent::GestureScrollBegin: {
+      if (gesture_event.data.scrollBegin.synthetic)
+        return;
+      if (gesture_event.data.scrollBegin.inertial) {
+        if (state_ == kStateInactive)
+          state_ = kStateMomentumScroll;
+      } else if (gesture_event.data.scrollBegin.deltaHintUnits ==
+                 blink::WebGestureEvent::PrecisePixels) {
+        scroll_velocity = gfx::Vector2dF();
+        last_scroll_event_timestamp_ = base::TimeTicks();
+        state_ = kStateActiveScroll;
+        pending_overscroll_delta_ = gfx::Vector2dF();
+      }
+      break;
+    }
+    case blink::WebInputEvent::GestureScrollUpdate: {
+      gfx::Vector2dF event_delta(-gesture_event.data.scrollUpdate.deltaX,
+                                 -gesture_event.data.scrollUpdate.deltaY);
+      switch (state_) {
+        case kStateMomentumAnimated:
+        case kStateInactive:
+          break;
+        case kStateActiveScroll:
+        case kStateMomentumScroll:
+          UpdateVelocity(event_delta, event_timestamp);
+          Overscroll(event_delta, scroll_result.unused_scroll_delta);
+          if (gesture_event.data.scrollUpdate.inertial &&
+              !helper_->StretchAmount().IsZero()) {
+            EnterStateMomentumAnimated(event_timestamp);
+          }
+          break;
+      }
+      break;
+    }
+    case blink::WebInputEvent::GestureScrollEnd: {
+      if (gesture_event.data.scrollEnd.synthetic)
+        return;
+      switch (state_) {
+        case kStateMomentumAnimated:
+        case kStateInactive:
+          break;
+        case kStateActiveScroll:
+        case kStateMomentumScroll:
+          if (helper_->StretchAmount().IsZero()) {
+            EnterStateInactive();
+          } else {
+            EnterStateMomentumAnimated(event_timestamp);
+          }
+          break;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
 void InputScrollElasticityController::UpdateVelocity(
     const gfx::Vector2dF& event_delta,
     const base::TimeTicks& event_timestamp) {
   float time_delta =
       (event_timestamp - last_scroll_event_timestamp_).InSecondsF();
   if (time_delta < kScrollVelocityZeroingTimeout && time_delta > 0) {
     scroll_velocity = gfx::Vector2dF(event_delta.x() / time_delta,
                                      event_delta.y() / time_delta);
   } else {
     scroll_velocity = gfx::Vector2dF();
@@ skipping 229 matching lines @@
       break;
     default:
       // These cases should not be hit because the stretch must be zero in the
       // Inactive and MomentumScroll states.
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace ui