Unify Android Webview and Chrome's 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/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 398 matching lines @@
         FROM_HERE,
         base::Bind(&InputScrollElasticityController::ObserveWheelEventAndResult,
                    scroll_elasticity_controller_->GetWeakPtr(), wheel_event,
                    scroll_result));
   }
   return result;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureScrollBegin(
     const WebGestureEvent& gesture_event) {
-  DCHECK(!gesture_scroll_on_impl_thread_);
+  if (gesture_scroll_on_impl_thread_)

[jdduke (slow), 2015/05/04 22:02:10]

I'm surprised this was necessary, was there a particular gesture sequence where
we didn't receive a GestureFlingCancel first?

[hush (inactive), 2015/05/05 21:15:32]

This is not necessary in chrome code I think.
In Android WebView, you could fling the webview with the finger immediately
after calling the Java API "WebView#flingScroll()", before the synthesized fling
finishes. I hit this DCHECK in that case.

When 2 real flings go back to back, CancelCurrentFlingWithoutNotifyingClient
will always be called before the 2nd fling. But when there is a real fling
immediately following a synthesized fling,
CancelCurrentFlingWithoutNotifyingClient is sometimes not called before the real
fling. And that is the problem. I got around it by calling "CancelCurrentFling"
in this case.
The better solution would be to figure out why
CancelCurrentFlingWithoutNotifyingClient is not called in that case. I don't
know it yet.

+    CancelCurrentFling();
+
 #ifndef NDEBUG
   DCHECK(!expect_scroll_update_end_);
   expect_scroll_update_end_ = true;
 #endif
   cc::InputHandler::ScrollStatus scroll_status = input_handler_->ScrollBegin(
       gfx::Point(gesture_event.x, gesture_event.y), cc::InputHandler::GESTURE);
   UMA_HISTOGRAM_ENUMERATION("Renderer4.CompositorScrollHitTestResult",
                             scroll_status,
                             cc::InputHandler::ScrollStatusCount);
   switch (scroll_status) {
@@ skipping 91 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_.startTime = gesture_event.timeStampSeconds;
       fling_parameters_.delta = WebFloatPoint(vx, vy);
       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
       fling_parameters_.globalPoint =
           WebPoint(gesture_event.globalX, gesture_event.globalY);
       fling_parameters_.modifiers = gesture_event.modifiers;
       fling_parameters_.sourceDevice = gesture_event.sourceDevice;
-      input_handler_->SetNeedsAnimate();
+      input_handler_->SetNeedsAnimateInput();
       return DID_HANDLE;
     }
     case cc::InputHandler::SCROLL_UNKNOWN:
     case cc::InputHandler::SCROLL_ON_MAIN_THREAD: {
       TRACE_EVENT_INSTANT0("input",
                            "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 201 matching lines @@
 
   if (!has_fling_animation_started_) {
     has_fling_animation_started_ = true;
     // Guard against invalid, future or sufficiently stale start times, as there
     // are no guarantees fling event and animation timestamps are compatible.
     if (!fling_parameters_.startTime ||
         monotonic_time_sec <= fling_parameters_.startTime ||
         monotonic_time_sec >= fling_parameters_.startTime +
                                   kMaxSecondsFromFlingTimestampToFirstAnimate) {
       fling_parameters_.startTime = monotonic_time_sec;
-      input_handler_->SetNeedsAnimate();
+      input_handler_->SetNeedsAnimateInput();
       return;
     }
   }
 
   bool fling_is_active =
       fling_curve_->apply(monotonic_time_sec - fling_parameters_.startTime,
                           this);
 
   if (disallow_vertical_fling_scroll_ && disallow_horizontal_fling_scroll_)
     fling_is_active = false;
 
   if (fling_is_active) {
-    input_handler_->SetNeedsAnimate();
+    input_handler_->SetNeedsAnimateInput();
   } else {
     TRACE_EVENT_INSTANT0("input",
                          "InputHandlerProxy::animate::flingOver",
                          TRACE_EVENT_SCOPE_THREAD);
     CancelCurrentFling();
   }
 }
 
 void InputHandlerProxy::MainThreadHasStoppedFlinging() {
   fling_may_be_active_on_main_thread_ = false;
@@ skipping 174 matching lines @@
   // trigger a scroll, e.g., with a trivial time delta between fling updates.
   // Return true in this case to prevent early fling termination.
   if (std::abs(clipped_increment.width) < kScrollEpsilon &&
       std::abs(clipped_increment.height) < kScrollEpsilon)
     return true;
 
   return did_scroll;
 }
 
 }  // namespace content