Overscroll and Elasticity for views::ScrollView

ui/events/blink/input_scroll_elasticity_controller.cc

Index: ui/events/blink/input_scroll_elasticity_controller.cc
diff --git a/ui/events/blink/input_scroll_elasticity_controller.cc b/ui/events/blink/input_scroll_elasticity_controller.cc
index 744c1bcf24745f661ed5d26eaa272852bf7cfd0f..4ee09c081a2c350daa9dba9f02e48b702f8d78f0 100644
--- a/ui/events/blink/input_scroll_elasticity_controller.cc
+++ b/ui/events/blink/input_scroll_elasticity_controller.cc
@@ -88,13 +88,11 @@ gfx::Vector2d StretchScrollForceForStretchAmount(const gfx::Vector2dF& delta) {
 
 }  // namespace
 
-InputScrollElasticityController::InputScrollElasticityController(
-    cc::ScrollElasticityHelper* helper)
-    : helper_(helper),
+InputScrollElasticityController::InputScrollElasticityController()
+    : helper_(nullptr),
       state_(kStateInactive),
       momentum_animation_reset_at_next_frame_(false),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 InputScrollElasticityController::~InputScrollElasticityController() {
 }
@@ -106,6 +104,60 @@ InputScrollElasticityController::GetWeakPtr() {
   return base::WeakPtr<InputScrollElasticityController>();
 }
 
+void InputScrollElasticityController::SetActiveHelper(
+    const base::WeakPtr<cc::ScrollElasticityHelper>& helper) {
+  if (helper_.get() == helper.get())
+    return;
+
+  if (helper_) {
+    helper_->SetStretchAmount(gfx::Vector2dF());
+    if (state_ != kStateInactive)
+      EnterStateInactive();
+  }
+
+  helper_ = helper;
+}
+
+void InputScrollElasticityController::ObserveRealScrollBegin(
+    bool enter_momentum,
+    bool leave_momentum) {
+  if (enter_momentum) {
+    if (state_ == kStateInactive)
+      state_ = kStateMomentumScroll;
+  } else if (leave_momentum) {
+    scroll_velocity = gfx::Vector2dF();
+    last_scroll_event_timestamp_ = base::TimeTicks();
+    state_ = kStateActiveScroll;
+    pending_overscroll_delta_ = gfx::Vector2dF();
+  }
+}
+
+void InputScrollElasticityController::ObserveScrollUpdate(
+    const gfx::Vector2dF& event_delta,
+    const gfx::Vector2dF& unused_scroll_delta,
+    const base::TimeTicks& event_timestamp,
+    bool has_momentum) {
+  if (state_ == kStateMomentumAnimated || state_ == kStateInactive)
+    return;
+
+  UpdateVelocity(event_delta, event_timestamp);
+  Overscroll(event_delta, unused_scroll_delta);
+  if (has_momentum && !helper_->StretchAmount().IsZero())
+    EnterStateMomentumAnimated(event_timestamp);
+}
+
+void InputScrollElasticityController::ObserveRealScrollEnd(
+    const base::TimeTicks& event_timestamp) {
+  if (state_ == kStateMomentumAnimated || state_ == kStateInactive)
+    return;
+
+  if (helper_->StretchAmount().IsZero()) {
+    EnterStateInactive();
+  } else {
+    EnterStateMomentumAnimated(event_timestamp);
+  }
+}
+
 void InputScrollElasticityController::ObserveGestureEventAndResult(
     const blink::WebGestureEvent& gesture_event,
     const cc::InputHandlerScrollResult& scroll_result) {
@@ -117,57 +169,28 @@ void InputScrollElasticityController::ObserveGestureEventAndResult(
     case blink::WebInputEvent::GestureScrollBegin: {
       if (gesture_event.data.scrollBegin.synthetic)
         return;
-      if (gesture_event.data.scrollBegin.inertialPhase ==
-          blink::WebGestureEvent::MomentumPhase) {
-        if (state_ == kStateInactive)
-          state_ = kStateMomentumScroll;
-      } else if (gesture_event.data.scrollBegin.inertialPhase ==
-                     blink::WebGestureEvent::NonMomentumPhase &&
-                 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();
-      }
+      bool enter_momentum = gesture_event.data.scrollBegin.inertialPhase ==
+                            blink::WebGestureEvent::MomentumPhase;
+      bool leave_momentum = gesture_event.data.scrollBegin.inertialPhase ==
+                                blink::WebGestureEvent::NonMomentumPhase &&
+                            gesture_event.data.scrollBegin.deltaHintUnits ==
+                                blink::WebGestureEvent::PrecisePixels;
+      ObserveRealScrollBegin(enter_momentum, leave_momentum);
       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.inertialPhase ==
-                  blink::WebGestureEvent::MomentumPhase &&
-              !helper_->StretchAmount().IsZero()) {
-            EnterStateMomentumAnimated(event_timestamp);
-          }
-          break;
-      }
+      bool has_momentum = gesture_event.data.scrollUpdate.inertialPhase ==
+                          blink::WebGestureEvent::MomentumPhase;
+      ObserveScrollUpdate(event_delta, scroll_result.unused_scroll_delta,
+                          event_timestamp, has_momentum);
       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;
-      }
+      ObserveRealScrollEnd(event_timestamp);
       break;
     }
     default:
@@ -369,6 +392,11 @@ bool InputScrollElasticityController::CanScrollVertically() const {
 }
 
 void InputScrollElasticityController::ReconcileStretchAndScroll() {
+  // If there has been no scroll, or the last elastic-scrolling layer has been
+  // removed from the tree, then there will be no |helper_|.
+  if (!helper_)
+    return;
+
   gfx::Vector2dF stretch = helper_->StretchAmount();
   if (stretch.IsZero())
     return;