CC Animation: Replace AnimiationEventsVector with AnimiationEvents class.

cc/animation/layer_animation_controller_unittest.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 "cc/animation/animation.h"
 #include "cc/animation/animation_curve.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/scroll_offset_animation_curve.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/test/animation_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/transform.h"
 
@@ skipping 120 matching lines @@
   int animation_id =
       AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
   EXPECT_TRUE(controller_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             controller_impl->GetAnimationById(animation_id)->run_state());
 
-  AnimationEventsVector events;
+  AnimationEvents events;
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, &events);
 
   // Synchronize the start times.
-  EXPECT_EQ(1u, events.size());
-  controller->NotifyAnimationStarted(events[0]);
+  EXPECT_EQ(1u, events.events_.size());
+  controller->NotifyAnimationStarted(events.events_[0]);
   EXPECT_EQ(controller->GetAnimationById(animation_id)->start_time(),
             controller_impl->GetAnimationById(animation_id)->start_time());
 
   // Start the animation on the main thread. Should not affect the start time.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, nullptr);
   EXPECT_EQ(controller->GetAnimationById(animation_id)->start_time(),
             controller_impl->GetAnimationById(animation_id)->start_time());
 }
 
@@ skipping 13 matching lines @@
   const TimeTicks start_time = TicksFromSecondsF(123);
   controller->GetAnimation(Animation::OPACITY)->set_start_time(start_time);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
   EXPECT_TRUE(controller_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             controller_impl->GetAnimationById(animation_id)->run_state());
 
-  AnimationEventsVector events;
+  AnimationEvents events;
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, &events);
 
   // Synchronize the start times.
-  EXPECT_EQ(1u, events.size());
-  controller->NotifyAnimationStarted(events[0]);
+  EXPECT_EQ(1u, events.events_.size());
+  controller->NotifyAnimationStarted(events.events_[0]);
 
   EXPECT_EQ(start_time,
             controller->GetAnimationById(animation_id)->start_time());
   EXPECT_EQ(controller->GetAnimationById(animation_id)->start_time(),
             controller_impl->GetAnimationById(animation_id)->start_time());
 
   // Start the animation on the main thread. Should not affect the start time.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, nullptr);
   EXPECT_EQ(start_time,
             controller->GetAnimationById(animation_id)->start_time());
   EXPECT_EQ(controller->GetAnimationById(animation_id)->start_time(),
             controller_impl->GetAnimationById(animation_id)->start_time());
 }
 
 // Tests that controllers activate and deactivate as expected.
 TEST(LayerAnimationControllerTest, Activation) {
   scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::Create();
   scoped_ptr<AnimationRegistrar> registrar_impl = AnimationRegistrar::Create();
 
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events = registrar->CreateEvents();
 
   controller->SetAnimationRegistrar(registrar.get());
   controller_impl->SetAnimationRegistrar(registrar_impl.get());
   EXPECT_EQ(1u, registrar->all_animation_controllers_for_testing().size());
   EXPECT_EQ(1u, registrar_impl->all_animation_controllers_for_testing().size());
 
   // Initially, both controllers should be inactive.
   EXPECT_EQ(0u, registrar->active_animation_controllers_for_testing().size());
   EXPECT_EQ(0u,
             registrar_impl->active_animation_controllers_for_testing().size());
 
   AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);
   // The main thread controller should now be active.
   EXPECT_EQ(1u, registrar->active_animation_controllers_for_testing().size());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   // Both controllers should now be active.
   EXPECT_EQ(1u, registrar->active_animation_controllers_for_testing().size());
   EXPECT_EQ(1u,
             registrar_impl->active_animation_controllers_for_testing().size());
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
-  EXPECT_EQ(1u, events->size());
-  controller->NotifyAnimationStarted((*events)[0]);
+  EXPECT_EQ(1u, events->events_.size());
+  controller->NotifyAnimationStarted(events->events_[0]);
 
   EXPECT_EQ(1u, registrar->active_animation_controllers_for_testing().size());
   EXPECT_EQ(1u,
             registrar_impl->active_animation_controllers_for_testing().size());
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, nullptr);
   EXPECT_EQ(1u, registrar->active_animation_controllers_for_testing().size());
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, nullptr);
   EXPECT_EQ(Animation::FINISHED,
             controller->GetAnimation(Animation::OPACITY)->run_state());
   EXPECT_EQ(1u, registrar->active_animation_controllers_for_testing().size());
 
-  events.reset(new AnimationEventsVector);
+  events.reset(new AnimationEvents);
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1500));
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             controller_impl->GetAnimation(Animation::OPACITY)->run_state());
   // The impl thread controller should have de-activated.
   EXPECT_EQ(0u,
             registrar_impl->active_animation_controllers_for_testing().size());
 
-  EXPECT_EQ(1u, events->size());
-  controller->NotifyAnimationFinished((*events)[0]);
+  EXPECT_EQ(1u, events->events_.size());
+  controller->NotifyAnimationFinished(events->events_[0]);
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
   controller->UpdateState(true, nullptr);
 
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             controller->GetAnimation(Animation::OPACITY)->run_state());
   // The main thread controller should have de-activated.
   EXPECT_EQ(0u, registrar->active_animation_controllers_for_testing().size());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
