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)
+    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)

[Ian Vollick, 2015/05/05 03:52:06]

when would iter->second != player?

[loyso (OOO), 2015/05/05 06:51:18]

Good point! We should go with DCHECK here and in RegisterPlayerForLayer.
In future, we must be able to run multiple AnimationPlayers per
blink::Element/cc::Layer.

[loyso (OOO), 2015/06/22 07:48:51]

Well, in fact this is an intermediate state of things. There is a TODO(loyso)
comment in animation_host.h for this (near the layer_to_players_map_ member). In
blink we can have many blink::AnimationPlayers per blink::Element. In cc we
re-use the old system for now. It has a limitation - one LAC per 1 Layer. The
temporary solution in these CLs is that cc::AnimationPlayer share the same LAC
if they are attached to same Element's Layer. (See
AnimationPlayer::AddControllerToTimeline ... layer_animation_controller_ =
registrar->GetAnimationControllerForId(layer_id_))

As a result, there is no difference which player is mapped for a given layer_id,
the mapping leads to the same LAC anyway.

I've added PlayersList in the recent PatchSet to make layer-to-player
relationship explicit.

And the plan is to merge LAC into cc::AnimationPlayer and allow different
AnimationPlayers to play same-Layer and same-property animations (like Blink
does). Also, we will need cc::LayerAnimations (a counterpart for
blink::ElementAnimations). This is the unification part.

I'm thinking if I need to introduce cc::LayerAnimations (cc::ElementAnimations?)
in this CL.

[Ian Vollick, 2015/06/22 13:58:39]

That sounds reasonable. Thanks for the details.

+    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