CC Animation: Use unordered_map instead of vector.

cc/animation/animation_host.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/animation_host.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "cc/animation/animation_delegate.h"
@@ skipping 149 matching lines @@
 
 AnimationHost::~AnimationHost() {
   scroll_offset_animations_ = nullptr;
 
   ClearTimelines();
   DCHECK(!mutator_host_client());
   DCHECK(layer_to_element_animations_map_.empty());
 }
 
 AnimationTimeline* AnimationHost::GetTimelineById(int timeline_id) const {
-  for (auto& timeline : timelines_)
-    if (timeline->id() == timeline_id)
-      return timeline.get();
-  return nullptr;
+  auto f = id_to_timeline_map_.find(timeline_id);
+  return f == id_to_timeline_map_.end() ? nullptr : f->second.get();
 }
 
 void AnimationHost::ClearTimelines() {
-  EraseTimelines(timelines_.begin(), timelines_.end());
+  for (auto& kv : id_to_timeline_map_)
+    EraseTimeline(kv.second);
+  id_to_timeline_map_.clear();
 }
 
-void AnimationHost::EraseTimelines(AnimationTimelineList::iterator begin,
-                                   AnimationTimelineList::iterator end) {
-  for (auto i = begin; i != end; ++i) {
-    auto& timeline = *i;
-    timeline->ClearPlayers();
-    timeline->SetAnimationHost(nullptr);
-  }
-
-  timelines_.erase(begin, end);
+void AnimationHost::EraseTimeline(scoped_refptr<AnimationTimeline> timeline) {
+  timeline->ClearPlayers();
+  timeline->SetAnimationHost(nullptr);
 }
 
 void AnimationHost::AddAnimationTimeline(
     scoped_refptr<AnimationTimeline> timeline) {
+  DCHECK(timeline->id());
   timeline->SetAnimationHost(this);
-  timelines_.push_back(timeline);
+  id_to_timeline_map_.insert(
+      std::make_pair(timeline->id(), std::move(timeline)));
 }
 
 void AnimationHost::RemoveAnimationTimeline(
     scoped_refptr<AnimationTimeline> timeline) {
-  for (auto iter = timelines_.begin(); iter != timelines_.end(); ++iter) {
-    if (iter->get() != timeline)
-      continue;
-
-    EraseTimelines(iter, iter + 1);
-    break;
-  }
+  DCHECK(timeline->id());
+  EraseTimeline(timeline);
+  id_to_timeline_map_.erase(timeline->id());
 }
 
 void AnimationHost::RegisterLayer(int layer_id, LayerTreeType tree_type) {
   ElementAnimations* element_animations =
       GetElementAnimationsForLayerId(layer_id);
   if (element_animations)
     element_animations->LayerRegistered(layer_id, tree_type);
 }
 
 void AnimationHost::UnregisterLayer(int layer_id, LayerTreeType tree_type) {
@@ skipping 57 matching lines @@
   mutator_host_client_->SetMutatorsNeedRebuildPropertyTrees();
 }
 
 void AnimationHost::PushPropertiesTo(AnimationHost* host_impl) {
   PushTimelinesToImplThread(host_impl);
   RemoveTimelinesFromImplThread(host_impl);
   PushPropertiesToImplThread(host_impl);
 }
 
 void AnimationHost::PushTimelinesToImplThread(AnimationHost* host_impl) const {
-  for (auto& timeline : timelines_) {
+  for (auto& kv : id_to_timeline_map_) {
+    auto& timeline = kv.second;
     AnimationTimeline* timeline_impl =
         host_impl->GetTimelineById(timeline->id());
     if (timeline_impl)
       continue;
 
     scoped_refptr<AnimationTimeline> to_add = timeline->CreateImplInstance();
     host_impl->AddAnimationTimeline(to_add.get());
   }
 }
 
 void AnimationHost::RemoveTimelinesFromImplThread(
     AnimationHost* host_impl) const {
-  AnimationTimelineList& timelines_impl = host_impl->timelines_;
+  IdToTimelineMap& timelines_impl = host_impl->id_to_timeline_map_;
 
-  auto to_erase =
-      std::partition(timelines_impl.begin(), timelines_impl.end(),
-                     [this](AnimationTimelineList::value_type timeline_impl) {
-                       return timeline_impl->is_impl_only() ||
-                              GetTimelineById(timeline_impl->id());
-                     });
-
-  host_impl->EraseTimelines(to_erase, timelines_impl.end());
+  // Erase all the impl timelines which |this| doesn't have.
+  for (auto it = timelines_impl.begin(); it != timelines_impl.end();) {
+    auto& timeline_impl = it->second;
+    if (timeline_impl->is_impl_only() || GetTimelineById(timeline_impl->id())) {
+      ++it;
+    } else {
+      host_impl->EraseTimeline(it->second);
+      it = timelines_impl.erase(it);
+    }
+  }
 }
 
 void AnimationHost::PushPropertiesToImplThread(AnimationHost* host_impl) {
   // Firstly, sync all players with impl thread to create ElementAnimations and
   // layer animation controllers.
-  for (auto& timeline : timelines_) {
+  for (auto& kv : id_to_timeline_map_) {
+    AnimationTimeline* timeline = kv.second.get();
     AnimationTimeline* timeline_impl =
         host_impl->GetTimelineById(timeline->id());
     if (timeline_impl)
       timeline->PushPropertiesTo(timeline_impl);
   }
 
   // Secondly, sync properties for created layer animation controllers.
   for (auto& kv : layer_to_element_animations_map_) {
     ElementAnimations* element_animations = kv.second.get();
     ElementAnimations* element_animations_impl =
@@ skipping 277 matching lines @@
   return scroll_offset_animations_->ScrollAnimationUpdateTarget(
       layer_id, scroll_delta, max_scroll_offset, frame_monotonic_time);
 }
 
 void AnimationHost::ScrollAnimationAbort(bool needs_completion) {
   DCHECK(scroll_offset_animations_);
   return scroll_offset_animations_->ScrollAnimationAbort(needs_completion);
 }
 
 }  // namespace cc