@@ skipping 31 matching lines @@
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
   EXPECT_TRUE(controller_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             controller_impl->GetAnimationById(animation_id)->run_state());
 
   TimeTicks time = kInitialTickTime;
 
   // Start the animations on each controller.
-  AnimationEventsVector events;
+  AnimationEvents events;
   controller_impl->Animate(time);
   controller_impl->UpdateState(true, &events);
-  EXPECT_EQ(1u, events.size());
+  EXPECT_EQ(1u, events.events_.size());
 
   controller->Animate(time);
   controller->UpdateState(true, nullptr);
-  controller->NotifyAnimationStarted(events[0]);
+  controller->NotifyAnimationStarted(events.events_[0]);
 
   EXPECT_EQ(Animation::RUNNING,
             controller_impl->GetAnimationById(animation_id)->run_state());
   EXPECT_EQ(Animation::RUNNING,
             controller->GetAnimationById(animation_id)->run_state());
 
   EXPECT_EQ(0.3f, dummy.opacity());
   EXPECT_EQ(0.3f, dummy_impl.opacity());
 
   EXPECT_EQ(kInitialTickTime,
@@ skipping 26 matching lines @@
 
 TEST(LayerAnimationControllerTest, DoNotSyncFinishedAnimation) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
 
   EXPECT_FALSE(controller_impl->GetAnimation(Animation::OPACITY));
 
   int animation_id =
       AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
   EXPECT_TRUE(controller_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             controller_impl->GetAnimationById(animation_id)->run_state());
 
-  events.reset(new AnimationEventsVector);
+  events.reset(new AnimationEvents);
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
-  EXPECT_EQ(1u, events->size());
-  EXPECT_EQ(AnimationEvent::STARTED, (*events)[0].type);
+  EXPECT_EQ(1u, events->events_.size());
+  EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
 
   // Notify main thread controller that the animation has started.
-  controller->NotifyAnimationStarted((*events)[0]);
+  controller->NotifyAnimationStarted(events->events_[0]);
 
   // Complete animation on impl thread.
-  events.reset(new AnimationEventsVector);
+  events.reset(new AnimationEvents);
   controller_impl->Animate(kInitialTickTime + TimeDelta::FromSeconds(1));
   controller_impl->UpdateState(true, events.get());
-  EXPECT_EQ(1u, events->size());
-  EXPECT_EQ(AnimationEvent::FINISHED, (*events)[0].type);
+  EXPECT_EQ(1u, events->events_.size());
+  EXPECT_EQ(AnimationEvent::FINISHED, events->events_[0].type);
 
-  controller->NotifyAnimationFinished((*events)[0]);
+  controller->NotifyAnimationFinished(events->events_[0]);
 
   controller->Animate(kInitialTickTime + TimeDelta::FromSeconds(2));
   controller->UpdateState(true, nullptr);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_FALSE(controller->GetAnimationById(animation_id));
   EXPECT_FALSE(controller_impl->GetAnimationById(animation_id));
 }
 
 // Ensure that a finished animation is eventually deleted by both the
 // main-thread and the impl-thread controllers.
 TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
   FakeLayerAnimationValueObserver dummy;
   FakeLayerAnimationValueObserver dummy_impl;
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
   controller_impl->AddValueObserver(&dummy_impl);
 
   AddOpacityTransitionToController(controller.get(), 1.0, 0.0f, 1.0f, false);
   controller->Animate(kInitialTickTime);
   controller->UpdateState(true, nullptr);
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
   controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller_impl->UpdateState(true, events.get());
 
   // There should be a STARTED event for the animation.
-  EXPECT_EQ(1u, events->size());
-  EXPECT_EQ(AnimationEvent::STARTED, (*events)[0].type);
-  controller->NotifyAnimationStarted((*events)[0]);
+  EXPECT_EQ(1u, events->events_.size());
+  EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
+  controller->NotifyAnimationStarted(events->events_[0]);
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, nullptr);
 
   EXPECT_FALSE(dummy.animation_waiting_for_deletion());
   EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
-  events.reset(new AnimationEventsVector);
+  events.reset(new AnimationEvents);
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(2000));
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());
 
   // There should be a FINISHED event for the animation.
-  EXPECT_EQ(1u, events->size());
-  EXPECT_EQ(AnimationEvent::FINISHED, (*events)[0].type);
+  EXPECT_EQ(1u, events->events_.size());
+  EXPECT_EQ(AnimationEvent::FINISHED, events->events_[0].type);
 
   // Neither controller should have deleted the animation yet.
   EXPECT_TRUE(controller->GetAnimation(Animation::OPACITY));
   EXPECT_TRUE(controller_impl->GetAnimation(Animation::OPACITY));
 
