Take MT jank into account when animating the scroll offset on CC

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 2760 matching lines @@
 
   gfx::ScrollOffset old_offset =
       scroll_tree.current_scroll_offset(scroll_node->owner_id);
   gfx::ScrollOffset new_offset = scroll_tree.ClampScrollOffsetToLimits(
       old_offset + gfx::ScrollOffset(adjusted_scroll), scroll_node);
 
   gfx::ScrollOffset scrolled = new_offset - old_offset;
   return gfx::Vector2dF(scrolled.x(), scrolled.y());
 }
 
-bool LayerTreeHostImpl::ScrollAnimationCreate(ScrollNode* scroll_node,
-                                              const gfx::Vector2dF& delta) {
+bool LayerTreeHostImpl::ScrollAnimationCreate(
+    ScrollNode* scroll_node,
+    const gfx::Vector2dF& delta,
+    base::TimeTicks original_event_time) {
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
 
   const float kEpsilon = 0.1f;
   bool scroll_animated =
       (std::abs(delta.x()) > kEpsilon || std::abs(delta.y()) > kEpsilon);
   if (!scroll_animated) {
     scroll_tree.ScrollBy(scroll_node, delta, active_tree());
     return false;
   }
 
   scroll_tree.set_currently_scrolling_node(scroll_node->id);
 
   gfx::ScrollOffset current_offset =
       scroll_tree.current_scroll_offset(scroll_node->owner_id);
   gfx::ScrollOffset target_offset = scroll_tree.ClampScrollOffsetToLimits(
       current_offset + gfx::ScrollOffset(delta), scroll_node);
   animation_host_->ImplOnlyScrollAnimationCreate(scroll_node->owner_id,
-                                                 target_offset, current_offset);
+                                                 target_offset, current_offset,
+                                                 original_event_time);
 
   SetNeedsOneBeginImplFrame();
 
   return true;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
     const gfx::Point& viewport_point,
-    const gfx::Vector2dF& scroll_delta) {
+    const gfx::Vector2dF& scroll_delta,
+    const ui::LatencyInfo* latency_info) {
   InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
   if (scroll_node) {
     gfx::Vector2dF delta = scroll_delta;
     if (!scroll_node->data.user_scrollable_horizontal)
       delta.set_x(0);
     if (!scroll_node->data.user_scrollable_vertical)
@@ skipping 23 matching lines @@
   scroll_node = scroll_tree.CurrentlyScrollingNode();
   if (scroll_status.thread == SCROLL_ON_IMPL_THREAD) {
     gfx::Vector2dF pending_delta = scroll_delta;
     if (scroll_node) {
       for (; scroll_tree.parent(scroll_node);
            scroll_node = scroll_tree.parent(scroll_node)) {
         if (!scroll_node->data.scrollable ||
             scroll_node->data.is_outer_viewport_scroll_layer)
           continue;
 
+        // Some time may have passed between now and when the user actually
+        // asked to scroll. The animation curve should take this into account
+        // in the duration of the animation.
+        ui::LatencyInfo::LatencyComponent o_component;
+        o_component.event_time = base::TimeTicks();
+        if (latency_info)
+          latency_info->FindLatency(ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
+                                    0, &o_component);
+
         if (scroll_node->data.is_inner_viewport_scroll_layer) {
-          gfx::Vector2dF scrolled = viewport()->ScrollAnimated(pending_delta);
+          gfx::Vector2dF scrolled =
+              viewport()->ScrollAnimated(pending_delta, o_component.event_time);
           // Viewport::ScrollAnimated returns pending_delta as long as it
           // starts an animation.
           if (scrolled == pending_delta)
             return scroll_status;
           pending_delta -= scrolled;
           continue;
         }
 
         gfx::Vector2dF scroll_delta =
             ComputeScrollDelta(scroll_node, pending_delta);
-        if (ScrollAnimationCreate(scroll_node, scroll_delta))
+        if (ScrollAnimationCreate(scroll_node, scroll_delta,
+                                  o_component.event_time))
           return scroll_status;
 
         pending_delta -= scroll_delta;
       }
     }
   }
   scroll_state.set_is_ending(true);
   ScrollEnd(&scroll_state);
   return scroll_status;
 }
@@ skipping 1153 matching lines @@
     const {
   return fixed_raster_scale_attempted_scale_change_history_.count() >=
          kFixedRasterScaleAttemptedScaleChangeThreshold;
 }
 
 void LayerTreeHostImpl::SetFixedRasterScaleAttemptedToChangeScale() {
   fixed_raster_scale_attempted_scale_change_history_.set(0);
 }
 
 }  // namespace cc