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

cc/layers/viewport.cc

 // Copyright 2015 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/layers/viewport.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "cc/input/top_controls_manager.h"
 #include "cc/trees/layer_tree_host_impl.h"
@@ skipping 55 matching lines @@
 
 bool Viewport::ShouldAnimateViewport(const gfx::Vector2dF& viewport_delta,
                                      const gfx::Vector2dF& pending_delta) {
   float max_dim_viewport_delta =
       std::max(std::abs(viewport_delta.x()), std::abs(viewport_delta.y()));
   float max_dim_pending_delta =
       std::max(std::abs(pending_delta.x()), std::abs(pending_delta.y()));
   return max_dim_viewport_delta > max_dim_pending_delta;
 }
 
-gfx::Vector2dF Viewport::ScrollAnimated(const gfx::Vector2dF& delta) {
+gfx::Vector2dF Viewport::ScrollAnimated(const gfx::Vector2dF& delta,
+                                        base::TimeTicks original_event_time) {
   ScrollTree& scroll_tree =
       host_impl_->active_tree()->property_trees()->scroll_tree;
 
   float scale_factor = host_impl_->active_tree()->current_page_scale_factor();
   gfx::Vector2dF scaled_delta = delta;
   scaled_delta.Scale(1.f / scale_factor);
 
   ScrollNode* inner_node =
       scroll_tree.Node(InnerScrollLayer()->scroll_tree_index());
   gfx::Vector2dF inner_delta =
@@ skipping 10 matching lines @@
   if (inner_delta.IsZero() && outer_delta.IsZero())
     return gfx::Vector2dF(0, 0);
 
   // Animate the viewport to which the majority of scroll delta will be applied.
   // The animation system only supports running one scroll offset animation.
   // TODO(ymalik): Fix the visible jump seen by instant scrolling one of the
   // viewports.
   bool will_animate = false;
   if (ShouldAnimateViewport(inner_delta, outer_delta)) {
     scroll_tree.ScrollBy(outer_node, outer_delta, host_impl_->active_tree());
-    will_animate = host_impl_->ScrollAnimationCreate(inner_node, inner_delta);
+    will_animate = host_impl_->ScrollAnimationCreate(inner_node, inner_delta,
+                                                     original_event_time);
   } else {
     scroll_tree.ScrollBy(inner_node, inner_delta, host_impl_->active_tree());
-    will_animate = host_impl_->ScrollAnimationCreate(outer_node, outer_delta);
+    will_animate = host_impl_->ScrollAnimationCreate(outer_node, outer_delta,
+                                                     original_event_time);
   }
 
   if (will_animate) {
     // Consume entire scroll delta as long as we are starting an animation.
     return delta;
   }
 
   pending_delta = scaled_delta - inner_delta - outer_delta;
   pending_delta.Scale(scale_factor);
   return pending_delta;
@@ skipping 112 matching lines @@
 
 LayerImpl* Viewport::InnerScrollLayer() const {
   return host_impl_->InnerViewportScrollLayer();
 }
 
 LayerImpl* Viewport::OuterScrollLayer() const {
   return host_impl_->OuterViewportScrollLayer();
 }
 
 }  // namespace cc