-  controller->NotifyAnimationFinished((*events)[0]);
+  controller->NotifyAnimationFinished(events->events_[0]);
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   controller->UpdateState(true, nullptr);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   // Both controllers should now have deleted the animation. The impl controller
   // should have deleted the animation even though activation has not occurred,
   // since the animation was already waiting for deletion when
   // PushAnimationUpdatesTo was called.
   EXPECT_FALSE(controller->has_any_animation());
   EXPECT_FALSE(controller_impl->has_any_animation());
 }
 
 // Tests that transitioning opacity from 0 to 1 works as expected.
 
 static const AnimationEvent* GetMostRecentPropertyUpdateEvent(
-    const AnimationEventsVector* events) {
+    const AnimationEvents* events) {
   const AnimationEvent* event = 0;
-  for (size_t i = 0; i < events->size(); ++i)
-    if ((*events)[i].type == AnimationEvent::PROPERTY_UPDATE)
-      event = &(*events)[i];
+  for (size_t i = 0; i < events->events_.size(); ++i)
+    if (events->events_[i].type == AnimationEvent::PROPERTY_UPDATE)
+      event = &events->events_[i];
 
   return event;
 }
 
 TEST(LayerAnimationControllerTest, TrivialTransition) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
 
   EXPECT_FALSE(controller->needs_to_start_animations_for_testing());
   controller->AddAnimation(std::move(to_add));
   EXPECT_TRUE(controller->needs_to_start_animations_for_testing());
   controller->Animate(kInitialTickTime);
   EXPECT_FALSE(controller->needs_to_start_animations_for_testing());
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
   // A non-impl-only animation should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 }
 
 TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
   to_add->set_is_impl_only(true);
 
   controller_impl->AddAnimation(std::move(to_add));
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy_impl.opacity());
-  EXPECT_EQ(1u, events->size());
+  EXPECT_EQ(1u, events->events_.size());
   const AnimationEvent* start_opacity_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(0.f, start_opacity_event->opacity);
 
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy_impl.opacity());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
-  EXPECT_EQ(2u, events->size());
+  EXPECT_EQ(2u, events->events_.size());
   const AnimationEvent* end_opacity_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(1.f, end_opacity_event->opacity);
 }
 
 TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
 
   // Choose different values for x and y to avoid coincidental values in the
   // observed transforms.
   const float delta_x = 3;
   const float delta_y = 4;
 
@@ skipping 11 matching lines @@
   scoped_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, Animation::TRANSFORM));
   animation->set_is_impl_only(true);
   controller_impl->AddAnimation(std::move(animation));
 
   // Run animation.
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(gfx::Transform(), dummy_impl.transform());
-  EXPECT_EQ(1u, events->size());
+  EXPECT_EQ(1u, events->events_.size());
   const AnimationEvent* start_transform_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   ASSERT_TRUE(start_transform_event);
   EXPECT_EQ(gfx::Transform(), start_transform_event->transform);
   EXPECT_TRUE(start_transform_event->is_impl_only);
 
   gfx::Transform expected_transform;
   expected_transform.Translate(delta_x, delta_y);
 
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(expected_transform, dummy_impl.transform());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
-  EXPECT_EQ(2u, events->size());
+  EXPECT_EQ(2u, events->events_.size());
   const AnimationEvent* end_transform_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(expected_transform, end_transform_event->transform);
   EXPECT_TRUE(end_transform_event->is_impl_only);
 }
 
 TEST(LayerAnimationControllerTest, FilterTransition) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   scoped_ptr<KeyframedFilterAnimationCurve> curve(
       KeyframedFilterAnimationCurve::Create());
 
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(1.f));
@@ skipping 26 matching lines @@
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(end_filters, dummy.filters());
   EXPECT_FALSE(controller->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 }
 
 TEST(LayerAnimationControllerTest, FilterTransitionOnImplOnly) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
 
   scoped_ptr<KeyframedFilterAnimationCurve> curve(
       KeyframedFilterAnimationCurve::Create());
 
   // Create simple FILTER animation.
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(1.f));
   curve->AddKeyframe(
       FilterKeyframe::Create(base::TimeDelta(), start_filters, nullptr));
   FilterOperations end_filters;
   end_filters.Append(FilterOperation::CreateBrightnessFilter(2.f));
   curve->AddKeyframe(FilterKeyframe::Create(base::TimeDelta::FromSecondsD(1.0),
                                             end_filters, nullptr));
 
   scoped_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, Animation::FILTER));
   animation->set_is_impl_only(true);
   controller_impl->AddAnimation(std::move(animation));
 
   // Run animation.
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(start_filters, dummy_impl.filters());
-  EXPECT_EQ(1u, events->size());
+  EXPECT_EQ(1u, events->events_.size());
   const AnimationEvent* start_filter_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_TRUE(start_filter_event);
   EXPECT_EQ(start_filters, start_filter_event->filters);
   EXPECT_TRUE(start_filter_event->is_impl_only);
 
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(end_filters, dummy_impl.filters());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
-  EXPECT_EQ(2u, events->size());
+  EXPECT_EQ(2u, events->events_.size());
   const AnimationEvent* end_filter_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_TRUE(end_filter_event);
   EXPECT_EQ(end_filters, end_filter_event->filters);
   EXPECT_TRUE(end_filter_event->is_impl_only);
 }
 
 TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
   FakeLayerAnimationValueObserver dummy_impl;
   FakeLayerAnimationValueProvider dummy_provider_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   controller_impl->set_value_provider(&dummy_provider_impl);
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   FakeLayerAnimationValueProvider dummy_provider;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
   controller->set_value_provider(&dummy_provider);
 
   gfx::ScrollOffset initial_value(100.f, 300.f);
   gfx::ScrollOffset target_value(300.f, 200.f);
   scoped_ptr<ScrollOffsetAnimationCurve> curve(
@@ skipping 22 matching lines @@
   EXPECT_EQ(initial_value, dummy.scroll_offset());
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy_impl.scroll_offset());
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller->NotifyAnimationStarted((*events)[0]);
+  controller->NotifyAnimationStarted(events->events_[0]);
   controller->Animate(kInitialTickTime + duration / 2);
   controller->UpdateState(true, nullptr);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f), dummy.scroll_offset());
 
   controller_impl->Animate(kInitialTickTime + duration / 2);
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f),
                       dummy_impl.scroll_offset());
   event = GetMostRecentPropertyUpdateEvent(events.get());
