ElementAnimations should hold an ObservableList of AnimationPlayers.

cc/animation/element_animations.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/element_animations.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 93 matching lines @@
   if (list_type == ElementListType::ACTIVE)
     set_has_element_in_active_list(false);
   else
     set_has_element_in_pending_list(false);
 
   if (!has_element_in_any_list())
     animation_host_->DidDeactivateElementAnimations(this);
 }
 
 void ElementAnimations::AddPlayer(AnimationPlayer* player) {
-  players_list_->Append(player);
+  players_list_->AddObserver(player);
 }
 
 void ElementAnimations::RemovePlayer(AnimationPlayer* player) {
-  for (PlayersListNode* node = players_list_->head();
-       node != players_list_->end(); node = node->next()) {
-    if (node->value() == player) {
-      node->RemoveFromList();
-      return;
-    }
-  }
+  players_list_->RemoveObserver(player);
 }
 
 bool ElementAnimations::IsEmpty() const {
-  return players_list_->empty();
+  return !players_list_->might_have_observers();
 }
 
 void ElementAnimations::PushPropertiesTo(
     scoped_refptr<ElementAnimations> element_animations_impl) {
   DCHECK_NE(this, element_animations_impl);
   if (!has_any_animation() && !element_animations_impl->has_any_animation())
     return;
   MarkAbortedAnimationsForDeletion(element_animations_impl.get());
   PurgeAnimationsMarkedForDeletion();
   PushNewAnimationsToImplThread(element_animations_impl.get());
@@ skipping 135 matching lines @@
       NotifyPlayersAnimationFinished(event.monotonic_time,
                                      event.target_property, event.group_id);
 
       return;
     }
   }
 }
 
 void ElementAnimations::NotifyAnimationTakeover(const AnimationEvent& event) {
   DCHECK(event.target_property == TargetProperty::SCROLL_OFFSET);
-  if (!players_list_->empty()) {
+  if (!IsEmpty()) {
     std::unique_ptr<AnimationCurve> animation_curve = event.curve->Clone();
     NotifyPlayersAnimationTakeover(event.monotonic_time, event.target_property,
                                    event.animation_start_time,
                                    std::move(animation_curve));
   }
 }
 
 void ElementAnimations::NotifyAnimationAborted(const AnimationEvent& event) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
@@ skipping 1133 matching lines @@
         NOTREACHED();
         break;
     }
   }
 }
 
 void ElementAnimations::NotifyPlayersAnimationStarted(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     int group) {
-  for (PlayersListNode* node = players_list_->head();
-       node != players_list_->end(); node = node->next()) {
-    AnimationPlayer* player = node->value();
-    player->NotifyAnimationStarted(monotonic_time, target_property, group);
-  }
+  FOR_EACH_OBSERVER(AnimationPlayer, *players_list_.get(),
+                    OnAnimationStarted(monotonic_time, target_property, group));
 }
 
 void ElementAnimations::NotifyPlayersAnimationFinished(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     int group) {
-  for (PlayersListNode* node = players_list_->head();
-       node != players_list_->end(); node = node->next()) {
-    AnimationPlayer* player = node->value();
-    player->NotifyAnimationFinished(monotonic_time, target_property, group);
-  }
+  FOR_EACH_OBSERVER(
+      AnimationPlayer, *players_list_.get(),
+      OnAnimationFinished(monotonic_time, target_property, group));
 }
 
 void ElementAnimations::NotifyPlayersAnimationAborted(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     int group) {
-  for (PlayersListNode* node = players_list_->head();
-       node != players_list_->end(); node = node->next()) {
-    AnimationPlayer* player = node->value();
-    player->NotifyAnimationAborted(monotonic_time, target_property, group);
-  }
+  FOR_EACH_OBSERVER(AnimationPlayer, *players_list_.get(),
+                    OnAnimationAborted(monotonic_time, target_property, group));
 }
 
 void ElementAnimations::NotifyPlayersAnimationTakeover(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     double animation_start_time,
     std::unique_ptr<AnimationCurve> curve) {
   DCHECK(curve);
-  for (PlayersListNode* node = players_list_->head();
-       node != players_list_->end(); node = node->next()) {
+  base::ObserverList<AnimationPlayer>::Iterator it(players_list_.get());

[loyso (OOO), 2016/08/05 00:18:48]

Use ElementAnimations::PlayersList type here, please.

[ymalik, 2016/08/05 00:54:04]

Totally, Done.

+  AnimationPlayer* player;
+  while ((player = it.GetNext()) != nullptr) {

[loyso (OOO), 2016/08/05 00:13:25]

Any comment, why this iteration is different and FOR_EACH_OBSERVER isn't used?

[ymalik, 2016/08/05 00:54:04]

We need to call player->OnAnimationTakeover with a new copy of the curve.

     std::unique_ptr<AnimationCurve> animation_curve = curve->Clone();
-    AnimationPlayer* player = node->value();
-    player->NotifyAnimationTakeover(monotonic_time, target_property,
-                                    animation_start_time,
-                                    std::move(animation_curve));
+    player->OnAnimationTakeover(monotonic_time, target_property,
+                                animation_start_time,
+                                std::move(animation_curve));
   }
 }
 
 gfx::ScrollOffset ElementAnimations::ScrollOffsetForAnimation() const {
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         element_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc