CC Animation: Replace AnimiationEventsVector with AnimiationEvents class.

cc/trees/layer_tree_host.cc

 // Copyright 2011 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/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
 #include "base/atomic_sequence_num.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
+#include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/layers/heads_up_display_layer.h"
@@ skipping 509 matching lines @@
 
 void LayerTreeHost::SetNextCommitWaitsForActivation() {
   proxy_->SetNextCommitWaitsForActivation();
 }
 
 void LayerTreeHost::SetNextCommitForcesRedraw() {
   next_commit_forces_redraw_ = true;
   proxy_->SetNeedsUpdateLayers();
 }
 
-void LayerTreeHost::SetAnimationEvents(
-    scoped_ptr<AnimationEventsVector> events) {
+void LayerTreeHost::SetAnimationEvents(scoped_ptr<AnimationEvents> events) {
   DCHECK(task_runner_provider_->IsMainThread());
   if (animation_host_)
     animation_host_->SetAnimationEvents(std::move(events));
   else
     animation_registrar_->SetAnimationEvents(std::move(events));
 }
 
 void LayerTreeHost::SetRootLayer(scoped_refptr<Layer> root_layer) {
   if (root_layer_.get() == root_layer.get())
     return;
@@ skipping 347 matching lines @@
                                            bool animate) {
   // Top controls are only used in threaded mode.
   DCHECK(IsThreaded());
   proxy_->UpdateTopControlsState(constraints, current, animate);
 }
 
 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled)
     return;
 
-  AnimationEventsVector events;
+  scoped_ptr<AnimationEvents> events;
   if (animation_host_) {
+    events = animation_host_->CreateEvents();
     if (animation_host_->AnimateLayers(monotonic_time))
-      animation_host_->UpdateAnimationState(true, &events);
+      animation_host_->UpdateAnimationState(true, events.get());
   } else {
+    events = animation_registrar_->CreateEvents();
     if (animation_registrar_->AnimateLayers(monotonic_time))
-      animation_registrar_->UpdateAnimationState(true, &events);
+      animation_registrar_->UpdateAnimationState(true, events.get());
   }
 
-  if (!events.empty())
+  if (!events->events_.empty())
     property_trees_.needs_rebuild = true;
 }
 
 UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
   DCHECK(client);
 
   UIResourceId next_id = next_ui_resource_id_++;
   DCHECK(ui_resource_client_map_.find(next_id) ==
          ui_resource_client_map_.end());
 
@@ skipping 326 matching lines @@
   return compositor_mode_ == CompositorMode::SingleThreaded;
 }
 
 bool LayerTreeHost::IsThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::Threaded ||
          task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::Threaded;
 }
 
 }  // namespace cc