@@ skipping 13 matching lines @@
 }
 
 // Ensure that when the impl controller doesn't have a value provider,
 // the main-thread controller's value provider is used to obtain the intial
 // scroll offset.
 TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   FakeLayerAnimationValueProvider dummy_provider;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
   controller->set_value_provider(&dummy_provider);
 
   gfx::ScrollOffset initial_value(500.f, 100.f);
   gfx::ScrollOffset target_value(300.f, 200.f);
   scoped_ptr<ScrollOffsetAnimationCurve> curve(
@@ skipping 22 matching lines @@
   EXPECT_EQ(initial_value, dummy.scroll_offset());
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy_impl.scroll_offset());
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-
-  controller->NotifyAnimationStarted((*events)[0]);
+  controller->NotifyAnimationStarted(events->events_[0]);
   controller->Animate(kInitialTickTime + duration / 2);
   controller->UpdateState(true, nullptr);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(400.f, 150.f), dummy.scroll_offset());
 
   controller_impl->Animate(kInitialTickTime + duration / 2);
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(400.f, 150.f),
                       dummy_impl.scroll_offset());
   event = GetMostRecentPropertyUpdateEvent(events.get());
@@ skipping 10 matching lines @@
   controller->UpdateState(true, nullptr);
   EXPECT_VECTOR2DF_EQ(target_value, dummy.scroll_offset());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 TEST(LayerAnimationControllerTest, ScrollOffsetTransitionOnImplOnly) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
 
   gfx::ScrollOffset initial_value(100.f, 300.f);
   gfx::ScrollOffset target_value(300.f, 200.f);
   scoped_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(target_value,
                                          EaseInOutTimingFunction::Create()));
   curve->SetInitialValue(initial_value);
   double duration_in_seconds = curve->Duration().InSecondsF();
 
   scoped_ptr<Animation> animation(
@@ skipping 27 matching lines @@
   EXPECT_FALSE(event);
 }
 
 TEST(LayerAnimationControllerTest, ScrollOffsetRemovalClearsScrollDelta) {
   FakeLayerAnimationValueObserver dummy_impl;
   FakeLayerAnimationValueProvider dummy_provider_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   controller_impl->set_value_provider(&dummy_provider_impl);
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   FakeLayerAnimationValueProvider dummy_provider;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
   controller->set_value_provider(&dummy_provider);
 
   // First test the 1-argument version of RemoveAnimation.
   gfx::ScrollOffset target_value(300.f, 200.f);
   scoped_ptr<ScrollOffsetAnimationCurve> curve(
@@ skipping 109 matching lines @@
 };
 
 // Tests that impl-only animations lead to start and finished notifications
 // on the impl thread controller's animation delegate.
 TEST(LayerAnimationControllerTest,
      NotificationsForImplOnlyAnimationsAreSentToImplThreadDelegate) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeAnimationDelegate delegate;
   controller_impl->set_layer_animation_delegate(&delegate);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
   to_add->set_is_impl_only(true);
   controller_impl->AddAnimation(std::move(to_add));
 
   EXPECT_FALSE(delegate.started());
   EXPECT_FALSE(delegate.finished());
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_TRUE(delegate.started());
   EXPECT_FALSE(delegate.finished());
 
-  events.reset(new AnimationEventsVector);
+  events.reset(new AnimationEvents);
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_TRUE(delegate.started());
   EXPECT_TRUE(delegate.finished());
 }
 
 // Tests that specified start times are sent to the main thread delegate
 TEST(LayerAnimationControllerTest,
@@ skipping 15 matching lines @@
   const TimeTicks start_time = TicksFromSecondsF(123);
   controller->GetAnimation(Animation::OPACITY)->set_start_time(start_time);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
   EXPECT_TRUE(controller_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             controller_impl->GetAnimationById(animation_id)->run_state());
 
-  AnimationEventsVector events;
+  AnimationEvents events;
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, &events);
 
   // Synchronize the start times.
