Revert of 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 342 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 gfx::Vector2dF& accumulated_overscroll,
-    const gfx::Vector2dF& latest_overscroll_delta) {
+void InputHandlerProxy::DidOverscroll(const cc::DidOverscrollParams& params) {
   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);
 }
 
-bool InputHandlerProxy::scrollBy(const WebFloatSize& increment,
-                                 const WebFloatSize& velocity) {
+void InputHandlerProxy::scrollBy(const WebFloatSize& increment) {
   WebFloatSize clipped_increment;
-  WebFloatSize clipped_velocity;
-  if (!disallow_horizontal_fling_scroll_) {
+  if (!disallow_horizontal_fling_scroll_)
     clipped_increment.width = increment.width;
-    clipped_velocity.width = velocity.width;
-  }
-  if (!disallow_vertical_fling_scroll_) {
+  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 false;
+    return;
 
   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;
   }
+}
 
-  return did_scroll;
+void InputHandlerProxy::notifyCurrentFlingVelocity(
+    const WebFloatSize& velocity) {
+  TRACE_EVENT2("input",
+               "InputHandlerProxy::notifyCurrentFlingVelocity",
+               "vx",
+               velocity.width,
+               "vy",
+               velocity.height);
+  input_handler_->NotifyCurrentFlingVelocity(ToClientScrollIncrement(velocity));
 }
 
 }  // namespace content