Update from https://crrev.com/320931

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 <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/animation/timing_function.h"
-#include "cc/base/latency_info_swap_promise_monitor.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/debug/debug_rect_history.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/debug/paint_time_counter.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/input/page_scale_animation.h"
@@ skipping 26 matching lines @@
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/raster_tile_priority_queue.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/software_rasterizer.h"
 #include "cc/resources/texture_mailbox_deleter.h"
 #include "cc/resources/tile_task_worker_pool.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/resources/zero_copy_tile_task_worker_pool.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/trees/damage_tracker.h"
+#include "cc/trees/latency_info_swap_promise_monitor.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
+#include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
-#include "gpu/GLES2/gl2extchromium.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 namespace {
 
 // Small helper class that saves the current viewport location as the user sees
 // it and resets to the same location.
 class ViewportAnchor {
  public:
@@ skipping 2341 matching lines @@
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     return SCROLL_STARTED;
   }
   return SCROLL_IGNORED;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
     const gfx::Point& viewport_point,
     const gfx::Vector2dF& scroll_delta) {
   if (LayerImpl* layer_impl = CurrentlyScrollingLayer()) {
-    Animation* animation =
-        layer_impl->layer_animation_controller()->GetAnimation(
-            Animation::SCROLL_OFFSET);
-    if (!animation)
-      return SCROLL_IGNORED;
-
-    ScrollOffsetAnimationCurve* curve =
-        animation->curve()->ToScrollOffsetAnimationCurve();
-
-    gfx::ScrollOffset new_target =
-        gfx::ScrollOffsetWithDelta(curve->target_value(), scroll_delta);
-    new_target.SetToMax(gfx::ScrollOffset());
-    new_target.SetToMin(layer_impl->MaxScrollOffset());
-
-    curve->UpdateTarget(
-        animation->TrimTimeToCurrentIteration(
-                       CurrentBeginFrameArgs().frame_time).InSecondsF(),
-        new_target);
-
-    return SCROLL_STARTED;
+    return ScrollAnimationUpdateTarget(layer_impl, scroll_delta)
+               ? SCROLL_STARTED
+               : SCROLL_IGNORED;
   }
   // ScrollAnimated is only used for wheel scrolls. We use the same bubbling
   // behavior as ScrollBy to determine which layer to animate, but we do not
   // do the Android-specific things in ScrollBy like showing top controls.
   InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, WHEEL);
   if (scroll_status == SCROLL_STARTED) {
     gfx::Vector2dF pending_delta = scroll_delta;
     for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
          layer_impl = layer_impl->parent()) {
       if (!layer_impl->scrollable())
@@ skipping 11 matching lines @@
                                std::abs(actual_delta.y()) > kEpsilon);
 
       if (!can_layer_scroll) {
         layer_impl->ScrollBy(actual_delta);
         pending_delta -= actual_delta;
         continue;
       }
 
       active_tree_->SetCurrentlyScrollingLayer(layer_impl);
 
-      scoped_ptr<ScrollOffsetAnimationCurve> curve =
-          ScrollOffsetAnimationCurve::Create(target_offset,
-                                             EaseInOutTimingFunction::Create());
-      curve->SetInitialValue(current_offset);
-
-      scoped_ptr<Animation> animation = Animation::Create(
-          curve.Pass(), AnimationIdProvider::NextAnimationId(),
-          AnimationIdProvider::NextGroupId(), Animation::SCROLL_OFFSET);
-      animation->set_is_impl_only(true);
-
-      layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
+      ScrollAnimationCreate(layer_impl, target_offset, current_offset);
 
       SetNeedsAnimate();
       return SCROLL_STARTED;
     }
   }
   ScrollEnd();
   return scroll_status;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
@@ skipping 942 matching lines @@
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnForwardScrollUpdateToMainThreadOnImpl();
 }
 
+void LayerTreeHostImpl::ScrollAnimationCreate(
+    LayerImpl* layer_impl,
+    const gfx::ScrollOffset& target_offset,
+    const gfx::ScrollOffset& current_offset) {
+  scoped_ptr<ScrollOffsetAnimationCurve> curve =
+      ScrollOffsetAnimationCurve::Create(target_offset,
+                                         EaseInOutTimingFunction::Create());
+  curve->SetInitialValue(current_offset);
+
+  scoped_ptr<Animation> animation = Animation::Create(
+      curve.Pass(), AnimationIdProvider::NextAnimationId(),
+      AnimationIdProvider::NextGroupId(), Animation::SCROLL_OFFSET);
+  animation->set_is_impl_only(true);
+
+  layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
+}
+
+bool LayerTreeHostImpl::ScrollAnimationUpdateTarget(
+    LayerImpl* layer_impl,
+    const gfx::Vector2dF& scroll_delta) {
+  Animation* animation =
+      layer_impl->layer_animation_controller()
+          ? layer_impl->layer_animation_controller()->GetAnimation(
+                Animation::SCROLL_OFFSET)
+          : nullptr;
+  if (!animation)
+    return false;
+
+  ScrollOffsetAnimationCurve* curve =
+      animation->curve()->ToScrollOffsetAnimationCurve();
+
+  gfx::ScrollOffset new_target =
+      gfx::ScrollOffsetWithDelta(curve->target_value(), scroll_delta);
+  new_target.SetToMax(gfx::ScrollOffset());
+  new_target.SetToMin(layer_impl->MaxScrollOffset());
+
+  curve->UpdateTarget(
+      animation->TrimTimeToCurrentIteration(CurrentBeginFrameArgs().frame_time)
+          .InSecondsF(),
+      new_target);
+
+  return true;
+}
 }  // namespace cc