-  EXPECT_EQ(1u, events.size());
-  controller->NotifyAnimationStarted(events[0]);
+  EXPECT_EQ(1u, events.events_.size());
+  controller->NotifyAnimationStarted(events.events_[0]);
 
   // Validate start time on the main thread delegate.
   EXPECT_EQ(start_time, delegate.start_time());
 }
 
 class FakeLayerAnimationEventObserver : public LayerAnimationEventObserver {
  public:
   FakeLayerAnimationEventObserver() : start_time_(base::TimeTicks()) {}
 
   void OnAnimationStarted(const AnimationEvent& event) override {
@@ skipping 25 matching lines @@
   const TimeTicks start_time = TicksFromSecondsF(123);
   controller->GetAnimation(Animation::OPACITY)->set_start_time(start_time);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
   EXPECT_TRUE(controller_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             controller_impl->GetAnimationById(animation_id)->run_state());
 
-  AnimationEventsVector events;
+  AnimationEvents events;
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, &events);
 
   // Synchronize the start times.
-  EXPECT_EQ(1u, events.size());
-  controller->NotifyAnimationStarted(events[0]);
+  EXPECT_EQ(1u, events.events_.size());
+  controller->NotifyAnimationStarted(events.events_[0]);
 
   // Validate start time on the event observer.
   EXPECT_EQ(start_time, observer.start_time());
 }
 
 // Tests animations that are waiting for a synchronized start time do not
 // finish.
 TEST(LayerAnimationControllerTest,
      AnimationsWaitingForStartTimeDoNotFinishIfTheyOutwaitTheirFinish) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
   to_add->set_needs_synchronized_start_time(true);
 
@@ skipping 18 matching lines @@
       AnimationEvent(AnimationEvent::STARTED, 0, 1, Animation::OPACITY,
                      kInitialTickTime + TimeDelta::FromMilliseconds(2000)));
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(5000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Tests that two queued animations affecting the same property run in sequence.
 TEST(LayerAnimationControllerTest, TrivialQueuing) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   EXPECT_FALSE(controller->needs_to_start_animations_for_testing());
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
@@ skipping 20 matching lines @@
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Tests interrupting a transition with another transition.
 TEST(LayerAnimationControllerTest, Interrupt) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
   controller->Animate(kInitialTickTime);
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
@@ skipping 13 matching lines @@
   EXPECT_EQ(1.f, dummy.opacity());
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Tests scheduling two animations to run together when only one property is
 // free.
 TEST(LayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1,
       Animation::TRANSFORM));
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)), 2,
@@ skipping 15 matching lines @@
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Tests scheduling two animations to run together with different lengths and
 // another animation queued to start when the shorter animation finishes (should
 // wait for both to finish).
 TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(2)), 1,
       Animation::TRANSFORM));
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
@@ skipping 19 matching lines @@
   // The second opacity animation should start at time 2 and should be done by
   // time 3.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Test that a looping animation loops and for the correct number of iterations.
 TEST(LayerAnimationControllerTest, TrivialLooping) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
   to_add->set_iterations(3);
   controller->AddAnimation(std::move(to_add));
@@ skipping 24 matching lines @@
   EXPECT_EQ(1.f, dummy.opacity());
 
   // Just be extra sure.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
 }
 
 // Test that an infinitely looping animation does indeed go until aborted.
 TEST(LayerAnimationControllerTest, InfiniteLooping) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
   to_add->set_iterations(-1);
   controller->AddAnimation(std::move(to_add));
@@ skipping 25 matching lines @@
   EXPECT_TRUE(controller->GetAnimation(Animation::OPACITY));
   controller->GetAnimation(Animation::OPACITY)
       ->SetRunState(Animation::ABORTED,
                     kInitialTickTime + TimeDelta::FromMilliseconds(750));
   EXPECT_FALSE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
 }
 
 // Test that pausing and resuming work as expected.
 TEST(LayerAnimationControllerTest, PauseResume) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
 
   controller->Animate(kInitialTickTime);
@@ skipping 24 matching lines @@
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024500));
   controller->UpdateState(true, events.get());
   EXPECT_FALSE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
 }
 
 TEST(LayerAnimationControllerTest, AbortAGroupedAnimation) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   const int animation_id = 2;
   controller->AddAnimation(Animation::Create(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1, 1,
       Animation::TRANSFORM));
   controller->AddAnimation(Animation::Create(
@@ skipping 24 matching lines @@
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(!controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
 }
 
 TEST(LayerAnimationControllerTest, PushUpdatesWhenSynchronizedStartTimeNeeded) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)), 0,
       Animation::OPACITY));
   to_add->set_needs_synchronized_start_time(true);
   controller->AddAnimation(std::move(to_add));
 
   controller->Animate(kInitialTickTime);
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   Animation* active_animation = controller->GetAnimation(Animation::OPACITY);
   EXPECT_TRUE(active_animation);
   EXPECT_TRUE(active_animation->needs_synchronized_start_time());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
   active_animation = controller_impl->GetAnimation(Animation::OPACITY);
   EXPECT_TRUE(active_animation);
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             active_animation->run_state());
 }
 
 // Tests that skipping a call to UpdateState works as expected.
 TEST(LayerAnimationControllerTest, SkipUpdateState) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> first_animation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1,
       Animation::TRANSFORM));
   first_animation->set_is_controlling_instance_for_test(true);
   controller->AddAnimation(std::move(first_animation));
 
   controller->Animate(kInitialTickTime);
   controller->UpdateState(true, events.get());
 
   scoped_ptr<Animation> second_animation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 2,
       Animation::OPACITY));
   second_animation->set_is_controlling_instance_for_test(true);
   controller->AddAnimation(std::move(second_animation));
 
   // Animate but don't UpdateState.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
-  events.reset(new AnimationEventsVector);
+  events.reset(new AnimationEvents);
   controller->UpdateState(true, events.get());
 
   // Should have one STARTED event and one FINISHED event.
