Plumb smooth scrolling in Chromium compositor

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/location.h"
 #include "base/logging.h"
@@ skipping 211 matching lines @@
                          "LatencyInfo.Flow",
                          TRACE_ID_DONT_MANGLE(latency_info->trace_id),
                          "HandleInputEventImpl");
 
   scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor =
       input_handler_->CreateLatencyInfoSwapPromiseMonitor(latency_info);
   InputHandlerProxy::EventDisposition disposition = HandleInputEvent(event);
   return disposition;
 }
 
+blink::WebGestureCurve* InputHandlerProxy::CreateAnimationCurve(
+    const blink::WebGestureEvent& gesture_event) {
+  blink::WebGestureCurve* fling_curve;
+  if (gesture_event.data.flingStart.isSmoothScroll) {
+    const float start_x = gesture_event.x;
+    const float start_y = gesture_event.y;
+    const float dx = gesture_event.data.flingStart.dx;
+    const float dy = gesture_event.data.flingStart.dy;
+    const long duration_ms = gesture_event.data.flingStart.durationMs;
+    fling_curve = client_->CreateSmoothScrollAnimationCurve(
+        gesture_event.sourceDevice, start_x, start_y, dx, dy, duration_ms);
+  } else {
+    const float vx = gesture_event.data.flingStart.velocityX;
+    const float vy = gesture_event.data.flingStart.velocityY;
+    fling_curve = client_->CreateFlingAnimationCurve(
+        gesture_event.sourceDevice, WebFloatPoint(vx, vy), blink::WebSize());
+  }
+
+  return fling_curve;
+}
+
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleInputEvent(
     const WebInputEvent& event) {
   DCHECK(input_handler_);
   TRACE_EVENT1("input,benchmark", "InputHandlerProxy::HandleInputEvent",
                "type", WebInputEventTraits::GetName(event.type));
 
   if (FilterInputEventForFlingBoosting(event))
     return DID_HANDLE;
 
   switch (event.type) {
@@ skipping 272 matching lines @@
 
   switch (scroll_status) {
     case cc::InputHandler::SCROLL_STARTED: {
       if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad)
         input_handler_->ScrollEnd();
 
       const float vx = gesture_event.data.flingStart.velocityX;
       const float vy = gesture_event.data.flingStart.velocityY;
       current_fling_velocity_ = gfx::Vector2dF(vx, vy);
       DCHECK(!current_fling_velocity_.IsZero());
-      fling_curve_.reset(client_->CreateFlingAnimationCurve(
-          gesture_event.sourceDevice,
-          WebFloatPoint(vx, vy),
-          blink::WebSize()));
+
+      fling_curve_.reset(CreateAnimationCurve(gesture_event));
+
       disallow_horizontal_fling_scroll_ = !vx;
       disallow_vertical_fling_scroll_ = !vy;
       TRACE_EVENT_ASYNC_BEGIN2("input",
                                "InputHandlerProxy::HandleGestureFling::started",
                                this,
                                "vx",
                                vx,
                                "vy",
                                vy);
       // Note that the timestamp will only be used to kickstart the animation if
@@ skipping 133 matching lines @@
       // preventing insertion of a synthetic GestureScrollBegin.
       last_fling_boost_event_ = WebGestureEvent();
       CancelCurrentFling();
       return true;
 
     case WebInputEvent::GestureFlingStart: {
       DCHECK_EQ(fling_parameters_.sourceDevice, gesture_event.sourceDevice);
 
       bool fling_boosted =
           fling_parameters_.modifiers == gesture_event.modifiers &&
           ShouldBoostFling(current_fling_velocity_, gesture_event);

[jdduke (slow), 2015/07/23 15:32:50]

We should make sure smooth scroll flings don't boost.

 
       gfx::Vector2dF new_fling_velocity(
           gesture_event.data.flingStart.velocityX,
           gesture_event.data.flingStart.velocityY);
       DCHECK(!new_fling_velocity.IsZero());
 
       if (fling_boosted)
         current_fling_velocity_ += new_fling_velocity;
       else
         current_fling_velocity_ = new_fling_velocity;
 
       WebFloatPoint velocity(current_fling_velocity_.x(),
                              current_fling_velocity_.y());
       deferred_fling_cancel_time_seconds_ = 0;
       disallow_horizontal_fling_scroll_ = !velocity.x;
       disallow_vertical_fling_scroll_ = !velocity.y;
       last_fling_boost_event_ = WebGestureEvent();
-      fling_curve_.reset(client_->CreateFlingAnimationCurve(
-          gesture_event.sourceDevice,
-          velocity,
-          blink::WebSize()));
+      fling_curve_.reset(CreateAnimationCurve(gesture_event));
       fling_parameters_.startTime = gesture_event.timeStampSeconds;
       fling_parameters_.delta = velocity;
       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
       fling_parameters_.globalPoint =
           WebPoint(gesture_event.globalX, gesture_event.globalY);
 
       TRACE_EVENT_INSTANT2("input",
                            fling_boosted ? "InputHandlerProxy::FlingBoosted"
                                          : "InputHandlerProxy::FlingReplaced",
                            TRACE_EVENT_SCOPE_THREAD,
@@ skipping 254 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