CC Animation: Make LayerAnimationController to have just one event observer.

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 <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 10 matching lines @@
 #include "cc/output/filter_operations.h"
 #include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 LayerAnimationController::LayerAnimationController(int id)
     : host_(0),
       id_(id),
       is_active_(false),
+      event_observer_(nullptr),
       value_observer_(nullptr),
       value_provider_(nullptr),
       layer_animation_delegate_(nullptr),
       needs_active_value_observations_(false),
       needs_pending_value_observations_(false),
       needs_to_start_animations_(false),
       scroll_offset_animation_was_interrupted_(false),
       potentially_animating_transform_for_active_observers_(false),
       potentially_animating_transform_for_pending_observers_(false) {}
 
@@ skipping 342 matching lines @@
   host_ = host;
   if (host_)
     host_->RegisterAnimationController(this);
 
   UpdateActivation(FORCE_ACTIVATION);
 }
 
 void LayerAnimationController::NotifyAnimationStarted(
     const AnimationEvent& event) {
   if (event.is_impl_only) {
-    FOR_EACH_OBSERVER(LayerAnimationEventObserver, event_observers_,
-                      OnAnimationStarted(event));
+    if (event_observer_)
+      event_observer_->OnAnimationStarted(event);
     if (layer_animation_delegate_)
       layer_animation_delegate_->NotifyAnimationStarted(
           event.monotonic_time, event.target_property, event.group_id);
     return;
   }
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
         animations_[i]->target_property() == event.target_property &&
         animations_[i]->needs_synchronized_start_time()) {
       animations_[i]->set_needs_synchronized_start_time(false);
       if (!animations_[i]->has_set_start_time())
         animations_[i]->set_start_time(event.monotonic_time);
 
-      FOR_EACH_OBSERVER(LayerAnimationEventObserver, event_observers_,
-                        OnAnimationStarted(event));
+      if (event_observer_)
+        event_observer_->OnAnimationStarted(event);
       if (layer_animation_delegate_)
         layer_animation_delegate_->NotifyAnimationStarted(
             event.monotonic_time, event.target_property, event.group_id);
 
       return;
     }
   }
 }
 
 void LayerAnimationController::NotifyAnimationFinished(
@@ skipping 60 matching lines @@
       break;
     case TargetProperty::TRANSFORM:
       NotifyObserversTransformAnimated(
           event.transform, notify_active_observers, notify_pending_observers);
       break;
     default:
       NOTREACHED();
   }
 }
 
-void LayerAnimationController::AddEventObserver(
+void LayerAnimationController::SetEventObserver(
     LayerAnimationEventObserver* observer) {
-  if (!event_observers_.HasObserver(observer))
-    event_observers_.AddObserver(observer);
-}
-
-void LayerAnimationController::RemoveEventObserver(
-    LayerAnimationEventObserver* observer) {
-  event_observers_.RemoveObserver(observer);
+  event_observer_ = observer;
 }
 
 bool LayerAnimationController::HasFilterAnimationThatInflatesBounds() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->target_property() == TargetProperty::FILTER &&
         animations_[i]
             ->curve()
             ->ToFilterAnimationCurve()
             ->HasFilterThatMovesPixels())
@@ skipping 738 matching lines @@
          needs_pending_value_observations();
 }
 
 bool LayerAnimationController::HasActiveValueObserver() {
   if (!value_observer_)
     return false;
   return needs_active_value_observations();
 }
 
 }  // namespace cc