Update from https://crrev.com/312398

cc/animation/layer_animation_controller.cc

 // Copyright 2012 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/layer_animation_controller.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/animation/animation.h"
@@ skipping 43 matching lines @@
   explicit HasAnimationId(int id) : id_(id) {}
   bool operator()(Animation* animation) const {
     return animation->id() == id_;
   }
 
  private:
   int id_;
 };
 
 void LayerAnimationController::RemoveAnimation(int animation_id) {
-  animations_.erase(cc::remove_if(&animations_,
-                                  animations_.begin(),
-                                  animations_.end(),
-                                  HasAnimationId(animation_id)),
-                    animations_.end());
+  auto animations_to_remove =
+      animations_.remove_if(HasAnimationId(animation_id));
+  for (auto it = animations_to_remove; it != animations_.end(); ++it) {
+    if ((*it)->target_property() == Animation::ScrollOffset) {
+      NotifyObserversScrollOffsetAnimationRemoved();
+      break;
+    }
+  }
+  animations_.erase(animations_to_remove, animations_.end());
   UpdateActivation(NormalActivation);
 }
 
 struct HasAnimationIdAndProperty {
   HasAnimationIdAndProperty(int id, Animation::TargetProperty target_property)
       : id_(id), target_property_(target_property) {}
   bool operator()(Animation* animation) const {
     return animation->id() == id_ &&
         animation->target_property() == target_property_;
   }
 
  private:
   int id_;
   Animation::TargetProperty target_property_;
 };
 
 void LayerAnimationController::RemoveAnimation(
     int animation_id,
     Animation::TargetProperty target_property) {
-  animations_.erase(
-      cc::remove_if(&animations_,
-                    animations_.begin(),
-                    animations_.end(),
-                    HasAnimationIdAndProperty(animation_id, target_property)),
-      animations_.end());
+  auto animations_to_remove = animations_.remove_if(
+      HasAnimationIdAndProperty(animation_id, target_property));
+  if (target_property == Animation::ScrollOffset &&
+      animations_to_remove != animations_.end())
+    NotifyObserversScrollOffsetAnimationRemoved();
+
+  animations_.erase(animations_to_remove, animations_.end());
   UpdateActivation(NormalActivation);
 }
 
 void LayerAnimationController::AbortAnimations(
     Animation::TargetProperty target_property) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->target_property() == target_property &&
         !animations_[i]->is_finished())
       animations_[i]->SetRunState(Animation::Aborted, last_tick_time_);
   }
@@ skipping 150 matching lines @@
   UpdateActivation(NormalActivation);
 }
 
 void LayerAnimationController::AddAnimation(scoped_ptr<Animation> animation) {
   animations_.push_back(animation.Pass());
   needs_to_start_animations_ = true;
   UpdateActivation(NormalActivation);
 }
 
 Animation* LayerAnimationController::GetAnimation(
-    int group_id,
-    Animation::TargetProperty target_property) const {
-  for (size_t i = 0; i < animations_.size(); ++i)
-    if (animations_[i]->group() == group_id &&
-        animations_[i]->target_property() == target_property)
-      return animations_[i];
-  return 0;
-}
-
-Animation* LayerAnimationController::GetAnimation(
     Animation::TargetProperty target_property) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     size_t index = animations_.size() - i - 1;
     if (animations_[index]->target_property() == target_property)
       return animations_[index];
   }
   return 0;
 }
 