-  EXPECT_EQ(2u, events->size());
-  EXPECT_NE((*events)[0].type, (*events)[1].type);
+  EXPECT_EQ(2u, events->events_.size());
+  EXPECT_NE(events->events_[0].type, events->events_[1].type);
 
   // The float transition should still be at its starting point.
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   controller->UpdateState(true, events.get());
 
   // The float tranisition should now be done.
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Tests that an animation controller with only a pending observer gets ticked
 // but doesn't progress animations past the STARTING state.
 TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy;
   FakeInactiveLayerAnimationValueObserver pending_dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
 
   const int id = 1;
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.5f, 1.f)), id,
       Animation::OPACITY));
 
   // Without an observer, the animation shouldn't progress to the STARTING
   // state.
   controller->Animate(kInitialTickTime);
   controller->UpdateState(true, events.get());
-  EXPECT_EQ(0u, events->size());
+  EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             controller->GetAnimation(Animation::OPACITY)->run_state());
 
   controller->AddValueObserver(&pending_dummy);
 
   // With only a pending observer, the animation should progress to the
   // STARTING state and get ticked at its starting point, but should not
   // progress to RUNNING.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
-  EXPECT_EQ(0u, events->size());
+  EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::STARTING,
             controller->GetAnimation(Animation::OPACITY)->run_state());
   EXPECT_EQ(0.5f, pending_dummy.opacity());
 
   // Even when already in the STARTING state, the animation should stay
   // there, and shouldn't be ticked past its starting point.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   controller->UpdateState(true, events.get());
-  EXPECT_EQ(0u, events->size());
+  EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::STARTING,
             controller->GetAnimation(Animation::OPACITY)->run_state());
   EXPECT_EQ(0.5f, pending_dummy.opacity());
 
   controller->AddValueObserver(&dummy);
 
   // Now that an active observer has been added, the animation should still
   // initially tick at its starting point, but should now progress to RUNNING.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   controller->UpdateState(true, events.get());
-  EXPECT_EQ(1u, events->size());
+  EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(Animation::RUNNING,
             controller->GetAnimation(Animation::OPACITY)->run_state());
   EXPECT_EQ(0.5f, pending_dummy.opacity());
   EXPECT_EQ(0.5f, dummy.opacity());
 
   // The animation should now tick past its starting point.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3500));
   EXPECT_NE(0.5f, pending_dummy.opacity());
   EXPECT_NE(0.5f, dummy.opacity());
 }
@@ skipping 166 matching lines @@
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_TRUE(controller_impl->GetAnimationById(animation_id));
 
   controller_impl->AbortAnimations(Animation::OPACITY);
   EXPECT_EQ(Animation::ABORTED,
             controller_impl->GetAnimation(Animation::OPACITY)->run_state());
   EXPECT_FALSE(dummy.animation_waiting_for_deletion());
   EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
-  AnimationEventsVector events;
+  AnimationEvents events;
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, &events);
   EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());
-  EXPECT_EQ(1u, events.size());
-  EXPECT_EQ(AnimationEvent::ABORTED, events[0].type);
+  EXPECT_EQ(1u, events.events_.size());
+  EXPECT_EQ(AnimationEvent::ABORTED, events.events_[0].type);
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             controller_impl->GetAnimation(Animation::OPACITY)->run_state());
 
-  controller->NotifyAnimationAborted(events[0]);
+  controller->NotifyAnimationAborted(events.events_[0]);
   EXPECT_EQ(Animation::ABORTED,
             controller->GetAnimation(Animation::OPACITY)->run_state());
 
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, nullptr);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             controller->GetAnimation(Animation::OPACITY)->run_state());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_FALSE(controller->GetAnimationById(animation_id));
   EXPECT_FALSE(controller_impl->GetAnimationById(animation_id));
 }
 
 // Ensure that we only generate FINISHED events for animations in a group
 // once all animations in that group are finished.
 TEST(LayerAnimationControllerTest, FinishedEventsForGroup) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
 
   const int group_id = 1;
 
   // Add two animations with the same group id but different durations.
   scoped_ptr<Animation> first_animation(Animation::Create(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(2.0)), 1, group_id,
       Animation::TRANSFORM));
   first_animation->set_is_controlling_instance_for_test(true);
   controller_impl->AddAnimation(std::move(first_animation));
 
   scoped_ptr<Animation> second_animation(Animation::Create(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 2,
       group_id, Animation::OPACITY));
   second_animation->set_is_controlling_instance_for_test(true);
   controller_impl->AddAnimation(std::move(second_animation));
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
 
   // Both animations should have started.
-  EXPECT_EQ(2u, events->size());
-  EXPECT_EQ(AnimationEvent::STARTED, (*events)[0].type);
-  EXPECT_EQ(AnimationEvent::STARTED, (*events)[1].type);
+  EXPECT_EQ(2u, events->events_.size());
+  EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
+  EXPECT_EQ(AnimationEvent::STARTED, events->events_[1].type);
 
-  events.reset(new AnimationEventsVector);
+  events.reset(new AnimationEvents);
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
 
   // The opacity animation should be finished, but should not have generated
   // a FINISHED event yet.
