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 334 matching lines @@
   } else {
     TRACE_EVENT_INSTANT0("renderer",
                          "InputHandlerProxy::animate::flingOver",
                          TRACE_EVENT_SCOPE_THREAD);
     CancelCurrentFling();
   }
 }
 
 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_ |=
@@ skipping 16 matching lines @@
   }
 
   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 (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 14 matching lines @@
       TRACE_EVENT_INSTANT0("renderer",
                            "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;

[jdduke (slow), 2014/01/10 23:00:03]

Hmm, I think we need to be careful here.  This will send a |DidStopFlinging()|
message immediately, and another one when the transferred fling terminates on
the main thread.  

You can prevent this by calling |fling_curve_.reset()| before
|CancelCurrentFling()| (that's kind of hacky, but it's valid because fling
transfer only occurs with wheel events).

[jdduke (slow), 2014/01/10 23:03:58]

If you do go that route, please put a comment explaining why you explicitly
reset the fling before before calling |CancelCurrentFling()|, so somebody
doesn't roll in and clean it up :)

[Xianzhu, 2014/01/10 23:30:45]

Thanks for the nice finding!

However, this makes me rethink counter vs boolean. I'm afraid there might be
similar issues hidden somewhere in the possible paths of fling handling (here,
cc, WebViewImpl, EventHandler, ScrollBar, ...). This makes the counter fragile.
Any error can break the counter until the tab is closed. A boolean status won't
propagate errors, though there may be short gaps of inaccuracy which could be
tolerated with a delay.

       CancelCurrentFling();
       break;
   }
 
   return false;
 }
 
 static gfx::Vector2dF ToClientScrollIncrement(const WebFloatSize& increment) {
   return gfx::Vector2dF(-increment.width, -increment.height);
 }
@@ skipping 39 matching lines @@
   TRACE_EVENT2("renderer",
                "InputHandlerProxy::notifyCurrentFlingVelocity",
                "vx",
                velocity.width,
                "vy",
                velocity.height);
   input_handler_->NotifyCurrentFlingVelocity(ToClientScrollIncrement(velocity));
 }
 
 }  // namespace content