CC Animations: Redirect all compositor animation requests to AnimationHost.

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"
+#include "ui/gfx/geometry/box_f.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_(),
@@ skipping 123 matching lines @@
       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;
 }
 
+void AnimationHost::SetSupportsScrollAnimations(
+    bool supports_scroll_animations) {
+  animation_registrar_->set_supports_scroll_animations(
+      supports_scroll_animations);
+}
+
+bool AnimationHost::GetSupportsScrollAnimations() const {

[ajuma, 2015/04/21 17:57:57]

Nit: s/GetSupportsScrollAnimations/SupportsScrollAnimations

[loyso (OOO), 2015/04/22 01:08:11]

Acknowledged.

+  return animation_registrar_->supports_scroll_animations();
+}
+
+bool AnimationHost::NeedsAnimateLayers() const {
+  return animation_registrar_->needs_animate_layers();
+}
+
+bool AnimationHost::ActivateAnimations() {
+  return animation_registrar_->ActivateAnimations();
+}
+
+bool AnimationHost::AnimateLayers(base::TimeTicks monotonic_time) {
+  return animation_registrar_->AnimateLayers(monotonic_time);
+}
+
+bool AnimationHost::UpdateAnimationState(bool start_ready_animations,
+                                         AnimationEventsVector* events) {
+  return animation_registrar_->UpdateAnimationState(start_ready_animations,
+                                                    events);
+}
+
+scoped_ptr<AnimationEventsVector> AnimationHost::CreateEvents() {
+  return animation_registrar_->CreateEvents();
+}
+
+void AnimationHost::SetAnimationEvents(
+    scoped_ptr<AnimationEventsVector> events) {
+  return animation_registrar_->SetAnimationEvents(events.Pass());
+}
+
+bool AnimationHost::IsAnimatingFilterProperty(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);

[loyso (OOO), 2015/04/22 01:27:30]

We have a hash look-up for such a request. The number of players is very low (in
average). However, the number of requests can be quite high. As a future
solution we could manage a LayerTreeMutator weak pointer(s) from a Layer to it's
attached player(s). That pointer would be non-null within Attach/Detach scope.

+  return player
+             ? player->layer_animation_controller()->IsAnimatingProperty(
+                   Animation::FILTER)
+             : false;
+}
+
+bool AnimationHost::IsAnimatingOpacityProperty(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()->IsAnimatingProperty(
+                   Animation::OPACITY)
+             : false;
+}
+
+bool AnimationHost::IsAnimatingTransformProperty(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()->IsAnimatingProperty(
+                   Animation::TRANSFORM)
+             : false;
+}
+
+bool AnimationHost::FilterIsAnimatingOnImplOnly(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  if (!player)
+    return false;
+
+  Animation* animation =
+      player->layer_animation_controller()->GetAnimation(Animation::FILTER);
+  return animation && animation->is_impl_only();
+}
+
+bool AnimationHost::OpacityIsAnimatingOnImplOnly(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  if (!player)
+    return false;
+
+  Animation* animation =
+      player->layer_animation_controller()->GetAnimation(Animation::OPACITY);
+  return animation && animation->is_impl_only();
+}
+
+bool AnimationHost::TransformIsAnimatingOnImplOnly(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  if (!player)
+    return false;
+
+  Animation* animation =
+      player->layer_animation_controller()->GetAnimation(Animation::TRANSFORM);
+  return animation && animation->is_impl_only();
+}
+
+bool AnimationHost::HasFilterAnimationThatInflatesBounds(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()
+                   ->HasFilterAnimationThatInflatesBounds()
+             : false;
+}
+
+bool AnimationHost::HasTransformAnimationThatInflatesBounds(
+    int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()
+                   ->HasTransformAnimationThatInflatesBounds()
+             : false;
+}
+
+bool AnimationHost::HasAnimationThatInflatesBounds(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()
+                   ->HasAnimationThatInflatesBounds()
+             : false;
+}
+
+bool AnimationHost::FilterAnimationBoundsForBox(int layer_id,
+                                                const gfx::BoxF& box,
+                                                gfx::BoxF* bounds) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()
+                   ->FilterAnimationBoundsForBox(box, bounds)
+             : false;
+}
+
+bool AnimationHost::TransformAnimationBoundsForBox(int layer_id,
+                                                   const gfx::BoxF& box,
+                                                   gfx::BoxF* bounds) const {
+  *bounds = gfx::BoxF();
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()
+                   ->TransformAnimationBoundsForBox(box, bounds)
+             : true;
+}
+
+bool AnimationHost::HasOnlyTranslationTransforms(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()
+                   ->HasOnlyTranslationTransforms()
+             : true;
+}
+
+bool AnimationHost::AnimationsPreserveAxisAlignment(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()
+                   ->AnimationsPreserveAxisAlignment()
+             : true;
+}
+
+bool AnimationHost::MaximumTargetScale(int layer_id, float* max_scale) const {
+  *max_scale = 0.f;
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player
+             ? player->layer_animation_controller()->MaximumTargetScale(
+                   max_scale)
+             : true;
+}
+
+bool AnimationHost::HasAnyAnimation(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player ? player->layer_animation_controller()->has_any_animation()
+                : false;
+}
+
+bool AnimationHost::HasActiveAnimation(int layer_id) const {
+  AnimationPlayer* player = GetPlayerForLayerId(layer_id);
+  return player ? player->layer_animation_controller()->HasActiveAnimation()
+                : false;
+}
+
 }  // namespace cc