cc/animation/element_animations.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/animation/element_animations.h"
   6
   7 #include "cc/animation/animation_host.h"
   8 #include "cc/animation/animation_player.h"
   9 #include "cc/animation/animation_registrar.h"
  10 #include "cc/animation/layer_animation_value_observer.h"
  11 #include "cc/trees/mutator_host_client.h"
  12
  13 namespace cc {
  14
  15 class ElementAnimations::ValueObserver : public LayerAnimationValueObserver {
  16  public:
  17   ValueObserver(ElementAnimations* element_animation, LayerTreeType tree_type)
  18       : element_animations_(element_animation), tree_type_(tree_type) {
  19     DCHECK(element_animations_);
  20   }
  21
  22   // LayerAnimationValueObserver implementation.
  23   void OnFilterAnimated(const FilterOperations& filters) override {
  24     element_animations_->SetFilterMutated(tree_type_, filters);
  25   }
  26
  27   void OnOpacityAnimated(float opacity) override {
  28     element_animations_->SetOpacityMutated(tree_type_, opacity);
  29   }
  30
  31   void OnTransformAnimated(const gfx::Transform& transform) override {
  32     element_animations_->SetTransformMutated(tree_type_, transform);
  33   }
  34
  35   void OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) override {
  36     element_animations_->SetScrollOffsetMutated(tree_type_, scroll_offset);
  37   }
  38
  39   void OnAnimationWaitingForDeletion() override {
  40     // TODO(loyso): See Layer::OnAnimationWaitingForDeletion. But we always do
  41     // PushProperties for AnimationTimelines for now.
  42   }
  43
  44   bool IsActive() const override { return tree_type_ == LayerTreeType::ACTIVE; }
  45
  46  private:
  47   ElementAnimations* element_animations_;
  48   const LayerTreeType tree_type_;
  49
  50   DISALLOW_COPY_AND_ASSIGN(ValueObserver);
  51 };
  52
  53 scoped_ptr<ElementAnimations> ElementAnimations::Create(AnimationHost* host) {
  54   return make_scoped_ptr(new ElementAnimations(host));
  55 }
  56
  57 ElementAnimations::ElementAnimations(AnimationHost* host)
  58     : players_list_(make_scoped_ptr(new PlayersList())), animation_host_(host) {
  59   DCHECK(animation_host_);
  60 }
  61
  62 ElementAnimations::~ElementAnimations() {
  63   DCHECK(!layer_animation_controller_);
  64 }
  65
  66 void ElementAnimations::CreateLayerAnimationController(int layer_id) {
  67   DCHECK(layer_id);
  68   DCHECK(!layer_animation_controller_);
  69   DCHECK(animation_host_);
  70
  71   AnimationRegistrar* registrar = animation_host_->animation_registrar();
  72   DCHECK(registrar);
  73
  74   layer_animation_controller_ =
  75       registrar->GetAnimationControllerForId(layer_id);
  76   layer_animation_controller_->SetAnimationRegistrar(registrar);
  77   layer_animation_controller_->set_layer_animation_delegate(this);
  78   layer_animation_controller_->set_value_provider(this);
  79
  80   DCHECK(animation_host_->mutator_host_client());
  81   if (animation_host_->mutator_host_client()->IsLayerInTree(
  82           layer_id, LayerTreeType::ACTIVE))
  83     CreateActiveValueObserver();
  84   if (animation_host_->mutator_host_client()->IsLayerInTree(
  85           layer_id, LayerTreeType::PENDING))
  86     CreatePendingValueObserver();
  87 }
  88
  89 void ElementAnimations::DestroyLayerAnimationController() {
  90   DCHECK(animation_host_);
  91
  92   DestroyPendingValueObserver();
  93   DestroyActiveValueObserver();
  94
  95   if (layer_animation_controller_) {
  96     layer_animation_controller_->remove_value_provider(this);
  97     layer_animation_controller_->remove_layer_animation_delegate(this);
  98     layer_animation_controller_->SetAnimationRegistrar(nullptr);
  99     layer_animation_controller_ = nullptr;
 100   }
 101 }
 102
 103 void ElementAnimations::LayerRegistered(int layer_id, LayerTreeType tree_type) {
 104   DCHECK(layer_animation_controller_);
 105   DCHECK_EQ(layer_animation_controller_->id(), layer_id);
 106
 107   if (tree_type == LayerTreeType::ACTIVE) {
 108     if (!active_value_observer_)
 109       CreateActiveValueObserver();
 110   } else {
 111     if (!pending_value_observer_)
 112       CreatePendingValueObserver();
 113   }
 114 }
 115
 116 void ElementAnimations::LayerUnregistered(int layer_id,
 117                                           LayerTreeType tree_type) {
 118   DCHECK_EQ(this->layer_id(), layer_id);
 119   tree_type == LayerTreeType::ACTIVE ? DestroyActiveValueObserver()
 120                                      : DestroyPendingValueObserver();
 121 }
 122
 123 void ElementAnimations::AddPlayer(AnimationPlayer* player) {
 124   players_list_->Append(player);
 125 }
 126
 127 void ElementAnimations::RemovePlayer(AnimationPlayer* player) {
 128   for (PlayersListNode* node = players_list_->head();
 129        node != players_list_->end(); node = node->next()) {
 130     if (node->value() == player) {
 131       node->RemoveFromList();
 132       return;
 133     }
 134   }
 135 }
 136
 137 bool ElementAnimations::IsEmpty() const {
 138   return players_list_->empty();
 139 }
 140
 141 void ElementAnimations::PushPropertiesTo(
 142     ElementAnimations* element_animations_impl) {
 143   DCHECK(layer_animation_controller_);
 144   DCHECK(element_animations_impl->layer_animation_controller());
 145
 146   layer_animation_controller_->PushAnimationUpdatesTo(
 147       element_animations_impl->layer_animation_controller());
 148 }
 149
 150 void ElementAnimations::SetFilterMutated(LayerTreeType tree_type,
 151                                          const FilterOperations& filters) {
 152   DCHECK(layer_id());
 153   DCHECK(animation_host());
 154   DCHECK(animation_host()->mutator_host_client());
 155   animation_host()->mutator_host_client()->SetLayerFilterMutated(
 156       layer_id(), tree_type, filters);
 157 }
 158
 159 void ElementAnimations::SetOpacityMutated(LayerTreeType tree_type,
 160                                           float opacity) {
 161   DCHECK(layer_id());
 162   DCHECK(animation_host());
 163   DCHECK(animation_host()->mutator_host_client());
 164   animation_host()->mutator_host_client()->SetLayerOpacityMutated(
 165       layer_id(), tree_type, opacity);
 166 }
 167
 168 void ElementAnimations::SetTransformMutated(LayerTreeType tree_type,
 169                                             const gfx::Transform& transform) {
 170   DCHECK(layer_id());
 171   DCHECK(animation_host());
 172   DCHECK(animation_host()->mutator_host_client());
 173   animation_host()->mutator_host_client()->SetLayerTransformMutated(
 174       layer_id(), tree_type, transform);
 175 }
 176
 177 void ElementAnimations::SetScrollOffsetMutated(
 178     LayerTreeType tree_type,
 179     const gfx::ScrollOffset& scroll_offset) {
 180   DCHECK(layer_id());
 181   DCHECK(animation_host());
 182   DCHECK(animation_host()->mutator_host_client());
 183   animation_host()->mutator_host_client()->SetLayerScrollOffsetMutated(
 184       layer_id(), tree_type, scroll_offset);
 185 }
 186
 187 void ElementAnimations::CreateActiveValueObserver() {
 188   DCHECK(layer_animation_controller_);
 189   DCHECK(!active_value_observer_);
 190   active_value_observer_ =
 191       make_scoped_ptr(new ValueObserver(this, LayerTreeType::ACTIVE));
 192   layer_animation_controller_->AddValueObserver(active_value_observer_.get());
 193 }
 194
 195 void ElementAnimations::DestroyActiveValueObserver() {
 196   if (layer_animation_controller_ && active_value_observer_)
 197     layer_animation_controller_->RemoveValueObserver(
 198         active_value_observer_.get());
 199   active_value_observer_ = nullptr;
 200 }
 201
 202 void ElementAnimations::CreatePendingValueObserver() {
 203   DCHECK(layer_animation_controller_);
 204   DCHECK(!pending_value_observer_);
 205   pending_value_observer_ =
 206       make_scoped_ptr(new ValueObserver(this, LayerTreeType::PENDING));
 207   layer_animation_controller_->AddValueObserver(pending_value_observer_.get());
 208 }
 209
 210 void ElementAnimations::DestroyPendingValueObserver() {
 211   if (layer_animation_controller_ && pending_value_observer_)
 212     layer_animation_controller_->RemoveValueObserver(
 213         pending_value_observer_.get());
 214   pending_value_observer_ = nullptr;
 215 }
 216
 217 void ElementAnimations::NotifyAnimationStarted(
 218     base::TimeTicks monotonic_time,
 219     Animation::TargetProperty target_property,
 220     int group) {
 221   for (PlayersListNode* node = players_list_->head();
 222        node != players_list_->end(); node = node->next()) {
 223     AnimationPlayer* player = node->value();
 224     player->NotifyAnimationStarted(monotonic_time, target_property, group);
 225   }
 226 }
 227
 228 void ElementAnimations::NotifyAnimationFinished(
 229     base::TimeTicks monotonic_time,
 230     Animation::TargetProperty target_property,
 231     int group) {
 232   for (PlayersListNode* node = players_list_->head();
 233        node != players_list_->end(); node = node->next()) {
 234     AnimationPlayer* player = node->value();
 235     player->NotifyAnimationFinished(monotonic_time, target_property, group);
 236   }
 237 }
 238
 239 gfx::ScrollOffset ElementAnimations::ScrollOffsetForAnimation() const {
 240   DCHECK(layer_animation_controller_);
 241   if (animation_host()) {
 242     DCHECK(animation_host()->mutator_host_client());
 243     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
 244         layer_id());
 245   }
 246
 247   return gfx::ScrollOffset();
 248 }
 249
 250 }  // namespace cc