Let the browser know the end of fling

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/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "content/renderer/input/input_handler_proxy_client.h"
@@ skipping 194 matching lines @@
         *static_cast<const WebGestureEvent*>(&event);
     input_handler_->PinchGestureUpdate(
         gesture_event.data.pinchUpdate.scale,
         gfx::Point(gesture_event.x, gesture_event.y));
     return DID_HANDLE;
   } else if (event.type == WebInputEvent::GestureFlingStart) {
     const WebGestureEvent& gesture_event =
         *static_cast<const WebGestureEvent*>(&event);
     return HandleGestureFling(gesture_event);
   } else if (event.type == WebInputEvent::GestureFlingCancel) {
-    if (CancelCurrentFling())
+    if (CancelCurrentFling(true))
       return DID_HANDLE;
     else if (!fling_may_be_active_on_main_thread_)
       return DROP_EVENT;
   } else if (event.type == WebInputEvent::TouchStart) {
     const WebTouchEvent& touch_event =
         *static_cast<const WebTouchEvent*>(&event);
     for (size_t i = 0; i < touch_event.touchesLength; ++i) {
       if (touch_event.touches[i].state != WebTouchPoint::StatePressed)
         continue;
       if (input_handler_->HaveTouchEventHandlersAt(touch_event.touches[i]
                                                        .position))
         return DID_NOT_HANDLE;
     }
     return DROP_EVENT;
   } else if (WebInputEvent::isKeyboardEventType(event.type)) {
-    CancelCurrentFling();
+    CancelCurrentFling(true);
   } else if (event.type == WebInputEvent::MouseMove) {
     const WebMouseEvent& mouse_event =
         *static_cast<const WebMouseEvent*>(&event);
     // TODO(tony): Ignore when mouse buttons are down?
     // TODO(davemoore): This should never happen, but bug #326635 showed some
     // surprising crashes.
     CHECK(input_handler_);
     input_handler_->MouseMoveAt(gfx::Point(mouse_event.x, mouse_event.y));
   }
 
@@ skipping 97 matching lines @@
 
   if (disallow_vertical_fling_scroll_ && disallow_horizontal_fling_scroll_)
     fling_is_active = false;
 
   if (fling_is_active) {
     input_handler_->ScheduleAnimation();
   } else {
     TRACE_EVENT_INSTANT0("renderer",
                          "InputHandlerProxy::animate::flingOver",
                          TRACE_EVENT_SCOPE_THREAD);
-    CancelCurrentFling();
+    CancelCurrentFling(true);
   }
 }
 
 void InputHandlerProxy::MainThreadHasStoppedFlinging() {
   fling_may_be_active_on_main_thread_ = false;
+  client_->DidStopFlinging();
 }
 
 void InputHandlerProxy::DidOverscroll(const cc::DidOverscrollParams& params) {
   DCHECK(client_);
   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;
   }
 
   client_->DidOverscroll(params);
 }
 
-bool InputHandlerProxy::CancelCurrentFling() {
+bool InputHandlerProxy::CancelCurrentFling(
+    bool send_fling_stopped_notification) {
   bool had_fling_animation = fling_curve_;
   if (had_fling_animation &&
       fling_parameters_.sourceDevice == WebGestureEvent::Touchscreen) {
     input_handler_->ScrollEnd();
     TRACE_EVENT_ASYNC_END0(
         "renderer",
         "InputHandlerProxy::HandleGestureFling::started",
         this);
   }
 
   TRACE_EVENT_INSTANT1("renderer",
                        "InputHandlerProxy::CancelCurrentFling",
                        TRACE_EVENT_SCOPE_THREAD,
                        "had_fling_animation",
                        had_fling_animation);
   fling_curve_.reset();
   gesture_scroll_on_impl_thread_ = false;
   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;
   synthetic_wheel.deltaX = increment.width;
   synthetic_wheel.deltaY = increment.height;
   synthetic_wheel.hasPreciseScrollingDeltas = true;
@@ skipping 15 matching lines @@
                            "InputHandlerProxy::scrollBy::AbortFling",
                            TRACE_EVENT_SCOPE_THREAD);
       // If we got a DID_NOT_HANDLE, that means we need to deliver wheels on the
       // main thread. In this case we need to schedule a commit and transfer the
       // fling curve over to the main thread and run the rest of the wheels from
       // there. This can happen when flinging a page that contains a scrollable
       // subarea that we can't scroll on the thread if the fling starts outside
       // the subarea but then is flung "under" the pointer.
       client_->TransferActiveWheelFlingAnimation(fling_parameters_);
       fling_may_be_active_on_main_thread_ = true;
-      CancelCurrentFling();
+      CancelCurrentFling(false);
       break;
   }
 
   return false;
 }
 
 static gfx::Vector2dF ToClientScrollIncrement(const WebFloatSize& increment) {
   return gfx::Vector2dF(-increment.width, -increment.height);
 }
 
@@ skipping 38 matching lines @@
   TRACE_EVENT2("renderer",
                "InputHandlerProxy::notifyCurrentFlingVelocity",
                "vx",
                velocity.width,
                "vy",
                velocity.height);
   input_handler_->NotifyCurrentFlingVelocity(ToClientScrollIncrement(velocity));
 }
 
 }  // namespace content