-  EXPECT_EQ(0u, events->size());
+  EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::FINISHED,
             controller_impl->GetAnimationById(2)->run_state());
   EXPECT_EQ(Animation::RUNNING,
             controller_impl->GetAnimationById(1)->run_state());
 
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(2000));
   controller_impl->UpdateState(true, events.get());
 
   // Both animations should have generated FINISHED events.
-  EXPECT_EQ(2u, events->size());
-  EXPECT_EQ(AnimationEvent::FINISHED, (*events)[0].type);
-  EXPECT_EQ(AnimationEvent::FINISHED, (*events)[1].type);
+  EXPECT_EQ(2u, events->events_.size());
+  EXPECT_EQ(AnimationEvent::FINISHED, events->events_[0].type);
+  EXPECT_EQ(AnimationEvent::FINISHED, events->events_[1].type);
 }
 
 // Ensure that when a group has a mix of aborted and finished animations,
 // we generate a FINISHED event for the finished animation and an ABORTED
 // event for the aborted animation.
 TEST(LayerAnimationControllerTest, FinishedAndAbortedEventsForGroup) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
 
   // Add two animations with the same group id.
   scoped_ptr<Animation> first_animation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1.0)), 1,
       Animation::TRANSFORM));
   first_animation->set_is_controlling_instance_for_test(true);
   controller_impl->AddAnimation(std::move(first_animation));
 
   scoped_ptr<Animation> second_animation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
       Animation::OPACITY));
   second_animation->set_is_controlling_instance_for_test(true);
   controller_impl->AddAnimation(std::move(second_animation));
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
 
   // Both animations should have started.
-  EXPECT_EQ(2u, events->size());
-  EXPECT_EQ(AnimationEvent::STARTED, (*events)[0].type);
-  EXPECT_EQ(AnimationEvent::STARTED, (*events)[1].type);
+  EXPECT_EQ(2u, events->events_.size());
+  EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
+  EXPECT_EQ(AnimationEvent::STARTED, events->events_[1].type);
 
   controller_impl->AbortAnimations(Animation::OPACITY);
 
-  events.reset(new AnimationEventsVector);
+  events.reset(new AnimationEvents);
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
 
   // We should have exactly 2 events: a FINISHED event for the tranform
   // animation, and an ABORTED event for the opacity animation.
-  EXPECT_EQ(2u, events->size());
-  EXPECT_EQ(AnimationEvent::FINISHED, (*events)[0].type);
-  EXPECT_EQ(Animation::TRANSFORM, (*events)[0].target_property);
-  EXPECT_EQ(AnimationEvent::ABORTED, (*events)[1].type);
-  EXPECT_EQ(Animation::OPACITY, (*events)[1].target_property);
+  EXPECT_EQ(2u, events->events_.size());
+  EXPECT_EQ(AnimationEvent::FINISHED, events->events_[0].type);
+  EXPECT_EQ(Animation::TRANSFORM, events->events_[0].target_property);
+  EXPECT_EQ(AnimationEvent::ABORTED, events->events_[1].type);
+  EXPECT_EQ(Animation::OPACITY, events->events_[1].target_property);
 }
 
 TEST(LayerAnimationControllerTest, HasAnimationThatAffectsScale) {
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
 
   EXPECT_FALSE(controller_impl->HasAnimationThatAffectsScale());
 
   controller_impl->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)), 1,
@@ skipping 424 matching lines @@
   animation->set_direction(Animation::DIRECTION_REVERSE);
   EXPECT_TRUE(controller_impl->MaximumTargetScale(
       LayerAnimationController::ObserverType::PENDING, &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(controller_impl->MaximumTargetScale(
       LayerAnimationController::ObserverType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 }
 
 TEST(LayerAnimationControllerTest, NewlyPushedAnimationWaitsForActivation) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy_impl;
   FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   controller_impl->AddValueObserver(&pending_dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
@@ skipping 41 matching lines @@
 
   // Since the animation has been activated, it should have reached the
   // RUNNING state and the active observer should start to get ticked.
   EXPECT_EQ(Animation::RUNNING,
             controller_impl->GetAnimationById(animation_id)->run_state());
   EXPECT_EQ(0.5f, pending_dummy_impl.opacity());
   EXPECT_EQ(0.5f, dummy_impl.opacity());
 }
 
 TEST(LayerAnimationControllerTest, ActivationBetweenAnimateAndUpdateState) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy_impl;
   FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   controller_impl->AddValueObserver(&pending_dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
@@ skipping 33 matching lines @@
 
   controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
 
   // Both observers should have been ticked.
   EXPECT_EQ(0.75f, pending_dummy_impl.opacity());
   EXPECT_EQ(0.75f, dummy_impl.opacity());
 }
 
 TEST(LayerAnimationControllerTest,
      ObserverNotifiedWhenTransformIsPotentiallyAnimatingChanges) {
-  AnimationEventsVector events;
+  AnimationEvents events;
   FakeLayerAnimationValueObserver active_dummy_impl;
   FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&active_dummy_impl);
   controller_impl->AddValueObserver(&pending_dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
@@ skipping 10 matching lines @@
   EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
   EXPECT_FALSE(active_dummy_impl.transform_is_animating());
 
   controller_impl->ActivateAnimations();
   EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
   EXPECT_TRUE(active_dummy_impl.transform_is_animating());
 
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, &events);
 
-  controller->NotifyAnimationStarted(events[0]);
-  events.clear();
+  controller->NotifyAnimationStarted(events.events_[0]);
+  events.events_.clear();
 
   // Finish the animation.
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, nullptr);
   EXPECT_FALSE(dummy.transform_is_animating());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   // controller_impl hasn't yet ticked at/past the end of the animation.
   EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
   EXPECT_TRUE(active_dummy_impl.transform_is_animating());
 
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, &events);
   EXPECT_FALSE(pending_dummy_impl.transform_is_animating());
   EXPECT_FALSE(active_dummy_impl.transform_is_animating());
 
-  controller->NotifyAnimationFinished(events[0]);
-  events.clear();
+  controller->NotifyAnimationFinished(events.events_[0]);
+  events.events_.clear();
 
   // Case 2: An animation that's removed before it finishes.
   int animation_id =
       AddAnimatedTransformToController(controller.get(), 10.0, 2, 2);
   EXPECT_TRUE(dummy.transform_is_animating());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
   EXPECT_FALSE(active_dummy_impl.transform_is_animating());
 
   controller_impl->ActivateAnimations();
   EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
   EXPECT_TRUE(active_dummy_impl.transform_is_animating());
 
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(2000));
   controller_impl->UpdateState(true, &events);
 
