CC Animation: Replace AnimiationEventsVector with AnimiationEvents class.

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>
 
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_delegate.h"
+#include "cc/animation/animation_events.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/layer_animation_value_observer.h"
 #include "cc/animation/layer_animation_value_provider.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/output/filter_operations.h"
 #include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
@@ skipping 172 matching lines @@
     return;
 
   if (needs_to_start_animations_)
     StartAnimations(monotonic_time);
   TickAnimations(monotonic_time);
   last_tick_time_ = monotonic_time;
 }
 
 void LayerAnimationController::AccumulatePropertyUpdates(
     base::TimeTicks monotonic_time,
-    AnimationEventsVector* events) {
+    AnimationEvents* events) {
   if (!events)
     return;
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     Animation* animation = animations_[i].get();
     if (!animation->is_impl_only())
       continue;
 
     if (!animation->InEffect(monotonic_time))
       continue;
 
     base::TimeDelta trimmed =
         animation->TrimTimeToCurrentIteration(monotonic_time);
     switch (animation->target_property()) {
       case Animation::OPACITY: {
         AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, id_,
                              animation->group(), Animation::OPACITY,
                              monotonic_time);
         const FloatAnimationCurve* float_animation_curve =
             animation->curve()->ToFloatAnimationCurve();
         event.opacity = float_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
-        events->push_back(event);
+        events->events_.push_back(event);
         break;
       }
 
       case Animation::TRANSFORM: {
         AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, id_,
                              animation->group(), Animation::TRANSFORM,
                              monotonic_time);
         const TransformAnimationCurve* transform_animation_curve =
             animation->curve()->ToTransformAnimationCurve();
         event.transform = transform_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
-        events->push_back(event);
+        events->events_.push_back(event);
         break;
       }
 
       case Animation::FILTER: {
         AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, id_,
                              animation->group(), Animation::FILTER,
                              monotonic_time);
         const FilterAnimationCurve* filter_animation_curve =
             animation->curve()->ToFilterAnimationCurve();
         event.filters = filter_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
-        events->push_back(event);
+        events->events_.push_back(event);
         break;
       }
 
       case Animation::BACKGROUND_COLOR: {
         break;
       }
 
       case Animation::SCROLL_OFFSET: {
         // Impl-side changes to scroll offset are already sent back to the
         // main thread (e.g. for user-driven scrolling), so a PROPERTY_UPDATE
         // isn't needed.
         break;
       }
     }
   }
 }
 
 void LayerAnimationController::UpdateState(bool start_ready_animations,
-                                           AnimationEventsVector* events) {
+                                           AnimationEvents* events) {
   if (!HasActiveValueObserver())
     return;
 
   // Animate hasn't been called, this happens if an observer has been added
   // between the Commit and Draw phases.
   if (last_tick_time_ == base::TimeTicks())
     return;
 
   if (start_ready_animations)
     PromoteStartedAnimations(last_tick_time_, events);
@@ skipping 585 matching lines @@
         }
       } else {
         needs_to_start_animations_ = true;
       }
     }
   }
 }
 
 void LayerAnimationController::PromoteStartedAnimations(
     base::TimeTicks monotonic_time,
-    AnimationEventsVector* events) {
+    AnimationEvents* events) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::STARTING &&
         animations_[i]->affects_active_observers()) {
       animations_[i]->SetRunState(Animation::RUNNING, monotonic_time);
       if (!animations_[i]->has_set_start_time() &&
           !animations_[i]->needs_synchronized_start_time())
         animations_[i]->set_start_time(monotonic_time);
       if (events) {
         base::TimeTicks start_time;
         if (animations_[i]->has_set_start_time())
           start_time = animations_[i]->start_time();
         else
           start_time = monotonic_time;
         AnimationEvent started_event(
             AnimationEvent::STARTED, id_, animations_[i]->group(),
             animations_[i]->target_property(), start_time);
         started_event.is_impl_only = animations_[i]->is_impl_only();
         if (started_event.is_impl_only)
           NotifyAnimationStarted(started_event);
         else
-          events->push_back(started_event);
+          events->events_.push_back(started_event);
       }
     }
   }
 }
 
 void LayerAnimationController::MarkFinishedAnimations(
     base::TimeTicks monotonic_time) {
   bool finished_transform_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->IsFinishedAt(monotonic_time)) {
       animations_[i]->SetRunState(Animation::FINISHED, monotonic_time);
       if (animations_[i]->target_property() == Animation::TRANSFORM) {
         finished_transform_animation = true;
       }
     }
   }
   if (finished_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 void LayerAnimationController::MarkAnimationsForDeletion(
     base::TimeTicks monotonic_time,
-    AnimationEventsVector* events) {
+    AnimationEvents* events) {
   bool marked_animations_for_deletions = false;
   std::vector<size_t> animations_with_same_group_id;
 
   animations_with_same_group_id.reserve(animations_.size());
   // Non-aborted animations are marked for deletion after a corresponding
   // AnimationEvent::FINISHED event is sent or received. This means that if
   // we don't have an events vector, we must ensure that non-aborted animations
   // have received a finished event before marking them for deletion.
   for (size_t i = 0; i < animations_.size(); i++) {
     int group_id = animations_[i]->group();
     if (animations_[i]->run_state() == Animation::ABORTED) {
       if (events && !animations_[i]->is_impl_only()) {
         AnimationEvent aborted_event(AnimationEvent::ABORTED, id_, group_id,
                                      animations_[i]->target_property(),
                                      monotonic_time);
-        events->push_back(aborted_event);
+        events->events_.push_back(aborted_event);
       }
       // If on the compositor or on the main thread and received finish event,
       // animation can be marked for deletion.
       if (events || animations_[i]->received_finished_event()) {
         animations_[i]->SetRunState(Animation::WAITING_FOR_DELETION,
                                     monotonic_time);
         marked_animations_for_deletions = true;
       }
       continue;
     }
@@ skipping 49 matching lines @@
             AnimationEvent finished_event(
                 AnimationEvent::FINISHED, id_,
                 animations_[animation_index]->group(),
                 animations_[animation_index]->target_property(),
                 monotonic_time);
             finished_event.is_impl_only =
                 animations_[animation_index]->is_impl_only();
             if (finished_event.is_impl_only)
               NotifyAnimationFinished(finished_event);
             else
-              events->push_back(finished_event);
+              events->events_.push_back(finished_event);
           }
           animations_[animation_index]->SetRunState(
               Animation::WAITING_FOR_DELETION, monotonic_time);
       }
       marked_animations_for_deletions = true;
     }
   }
   if (marked_animations_for_deletions)
     NotifyObserversAnimationWaitingForDeletion();
 }
@@ skipping 227 matching lines @@
         &value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != nullptr)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc