Share animations from compositor to main thread.

cc/animation/animation_host.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/animation/animation_host.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "cc/animation/animation_delegate.h"
@@ skipping 80 matching lines @@
     new_target.SetToMax(gfx::ScrollOffset());
     new_target.SetToMin(max_scroll_offset);
 
     curve->UpdateTarget(animation->TrimTimeToCurrentIteration(
                                        frame_monotonic_time).InSecondsF(),
                         new_target);
 
     return true;
   }
 
-  void ScrollAnimationAbort() {
+  void ScrollAnimationAbort(bool needs_completion) {
     DCHECK(scroll_offset_animation_player_);
     scroll_offset_animation_player_->AbortAnimations(
-        TargetProperty::SCROLL_OFFSET);
+        TargetProperty::SCROLL_OFFSET, needs_completion);
   }
 
   // AnimationDelegate implementation.
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {}
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
                                TargetProperty::Type target_property,
                                int group) override {
     DCHECK_EQ(target_property, TargetProperty::SCROLL_OFFSET);
     DCHECK(animation_host_->mutator_host_client());
     animation_host_->mutator_host_client()->ScrollOffsetAnimationFinished();
   }
   void NotifyAnimationAborted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {}
+  void NotifyAnimationTakeover(base::TimeTicks monotonic_time,
+                               double animation_start_time,
+                               scoped_ptr<AnimationCurve> curve) override {}
 
  private:
   void ReattachScrollOffsetPlayerIfNeeded(int layer_id) {
     if (scroll_offset_animation_player_->layer_id() != layer_id) {
       if (scroll_offset_animation_player_->layer_id())
         scroll_offset_animation_player_->DetachLayer();
       if (layer_id)
         scroll_offset_animation_player_->AttachLayer(layer_id);
     }
   }
@@ skipping 338 matching lines @@
 
 bool AnimationHost::OpacityIsAnimatingOnImplOnly(int layer_id) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   if (!controller)
     return false;
 
   Animation* animation = controller->GetAnimation(TargetProperty::OPACITY);
   return animation && animation->is_impl_only();
 }
 
+bool AnimationHost::ScrollOffsetIsAnimatingOnImplOnly(int layer_id) const {
+  LayerAnimationController* controller = GetControllerForLayerId(layer_id);
+  if (!controller)
+    return false;
+
+  Animation* animation =
+      controller->GetAnimation(TargetProperty::SCROLL_OFFSET);
+  return animation && animation->is_impl_only();
+}
+
 bool AnimationHost::TransformIsAnimatingOnImplOnly(int layer_id) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   if (!controller)
     return false;
 
   Animation* animation = controller->GetAnimation(TargetProperty::TRANSFORM);
   return animation && animation->is_impl_only();
 }
 
 bool AnimationHost::HasFilterAnimationThatInflatesBounds(int layer_id) const {
@@ skipping 90 matching lines @@
 bool AnimationHost::ImplOnlyScrollAnimationUpdateTarget(
     int layer_id,
     const gfx::Vector2dF& scroll_delta,
     const gfx::ScrollOffset& max_scroll_offset,
     base::TimeTicks frame_monotonic_time) {
   DCHECK(scroll_offset_animations_);
   return scroll_offset_animations_->ScrollAnimationUpdateTarget(
       layer_id, scroll_delta, max_scroll_offset, frame_monotonic_time);
 }
 
-void AnimationHost::ScrollAnimationAbort() {
+void AnimationHost::ScrollAnimationAbort(bool needs_completion) {
   DCHECK(scroll_offset_animations_);
-  return scroll_offset_animations_->ScrollAnimationAbort();
+  return scroll_offset_animations_->ScrollAnimationAbort(needs_completion);
 }
 
 }  // namespace cc