-  controller->NotifyAnimationStarted(events[0]);
-  events.clear();
+  controller->NotifyAnimationStarted(events.events_[0]);
+  events.events_.clear();
 
   controller->RemoveAnimation(animation_id);
   EXPECT_FALSE(dummy.transform_is_animating());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   EXPECT_FALSE(pending_dummy_impl.transform_is_animating());
   EXPECT_TRUE(active_dummy_impl.transform_is_animating());
 
   controller_impl->ActivateAnimations();
   EXPECT_FALSE(pending_dummy_impl.transform_is_animating());
   EXPECT_FALSE(active_dummy_impl.transform_is_animating());
 
   // Case 3: An animation that's aborted before it finishes.
   animation_id = AddAnimatedTransformToController(controller.get(), 10.0, 3, 3);
   EXPECT_TRUE(dummy.transform_is_animating());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
   EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
   EXPECT_FALSE(active_dummy_impl.transform_is_animating());
 
   controller_impl->ActivateAnimations();
   EXPECT_TRUE(pending_dummy_impl.transform_is_animating());
   EXPECT_TRUE(active_dummy_impl.transform_is_animating());
 
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(3000));
   controller_impl->UpdateState(true, &events);
 
-  controller->NotifyAnimationStarted(events[0]);
-  events.clear();
+  controller->NotifyAnimationStarted(events.events_[0]);
+  events.events_.clear();
 
   controller_impl->AbortAnimations(Animation::TRANSFORM);
   EXPECT_FALSE(pending_dummy_impl.transform_is_animating());
   EXPECT_FALSE(active_dummy_impl.transform_is_animating());
 
   controller_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(4000));
   controller_impl->UpdateState(true, &events);
 
-  controller->NotifyAnimationAborted(events[0]);
+  controller->NotifyAnimationAborted(events.events_[0]);
   EXPECT_FALSE(dummy.transform_is_animating());
 }
 
 TEST(LayerAnimationControllerTest, ClippedOpacityValues) {
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
 
   AddOpacityTransitionToController(controller.get(), 1, 1.f, 2.f, true);
@@ skipping 16 matching lines @@
 
   controller->Animate(kInitialTickTime);
   EXPECT_EQ(0.f, dummy.opacity());
 
   // Opacity values are clipped [0,1]
   controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   EXPECT_EQ(0.f, dummy.opacity());
 }
 
 TEST(LayerAnimationControllerTest, PushedDeletedAnimationWaitsForActivation) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy_impl;
   FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   controller_impl->AddValueObserver(&pending_dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
@@ skipping 35 matching lines @@
 
   controller_impl->ActivateAnimations();
 
   // Activation should cause the animation to be deleted.
   EXPECT_FALSE(controller_impl->has_any_animation());
 }
 
 // Tests that an animation that affects only active observers won't block
 // an animation that affects only pending observers from starting.
 TEST(LayerAnimationControllerTest, StartAnimationsAffectingDifferentObservers) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
+  scoped_ptr<AnimationEvents> events(make_scoped_ptr(new AnimationEvents));
   FakeLayerAnimationValueObserver dummy_impl;
   FakeInactiveLayerAnimationValueObserver pending_dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   controller_impl->AddValueObserver(&pending_dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
   controller->AddValueObserver(&dummy);
@@ skipping 211 matching lines @@
   EXPECT_FALSE(controller->IsPotentiallyAnimatingProperty(
       Animation::OPACITY, LayerAnimationController::ObserverType::ACTIVE));
   EXPECT_FALSE(controller->IsCurrentlyAnimatingProperty(
       Animation::OPACITY, LayerAnimationController::ObserverType::PENDING));
   EXPECT_FALSE(controller->IsCurrentlyAnimatingProperty(
       Animation::OPACITY, LayerAnimationController::ObserverType::ACTIVE));
 }
 
 }  // namespace
 }  // namespace cc