NOT FOR REVIEW - convert to cc animation

cc/animation/animation_player.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_player.h"
 
 #include <algorithm>
 
 #include "base/stl_util.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
+#include "cc/animation/animation_observer.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
+#include "cc/animation/transform_operations.h"
 #include "cc/trees/property_animation_state.h"
 
 namespace cc {
 
 scoped_refptr<AnimationPlayer> AnimationPlayer::Create(int id) {
   return make_scoped_refptr(new AnimationPlayer(id));
 }
 
 AnimationPlayer::AnimationPlayer(int id)
     : animation_host_(),
@@ skipping 76 matching lines @@
 
   UnbindElementAnimations();
   // Destroy ElementAnimations or release it if it's still needed.
   animation_host_->UnregisterPlayerForElement(element_id_, this);
 }
 
 void AnimationPlayer::BindElementAnimations() {
   DCHECK(!element_animations_);
   element_animations_ =
       animation_host_->GetElementAnimationsForElementId(element_id_);
+  observers_.AddObserver(element_animations_.get());
   DCHECK(element_animations_);
 
   if (!animations_.empty())
     AnimationAdded();
 
   SetNeedsPushProperties();
 }
 
 void AnimationPlayer::UnbindElementAnimations() {
   SetNeedsPushProperties();
+  if (element_animations_) {
+    observers_.RemoveObserver(element_animations_.get());
+  }
   element_animations_ = nullptr;
 }
 
 void AnimationPlayer::AddAnimation(std::unique_ptr<Animation> animation) {
   DCHECK(animation->target_property() != TargetProperty::SCROLL_OFFSET ||
          (animation_host_ && animation_host_->SupportsScrollAnimations()));
   DCHECK(!animation->is_impl_only() ||
          animation->target_property() == TargetProperty::SCROLL_OFFSET);
 
   animations_.push_back(std::move(animation));
+  AnimationAdded();
   if (element_animations_) {
-    AnimationAdded();
     SetNeedsPushProperties();
   }
 }
 
 void AnimationPlayer::AnimationAdded() {
-  DCHECK(element_animations_);
-
-  SetNeedsCommit();
+  if (element_animations_)
+    SetNeedsCommit();
   needs_to_start_animations_ = true;
-
-  UpdateTickingState(UpdateTickingType::NORMAL);
-  element_animations_->UpdateClientAnimationState();
+  if (element_animations_) {
+    UpdateTickingState(UpdateTickingType::NORMAL);
+    element_animations_->UpdateClientAnimationState();
+  }
 }
 
 void AnimationPlayer::PauseAnimation(int animation_id, double time_offset) {
   const base::TimeDelta time_delta = base::TimeDelta::FromSecondsD(time_offset);
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->id() == animation_id) {
       animations_[i]->SetRunState(Animation::PAUSED,
                                   time_delta + animations_[i]->start_time() +
                                       animations_[i]->time_offset());
@@ skipping 106 matching lines @@
   // this insures we will never push an animation twice.
   RemoveAnimationsCompletedOnMainThread(player_impl);
 
   PushPropertiesToImplThread(player_impl);
 
   player_impl->UpdateTickingState(UpdateTickingType::NORMAL);
 }
 
 void AnimationPlayer::Tick(base::TimeTicks monotonic_time) {
   DCHECK(!monotonic_time.is_null());
-  DCHECK(element_animations_);
 
-  if (!element_animations_->has_element_in_any_list())
+  if (element_animations_ && !element_animations_->has_element_in_any_list())
     return;
 
   if (needs_to_start_animations())
     StartAnimations(monotonic_time);
 
   TickAnimations(monotonic_time);
 
   last_tick_time_ = monotonic_time;
-  element_animations_->UpdateClientAnimationState();
+  if (element_animations_)
+    element_animations_->UpdateClientAnimationState();
 }
 
 void AnimationPlayer::UpdateState(bool start_ready_animations,
                                   AnimationEvents* events) {
-  DCHECK(element_animations_);
-  if (!element_animations_->has_element_in_active_list())
+  if (element_animations_ && !element_animations_->has_element_in_active_list())
     return;
 
   // Animate hasn't been called, this happens if an element has been added
   // between the Commit and Draw phases.
   if (last_tick_time_ == base::TimeTicks())
     return;
 
   if (start_ready_animations)
     PromoteStartedAnimations(last_tick_time_, events);
 
@@ skipping 417 matching lines @@
   }
 
   // Notify about animations waiting for deletion.
   // We need to purge animations marked for deletion, which happens in
   // PushProperties().
   if (marked_animations_for_deletions)
     SetNeedsPushProperties();
 }
 
 void AnimationPlayer::TickAnimations(base::TimeTicks monotonic_time) {
-  DCHECK(element_animations_);
-
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::STARTING ||
         animations_[i]->run_state() == Animation::RUNNING ||
         animations_[i]->run_state() == Animation::PAUSED) {
       if (!animations_[i]->InEffect(monotonic_time))
         continue;
 
       base::TimeDelta trimmed =
           animations_[i]->TrimTimeToCurrentIteration(monotonic_time);
 
       switch (animations_[i]->target_property()) {
         case TargetProperty::TRANSFORM: {
           const TransformAnimationCurve* transform_animation_curve =
               animations_[i]->curve()->ToTransformAnimationCurve();
-          const gfx::Transform transform =
+          const TransformOperations operations =
               transform_animation_curve->GetValue(trimmed);
-          element_animations_->NotifyClientTransformAnimated(
-              transform, animations_[i]->affects_active_elements(),
-              animations_[i]->affects_pending_elements());
+          for (auto& observer : observers_) {
+            observer.NotifyClientTransformOperationsAnimated(
+                operations, animations_[i]->affects_active_elements(),
+                animations_[i]->affects_pending_elements());
+          }
           break;
         }
 
         case TargetProperty::OPACITY: {
           const FloatAnimationCurve* float_animation_curve =
               animations_[i]->curve()->ToFloatAnimationCurve();
           const float opacity = std::max(
               std::min(float_animation_curve->GetValue(trimmed), 1.0f), 0.f);
-          element_animations_->NotifyClientOpacityAnimated(
-              opacity, animations_[i]->affects_active_elements(),
-              animations_[i]->affects_pending_elements());
+          for (auto& observer : observers_) {
+            observer.NotifyClientOpacityAnimated(
+                opacity, animations_[i]->affects_active_elements(),
+                animations_[i]->affects_pending_elements());
+          }
           break;
         }
 
         case TargetProperty::FILTER: {
           const FilterAnimationCurve* filter_animation_curve =
               animations_[i]->curve()->ToFilterAnimationCurve();
           const FilterOperations filter =
               filter_animation_curve->GetValue(trimmed);
-          element_animations_->NotifyClientFilterAnimated(
-              filter, animations_[i]->affects_active_elements(),
-              animations_[i]->affects_pending_elements());
+          for (auto& observer : observers_) {
+            observer.NotifyClientFilterAnimated(
+                filter, animations_[i]->affects_active_elements(),
+                animations_[i]->affects_pending_elements());
+          }
           break;
         }
 
         case TargetProperty::BACKGROUND_COLOR: {
           // Not yet implemented.
           break;
         }
 
         case TargetProperty::SCROLL_OFFSET: {
           const ScrollOffsetAnimationCurve* scroll_offset_animation_curve =
               animations_[i]->curve()->ToScrollOffsetAnimationCurve();
           const gfx::ScrollOffset scroll_offset =
               scroll_offset_animation_curve->GetValue(trimmed);
-          element_animations_->NotifyClientScrollOffsetAnimated(
-              scroll_offset, animations_[i]->affects_active_elements(),
-              animations_[i]->affects_pending_elements());
+          for (auto& observer : observers_) {
+            observer.NotifyClientScrollOffsetAnimated(
+                scroll_offset, animations_[i]->affects_active_elements(),
+                animations_[i]->affects_pending_elements());
+          }
+          break;
+        }
+
+        case TargetProperty::BOUNDS: {
+          const SizeAnimationCurve* size_animation_curve =
+              animations_[i]->curve()->ToSizeAnimationCurve();
+          const gfx::SizeF size = size_animation_curve->GetValue(trimmed);
+          for (auto& observer : observers_) {
+            observer.NotifyClientBoundsAnimated(
+                size, animations_[i]->affects_active_elements(),
+                animations_[i]->affects_pending_elements());
+          }
           break;
         }
       }
     }
   }
 
   last_tick_time_ = monotonic_time;
 }
 
 void AnimationPlayer::MarkFinishedAnimations(base::TimeTicks monotonic_time) {
   bool animation_finished = false;
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->IsFinishedAt(monotonic_time)) {
       animations_[i]->SetRunState(Animation::FINISHED, monotonic_time);
       animation_finished = true;
-      SetNeedsPushProperties();
+      if (element_animations_) {
+        SetNeedsPushProperties();
+      }
     }
     if (!animations_[i]->affects_active_elements() &&
         !animations_[i]->affects_pending_elements()) {
       switch (animations_[i]->run_state()) {
         case Animation::WAITING_FOR_TARGET_AVAILABILITY:
         case Animation::STARTING:
         case Animation::RUNNING:
         case Animation::PAUSED:
           animations_[i]->SetRunState(Animation::FINISHED, monotonic_time);
           animation_finished = true;
           break;
         default:
           break;
       }
     }
   }
 
-  DCHECK(element_animations_);
-  if (animation_finished)
+  if (element_animations_ && animation_finished)
     element_animations_->UpdateClientAnimationState();
 }
 
 void AnimationPlayer::ActivateAnimations() {
   bool animation_activated = false;
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->affects_active_elements() !=
         animations_[i]->affects_pending_elements()) {
       animation_activated = true;
@@ skipping 372 matching lines @@
         animation_player_impl->GetAnimationById(animations_[i]->id());
     if (current_impl)
       animations_[i]->PushPropertiesTo(current_impl);
   }
 
   animation_player_impl->scroll_offset_animation_was_interrupted_ =
       scroll_offset_animation_was_interrupted_;
   scroll_offset_animation_was_interrupted_ = false;
 }
 
+void AnimationPlayer::AddObserver(AnimationObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void AnimationPlayer::RemoveObserver(AnimationObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 }  // namespace cc