CC Animations: Establish AnimationHost, AnimationTimeline and AnimationPlayer

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 "cc/animation/animation_player.h"
+#include "cc/animation/animation_registrar.h"
+#include "cc/animation/animation_timeline.h"
+#include "cc/trees/layer_tree_mutators_client.h"
+
+namespace cc {
+
+scoped_ptr<AnimationHost> AnimationHost::Create(bool is_impl_instance) {
+  return make_scoped_ptr(new AnimationHost(is_impl_instance));
+}
+
+AnimationHost::AnimationHost(bool is_impl_instance)
+    : animation_registrar_(AnimationRegistrar::Create()),
+      layer_tree_mutators_client_(),
+      is_impl_instance_(is_impl_instance) {
+}
+
+AnimationHost::~AnimationHost() {
+  ClearTimelines();
+  DCHECK(!layer_tree_mutators_client());
+}
+
+AnimationTimeline* AnimationHost::GetTimelineById(int timeline_id) const {
+  for (auto& timeline : timelines_)
+    if (timeline->id() == timeline_id)
+      return timeline.get();
+  return nullptr;
+}
+
+void AnimationHost::ClearTimelines() {
+  EraseTimelines(timelines_.begin(), timelines_.end());
+}
+
+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::AddAnimationTimeline(AnimationTimeline* timeline) {
+  timeline->SetAnimationHost(this);
+  timelines_.push_back(timeline);
+}
+
+void AnimationHost::RemoveAnimationTimeline(AnimationTimeline* timeline) {
+  for (auto iter = timelines_.begin(); iter != timelines_.end(); ++iter) {
+    if (iter->get() != timeline)
+      continue;
+
+    EraseTimelines(iter, iter + 1);
+    break;
+  }
+}
+
+void AnimationHost::RegisterLayer(int layer_id, bool is_active_tree) {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  if (player)

[ajuma, 2015/04/22 15:47:18]

Can this be a DCHECK? (And if not, what if RegisterPlayerForLayer gets called
later?)

[loyso (OOO), 2015/04/30 06:40:21]

No, it can't. AnimationPlayer::AddControllerToTimeline (which calls
RegisterPlayerForLayer) checks, whether layer was registered before via
animation_host_->layer_tree_mutators_client()->IsLayerInActiveTree() or
animation_host_->layer_tree_mutators_client()->IsLayerInPendingTree().

+    player->LayerRegistered(layer_id, is_active_tree);
+}
+
+void AnimationHost::UnregisterLayer(int layer_id, bool is_active_tree) {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  if (player)
+    player->LayerUnregistered(layer_id, is_active_tree);
+}
+
+void AnimationHost::RegisterPlayerForLayer(int layer_id,
+                                           AnimationPlayer* player) {
+  DCHECK(layer_id);
+  DCHECK(player);
+  layer_to_player_map_[layer_id] = player;
+}
+
+void AnimationHost::UnregisterPlayerForLayer(int layer_id,
+                                             AnimationPlayer* player) {
+  DCHECK(layer_id);
+  DCHECK(player);
+  auto iter = layer_to_player_map_.find(layer_id);
+  if (iter != layer_to_player_map_.end() && iter->second == player)
+    layer_to_player_map_.erase(iter);
+}
+
+void AnimationHost::SetLayerTreeMutatorsClient(
+    LayerTreeMutatorsClient* client) {
+  if (layer_tree_mutators_client_ == client)
+    return;
+
+  layer_tree_mutators_client_ = client;
+}
+
+void AnimationHost::SetNeedsCommit() {
+  DCHECK(layer_tree_mutators_client_);
+  layer_tree_mutators_client_->SetMutatorsNeedCommit();
+}
+
+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_) {
+    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_;
+
+  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());
+}
+
+void AnimationHost::PushPropertiesToImplThread(AnimationHost* host_impl) {
+  for (auto& timeline : timelines_) {
+    AnimationTimeline* timeline_impl =
+        host_impl->GetTimelineById(timeline->id());
+    if (timeline_impl)
+      timeline->PushPropertiesTo(timeline_impl);
+  }
+}
+
+AnimationPlayer* AnimationHost::GetPlayerForLayerId(int layer_id) const {
+  DCHECK(layer_id);
+  auto iter = layer_to_player_map_.find(layer_id);
+  return iter == layer_to_player_map_.end() ? nullptr : iter->second;
+}
+
+}  // namespace cc