First Implementation of Snapped Points

ui/events/blink/input_handler_proxy.cc

 // Copyright 2013 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_handler_proxy.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 907 matching lines @@
 
   return scroll_result.did_scroll ? DID_HANDLE : DROP_EVENT;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureScrollEnd(
   const WebGestureEvent& gesture_event) {
 #ifndef NDEBUG
   DCHECK(expect_scroll_update_end_);
   expect_scroll_update_end_ = false;
 #endif
+  input_handler_->SnapAfterGestureScroll(
+      gfx::Point(gesture_event.x, gesture_event.y));
+
   if (ShouldAnimate(gesture_event.data.scroll_end.delta_units !=
                     blink::WebGestureEvent::ScrollUnits::kPixels)) {
     // Do nothing if the scroll is being animated; the scroll animation will
     // generate the ScrollEnd when it is done.
   } else {
     cc::ScrollState scroll_state = CreateScrollStateForGesture(gesture_event);
     input_handler_->ScrollEnd(&scroll_state);
   }
+
   if (!gesture_scroll_on_impl_thread_)
     return DID_NOT_HANDLE;
 
   if (scroll_elasticity_controller_)
     HandleScrollElasticityOverscroll(gesture_event,
                                      cc::InputHandlerScrollResult());
 
   gesture_scroll_on_impl_thread_ = false;
   return DID_HANDLE;
 }
@@ skipping 56 matching lines @@
       // Note that the timestamp will only be used to kickstart the animation if
       // its sufficiently close to the timestamp of the first call |Animate()|.
       has_fling_animation_started_ = false;
       fling_parameters_.start_time = gesture_event.TimeStampSeconds();
       fling_parameters_.delta = WebFloatPoint(vx, vy);
       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
       fling_parameters_.global_point =
           WebPoint(gesture_event.global_x, gesture_event.global_y);
       fling_parameters_.modifiers = gesture_event.GetModifiers();
       fling_parameters_.source_device = gesture_event.source_device;
-      RequestAnimation();
+      if (AdjustFlingCurveToSnapPoints())
+        RequestAnimation();
+      else
+        fling_curve_.reset();
       return DID_HANDLE;
     }
     case cc::InputHandler::SCROLL_UNKNOWN:
     case cc::InputHandler::SCROLL_ON_MAIN_THREAD: {
       TRACE_EVENT_INSTANT0("input,rail",
                            "InputHandlerProxy::HandleGestureFling::"
                            "scroll_on_main_thread",
                            TRACE_EVENT_SCOPE_THREAD);
       gesture_scroll_on_impl_thread_ = false;
       fling_may_be_active_on_main_thread_ = true;
@@ skipping 261 matching lines @@
 void InputHandlerProxy::ExtendBoostedFlingTimeout(
     const blink::WebGestureEvent& event) {
   TRACE_EVENT_INSTANT0("input",
                        "InputHandlerProxy::ExtendBoostedFlingTimeout",
                        TRACE_EVENT_SCOPE_THREAD);
   deferred_fling_cancel_time_seconds_ =
       event.TimeStampSeconds() + kFlingBoostTimeoutDelaySeconds;
   last_fling_boost_event_ = event;
 }
 
+bool InputHandlerProxy::AdjustFlingCurveToSnapPoints() {
+  gfx::Vector2dF original_offset;
+  fling_curve_->ComputeTotalScrollOffset(original_offset);
+  gfx::Vector2dF snapped_offset;
+  input_handler_->FindSnappedOffset(&snapped_offset, original_offset);
+  return fling_curve_->ResetCurveBySnappedOffset(snapped_offset);
+}
+
 void InputHandlerProxy::Animate(base::TimeTicks time) {
   // If using synchronous animate, then only expect Animate attempts started by
   // the synchronous system. Don't let the InputHandler try to Animate also.
   DCHECK(!input_handler_->IsCurrentlyScrollingViewport() ||
          allow_root_animate_);
 
   if (scroll_elasticity_controller_)
     scroll_elasticity_controller_->Animate(time);
 
   if (!fling_curve_)
@@ skipping 357 matching lines @@
                  scroll_elasticity_controller_->GetWeakPtr(), gesture_event,
                  scroll_result));
 }
 
 void InputHandlerProxy::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   tick_clock_ = std::move(tick_clock);
 }
 
 }  // namespace ui