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 96 matching lines @@
 }
 
 void InputScrollElasticityController::ObserveWheelEventAndResult(
     const blink::WebMouseWheelEvent& wheel_event,
     const cc::InputHandlerScrollResult& scroll_result) {
   // We should only get PhaseMayBegin or PhaseBegan events while in the
   // Inactive or MomentumAnimated states, but in case we get bad input (e.g,
   // abbreviated by tab-switch), always re-set the state to ActiveScrolling
   // when those events are received.
   if (wheel_event.phase == blink::WebMouseWheelEvent::PhaseMayBegin ||
       wheel_event.phase == blink::WebMouseWheelEvent::PhaseBegan) {

[tdresser, 2016/03/02 18:26:53]

This change will regress this behavior, because we'll switch from using real
wheel event phases to using our fake phases, right?

[dtapuska, 2016/03/07 18:03:59]

There will always be a scroll begin, update, end.

So this logic has moved into the Scroll begin. Correct if we get a may begin in
the middle of current phase information it won't actually reset it to the
correct state; but I never saw incorrectly sequenced messages from OSX.

     scroll_velocity = gfx::Vector2dF();
     last_scroll_event_timestamp_ = base::TimeTicks();
     state_ = kStateActiveScroll;
     pending_overscroll_delta_ = gfx::Vector2dF();
     return;
   }
 
   gfx::Vector2dF event_delta(-wheel_event.deltaX, -wheel_event.deltaY);
   base::TimeTicks event_timestamp =
       base::TimeTicks() +
@@ skipping 32 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.inertial) {
+        if (state_ == kStateInactive)
+          state_ = kStateMomentumScroll;
+      } else {
+        scroll_velocity = gfx::Vector2dF();
+        last_scroll_event_timestamp_ = base::TimeTicks();
+        state_ = kStateActiveScroll;
+        pending_overscroll_delta_ = gfx::Vector2dF();
+      }
+      break;
+    }
+    case blink::WebInputEvent::GestureScrollEnd: {
+      switch (state_) {
+        case kStateMomentumAnimated:
+        case kStateInactive:
+          break;
+        case kStateActiveScroll:
+        case kStateMomentumScroll:
+          if (helper_->StretchAmount().IsZero()) {
+            EnterStateInactive();
+          } else {
+            EnterStateMomentumAnimated(event_timestamp);
+          }
+          break;
+      }
+      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;
+    }
+    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