Overscroll and Elasticity for views::ScrollView

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 70 matching lines @@
   return gfx::ToRoundedVector2d(gfx::ScaleVector2d(delta, 1.0f / stiffness));
 }
 
 gfx::Vector2d StretchScrollForceForStretchAmount(const gfx::Vector2dF& delta) {
   return gfx::ToRoundedVector2d(
       gfx::ScaleVector2d(delta, kRubberbandStiffness));
 }
 
 }  // 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() {
 }
 
 base::WeakPtr<InputScrollElasticityController>
 InputScrollElasticityController::GetWeakPtr() {
   if (helper_)
     return weak_factory_.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) {
   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.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:
       break;
   }
 }
 
 void InputScrollElasticityController::UpdateVelocity(
     const gfx::Vector2dF& event_delta,
     const base::TimeTicks& event_timestamp) {
@@ skipping 181 matching lines @@
 
 bool InputScrollElasticityController::CanScrollHorizontally() const {
   return helper_->MaxScrollOffset().x() > 0;
 }
 
 bool InputScrollElasticityController::CanScrollVertically() const {
   return helper_->MaxScrollOffset().y() > 0;
 }
 
 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;
 
   gfx::ScrollOffset scroll_offset = helper_->ScrollOffset();
   gfx::ScrollOffset max_scroll_offset = helper_->MaxScrollOffset();
 
   // Compute stretch_adjustment which will be added to |stretch| and subtracted
   // from the |scroll_offset|.
   gfx::Vector2dF stretch_adjustment;
@@ skipping 35 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