+Animation* LayerAnimationController::GetAnimationById(int animation_id) const {
+  for (size_t i = 0; i < animations_.size(); ++i)
+    if (animations_[i]->id() == animation_id)
+      return animations_[i];
+  return nullptr;
+}
+
 bool LayerAnimationController::HasActiveAnimation() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished())
       return true;
   }
   return false;
 }
 
 bool LayerAnimationController::IsAnimatingProperty(
     Animation::TargetProperty target_property) const {
@@ skipping 254 matching lines @@
   return true;
 }
 
 void LayerAnimationController::PushNewAnimationsToImplThread(
     LayerAnimationController* controller_impl) const {
   // Any new animations owned by the main thread's controller are cloned and
   // add to the impl thread's controller.
   for (size_t i = 0; i < animations_.size(); ++i) {
     // If the animation is already running on the impl thread, there is no
     // need to copy it over.
-    if (controller_impl->GetAnimation(animations_[i]->group(),
-                                      animations_[i]->target_property()))
+    if (controller_impl->GetAnimationById(animations_[i]->id()))
       continue;
 
     // If the animation is not running on the impl thread, it does not
     // necessarily mean that it needs to be copied over and started; it may
     // have already finished. In this case, the impl thread animation will
     // have already notified that it has started and the main thread animation
     // will no longer need
     // a synchronized start time.
     if (!animations_[i]->needs_synchronized_start_time())
       continue;
@@ skipping 23 matching lines @@
     controller_impl->AddAnimation(to_add.Pass());
   }
 }
 
 static bool IsCompleted(
     Animation* animation,
     const LayerAnimationController* main_thread_controller) {
   if (animation->is_impl_only()) {
     return (animation->run_state() == Animation::WaitingForDeletion);
   } else {
-    return !main_thread_controller->GetAnimation(animation->group(),
-                                                 animation->target_property());
+    return !main_thread_controller->GetAnimationById(animation->id());
   }
 }
 
 static bool AffectsActiveOnlyAndIsWaitingForDeletion(Animation* animation) {
   return animation->run_state() == Animation::WaitingForDeletion &&
          !animation->affects_pending_observers();
 }
 
 void LayerAnimationController::RemoveAnimationsCompletedOnMainThread(
     LayerAnimationController* controller_impl) const {
   // Animations removed on the main thread should no longer affect pending
   // observers, and should stop affecting active observers after the next call
   // to ActivateAnimations. If already WaitingForDeletion, they can be removed
   // immediately.
   ScopedPtrVector<Animation>& animations = controller_impl->animations_;
   for (size_t i = 0; i < animations.size(); ++i) {
     if (IsCompleted(animations[i], this))
       animations[i]->set_affects_pending_observers(false);
   }
   animations.erase(cc::remove_if(&animations,
                                  animations.begin(),
                                  animations.end(),
                                  AffectsActiveOnlyAndIsWaitingForDeletion),
                    animations.end());
 }
 
 void LayerAnimationController::PushPropertiesToImplThread(
     LayerAnimationController* controller_impl) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
-    Animation* current_impl = controller_impl->GetAnimation(
-        animations_[i]->group(), animations_[i]->target_property());
+    Animation* current_impl =
+        controller_impl->GetAnimationById(animations_[i]->id());
     if (current_impl)
       animations_[i]->PushPropertiesTo(current_impl);
   }
 }
 
 void LayerAnimationController::StartAnimations(base::TimeTicks monotonic_time) {
   DCHECK(needs_to_start_animations_);
   needs_to_start_animations_ = false;
   // First collect running properties affecting each type of observer.
   TargetProperties blocked_properties_for_active_observers;
@@ skipping 382 matching lines @@
     }
   }
 }
 
 void LayerAnimationController::NotifyObserversAnimationWaitingForDeletion() {
   FOR_EACH_OBSERVER(LayerAnimationValueObserver,
                     value_observers_,
                     OnAnimationWaitingForDeletion());
 }
 
+void LayerAnimationController::NotifyObserversScrollOffsetAnimationRemoved() {
+  FOR_EACH_OBSERVER(LayerAnimationValueObserver, value_observers_,
+                    OnScrollOffsetAnimationRemoved());
+}
+
 bool LayerAnimationController::HasValueObserver() {
   if (value_observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(
         value_observers_);
     return it.GetNext() != nullptr;
   }
   return false;
 }
 
 bool LayerAnimationController::HasActiveValueObserver() {
   if (value_observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != nullptr)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc