Early terminate flings when scrolling impossible

content/renderer/input/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 "content/renderer/input/input_handler_proxy.h"
 
+#include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "content/common/input/did_overscroll_params.h"
 #include "content/common/input/web_input_event_traits.h"
 #include "content/renderer/input/input_handler_proxy_client.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/geometry/point_conversions.h"
 
 using blink::WebFloatPoint;
 using blink::WebFloatSize;
@@ skipping 348 matching lines @@
                          TRACE_EVENT_SCOPE_THREAD);
     CancelCurrentFling(true);
   }
 }
 
 void InputHandlerProxy::MainThreadHasStoppedFlinging() {
   fling_may_be_active_on_main_thread_ = false;
   client_->DidStopFlinging();
 }
 
-void InputHandlerProxy::DidOverscroll(const cc::DidOverscrollParams& params) {
+void InputHandlerProxy::DidOverscroll(
+    const gfx::Vector2dF& accumulated_overscroll,
+    const gfx::Vector2dF& latest_overscroll_delta) {
   DCHECK(client_);
+
+  DidOverscrollParams params;
+  params.accumulated_overscroll = accumulated_overscroll;
+  params.latest_overscroll_delta = latest_overscroll_delta;
+  params.current_fling_velocity = current_fling_velocity_;
+
   if (fling_curve_) {
     static const int kFlingOverscrollThreshold = 1;
     disallow_horizontal_fling_scroll_ |=
         std::abs(params.accumulated_overscroll.x()) >=
         kFlingOverscrollThreshold;
     disallow_vertical_fling_scroll_ |=
         std::abs(params.accumulated_overscroll.y()) >=
         kFlingOverscrollThreshold;
   }
 
@@ skipping 12 matching lines @@
         this);
   }
 
   TRACE_EVENT_INSTANT1("input",
                        "InputHandlerProxy::CancelCurrentFling",
                        TRACE_EVENT_SCOPE_THREAD,
                        "had_fling_animation",
                        had_fling_animation);
   fling_curve_.reset();
   gesture_scroll_on_impl_thread_ = false;
+  current_fling_velocity_ = gfx::Vector2dF();
   fling_parameters_ = blink::WebActiveWheelFlingParameters();
   if (send_fling_stopped_notification && had_fling_animation)
     client_->DidStopFlinging();
   return had_fling_animation;
 }
 
 bool InputHandlerProxy::TouchpadFlingScroll(
     const WebFloatSize& increment) {
   WebMouseWheelEvent synthetic_wheel;
   synthetic_wheel.type = WebInputEvent::MouseWheel;
@@ skipping 29 matching lines @@
       break;
   }
 
   return false;
 }
 
 static gfx::Vector2dF ToClientScrollIncrement(const WebFloatSize& increment) {
   return gfx::Vector2dF(-increment.width, -increment.height);
 }
 
-void InputHandlerProxy::scrollBy(const WebFloatSize& increment) {
+bool InputHandlerProxy::scrollBy(const WebFloatSize& increment,
+                                 const WebFloatSize& velocity) {
   WebFloatSize clipped_increment;
-  if (!disallow_horizontal_fling_scroll_)
+  WebFloatSize clipped_velocity;
+  if (!disallow_horizontal_fling_scroll_) {
     clipped_increment.width = increment.width;
-  if (!disallow_vertical_fling_scroll_)
+    clipped_velocity.width = velocity.width;
+  }
+  if (!disallow_vertical_fling_scroll_) {
     clipped_increment.height = increment.height;
+    clipped_velocity.height = velocity.height;
+  }
 
+  current_fling_velocity_ = clipped_velocity;
   if (clipped_increment == WebFloatSize())
-    return;
+    return false;
 
   TRACE_EVENT2("input",
                "InputHandlerProxy::scrollBy",
                "x",
                clipped_increment.width,
                "y",
                clipped_increment.height);
 
   bool did_scroll = false;
 
   switch (fling_parameters_.sourceDevice) {
     case WebGestureEvent::Touchpad:
       did_scroll = TouchpadFlingScroll(clipped_increment);
       break;
     case WebGestureEvent::Touchscreen:
       clipped_increment = ToClientScrollIncrement(clipped_increment);
+      clipped_velocity = ToClientScrollIncrement(clipped_velocity);
       did_scroll = input_handler_->ScrollBy(fling_parameters_.point,
                                             clipped_increment);
       break;
   }
 
   if (did_scroll) {
     fling_parameters_.cumulativeScroll.width += clipped_increment.width;
     fling_parameters_.cumulativeScroll.height += clipped_increment.height;
   }
-}
 
-void InputHandlerProxy::notifyCurrentFlingVelocity(
-    const WebFloatSize& velocity) {
-  TRACE_EVENT2("input",
-               "InputHandlerProxy::notifyCurrentFlingVelocity",
-               "vx",
-               velocity.width,
-               "vy",
-               velocity.height);
-  input_handler_->NotifyCurrentFlingVelocity(ToClientScrollIncrement(velocity));
+  return did_scroll;
 }
 
 }  // namespace content