CC Animation: Expose TargetProperty enum to be aliased in Blink Platform.

cc/animation/layer_animation_controller.cc

 // Copyright 2012 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/layer_animation_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 48 matching lines @@
   bool was_potentially_animating_transform_for_active_observers =
       potentially_animating_transform_for_active_observers_;
   bool was_potentially_animating_transform_for_pending_observers =
       potentially_animating_transform_for_pending_observers_;
 
   potentially_animating_transform_for_active_observers_ = false;
   potentially_animating_transform_for_pending_observers_ = false;
 
   for (const auto& animation : animations_) {
     if (!animation->is_finished() &&
-        animation->target_property() == Animation::TRANSFORM) {
+        animation->target_property() == AnimationTargetProperty::TRANSFORM) {
       potentially_animating_transform_for_active_observers_ |=
           animation->affects_active_observers();
       potentially_animating_transform_for_pending_observers_ |=
           animation->affects_pending_observers();
     }
   }
 
   bool changed_for_active_observers =
       was_potentially_animating_transform_for_active_observers !=
       potentially_animating_transform_for_active_observers_;
@@ skipping 12 matching lines @@
   bool removed_transform_animation = false;
   // Since we want to use the animations that we're going to remove, we need to
   // use a stable_parition here instead of remove_if. Remove_if leaves the
   // removed items in an unspecified state.
   auto animations_to_remove = std::stable_partition(
       animations_.begin(), animations_.end(),
       [animation_id](const scoped_ptr<Animation>& animation) {
         return animation->id() != animation_id;
       });
   for (auto it = animations_to_remove; it != animations_.end(); ++it) {
-    if ((*it)->target_property() == Animation::SCROLL_OFFSET) {
+    if ((*it)->target_property() == AnimationTargetProperty::SCROLL_OFFSET) {
       scroll_offset_animation_was_interrupted_ = true;
-    } else if ((*it)->target_property() == Animation::TRANSFORM &&
+    } else if ((*it)->target_property() == AnimationTargetProperty::TRANSFORM &&
                !(*it)->is_finished()) {
       removed_transform_animation = true;
     }
   }
 
   animations_.erase(animations_to_remove, animations_.end());
   UpdateActivation(NORMAL_ACTIVATION);
   if (removed_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 void LayerAnimationController::AbortAnimation(int animation_id) {
   bool aborted_transform_animation = false;
   if (Animation* animation = GetAnimationById(animation_id)) {
     if (!animation->is_finished()) {
       animation->SetRunState(Animation::ABORTED, last_tick_time_);
-      if (animation->target_property() == Animation::TRANSFORM)
+      if (animation->target_property() == AnimationTargetProperty::TRANSFORM)
         aborted_transform_animation = true;
     }
   }
   if (aborted_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 void LayerAnimationController::AbortAnimations(
-    Animation::TargetProperty target_property) {
+    AnimationTargetProperty::Enum target_property) {
   bool aborted_transform_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->target_property() == target_property &&
         !animations_[i]->is_finished()) {
       animations_[i]->SetRunState(Animation::ABORTED, last_tick_time_);
-      if (target_property == Animation::TRANSFORM)
+      if (target_property == AnimationTargetProperty::TRANSFORM)
         aborted_transform_animation = true;
     }
   }
   if (aborted_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 // Ensures that the list of active animations on the main thread and the impl
 // thread are kept in sync.
 void LayerAnimationController::PushAnimationUpdatesTo(
@@ skipping 36 matching lines @@
     Animation* animation = animations_[i].get();
     if (!animation->is_impl_only())
       continue;
 
     if (!animation->InEffect(monotonic_time))
       continue;
 
     base::TimeDelta trimmed =
         animation->TrimTimeToCurrentIteration(monotonic_time);
     switch (animation->target_property()) {
-      case Animation::OPACITY: {
+      case AnimationTargetProperty::OPACITY: {
         AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, id_,
-                             animation->group(), Animation::OPACITY,
-                             monotonic_time);
+                             animation->group(),
+                             AnimationTargetProperty::OPACITY, monotonic_time);
         const FloatAnimationCurve* float_animation_curve =
             animation->curve()->ToFloatAnimationCurve();
         event.opacity = float_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
         events->events_.push_back(event);
         break;
       }
 
-      case Animation::TRANSFORM: {
-        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, id_,
-                             animation->group(), Animation::TRANSFORM,
-                             monotonic_time);
+      case AnimationTargetProperty::TRANSFORM: {
+        AnimationEvent event(
+            AnimationEvent::PROPERTY_UPDATE, id_, animation->group(),
+            AnimationTargetProperty::TRANSFORM, monotonic_time);
         const TransformAnimationCurve* transform_animation_curve =
             animation->curve()->ToTransformAnimationCurve();
         event.transform = transform_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
         events->events_.push_back(event);
         break;
       }
 
-      case Animation::FILTER: {
+      case AnimationTargetProperty::FILTER: {
         AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, id_,
-                             animation->group(), Animation::FILTER,
-                             monotonic_time);
+                             animation->group(),
+                             AnimationTargetProperty::FILTER, monotonic_time);
         const FilterAnimationCurve* filter_animation_curve =
             animation->curve()->ToFilterAnimationCurve();
         event.filters = filter_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
         events->events_.push_back(event);
         break;
       }
 
-      case Animation::BACKGROUND_COLOR: {
+      case AnimationTargetProperty::BACKGROUND_COLOR: {
         break;
       }
 
-      case Animation::SCROLL_OFFSET: {
+      case AnimationTargetProperty::SCROLL_OFFSET: {
         // Impl-side changes to scroll offset are already sent back to the
         // main thread (e.g. for user-driven scrolling), so a PROPERTY_UPDATE
         // isn't needed.
         break;
       }
     }
   }
 }
 
 void LayerAnimationController::UpdateState(bool start_ready_animations,
@@ skipping 20 matching lines @@
   AccumulatePropertyUpdates(last_tick_time_, events);
 
   UpdateActivation(NORMAL_ACTIVATION);
 }
 
 void LayerAnimationController::ActivateAnimations() {
   bool changed_transform_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->affects_active_observers() !=
             animations_[i]->affects_pending_observers() &&
-        animations_[i]->target_property() == Animation::TRANSFORM)
+        animations_[i]->target_property() == AnimationTargetProperty::TRANSFORM)
       changed_transform_animation = true;
     animations_[i]->set_affects_active_observers(
         animations_[i]->affects_pending_observers());
   }
   auto affects_no_observers = [](const scoped_ptr<Animation>& animation) {
     return !animation->affects_active_observers() &&
            !animation->affects_pending_observers();
   };
   animations_.erase(std::remove_if(animations_.begin(), animations_.end(),
                                    affects_no_observers),
                     animations_.end());
   scroll_offset_animation_was_interrupted_ = false;
   UpdateActivation(NORMAL_ACTIVATION);
   if (changed_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 void LayerAnimationController::AddAnimation(scoped_ptr<Animation> animation) {
   bool added_transform_animation =
-      animation->target_property() == Animation::TRANSFORM;
+      animation->target_property() == AnimationTargetProperty::TRANSFORM;
   animations_.push_back(std::move(animation));
   needs_to_start_animations_ = true;
   UpdateActivation(NORMAL_ACTIVATION);
   if (added_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 Animation* LayerAnimationController::GetAnimation(
-    Animation::TargetProperty target_property) const {
+    AnimationTargetProperty::Enum target_property) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     size_t index = animations_.size() - i - 1;
     if (animations_[index]->target_property() == target_property)
       return animations_[index].get();
   }
   return nullptr;
 }
 
 Animation* LayerAnimationController::GetAnimationById(int animation_id) const {
   for (size_t i = 0; i < animations_.size(); ++i)
     if (animations_[i]->id() == animation_id)
       return animations_[i].get();
   return nullptr;
 }
 
 bool LayerAnimationController::HasActiveAnimation() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished())
       return true;
   }
   return false;
 }
 
 bool LayerAnimationController::IsPotentiallyAnimatingProperty(
-    Animation::TargetProperty target_property,
+    AnimationTargetProperty::Enum target_property,
     ObserverType observer_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->target_property() == target_property) {
       if ((observer_type == ObserverType::ACTIVE &&
            animations_[i]->affects_active_observers()) ||
           (observer_type == ObserverType::PENDING &&
            animations_[i]->affects_pending_observers()))
         return true;
     }
   }
   return false;
 }
 
 bool LayerAnimationController::IsCurrentlyAnimatingProperty(
-    Animation::TargetProperty target_property,
+    AnimationTargetProperty::Enum target_property,
     ObserverType observer_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->InEffect(last_tick_time_) &&
         animations_[i]->target_property() == target_property) {
       if ((observer_type == ObserverType::ACTIVE &&
            animations_[i]->affects_active_observers()) ||
           (observer_type == ObserverType::PENDING &&
            animations_[i]->affects_pending_observers()))
         return true;
@@ skipping 73 matching lines @@
     const AnimationEvent& event) {
   bool aborted_transform_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
         animations_[i]->target_property() == event.target_property) {
       animations_[i]->SetRunState(Animation::ABORTED, event.monotonic_time);
       animations_[i]->set_received_finished_event(true);
       if (layer_animation_delegate_)
         layer_animation_delegate_->NotifyAnimationAborted(
             event.monotonic_time, event.target_property, event.group_id);
-      if (event.target_property == Animation::TRANSFORM)
+      if (event.target_property == AnimationTargetProperty::TRANSFORM)
         aborted_transform_animation = true;
     }
   }
   if (aborted_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 void LayerAnimationController::NotifyAnimationPropertyUpdate(
     const AnimationEvent& event) {
   bool notify_active_observers = true;
   bool notify_pending_observers = true;
   switch (event.target_property) {
-    case Animation::OPACITY:
+    case AnimationTargetProperty::OPACITY:
       NotifyObserversOpacityAnimated(
           event.opacity, notify_active_observers, notify_pending_observers);
       break;
-    case Animation::TRANSFORM:
+    case AnimationTargetProperty::TRANSFORM:
       NotifyObserversTransformAnimated(
           event.transform, notify_active_observers, notify_pending_observers);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void LayerAnimationController::AddValueObserver(
     LayerAnimationValueObserver* observer) {
@@ skipping 13 matching lines @@
 }
 
 void LayerAnimationController::RemoveEventObserver(
     LayerAnimationEventObserver* observer) {
   event_observers_.RemoveObserver(observer);
 }
 
 bool LayerAnimationController::HasFilterAnimationThatInflatesBounds() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
-        animations_[i]->target_property() == Animation::FILTER &&
+        animations_[i]->target_property() == AnimationTargetProperty::FILTER &&
         animations_[i]
             ->curve()
             ->ToFilterAnimationCurve()
             ->HasFilterThatMovesPixels())
       return true;
   }
 
   return false;
 }
 
 bool LayerAnimationController::HasTransformAnimationThatInflatesBounds() const {
-  return IsCurrentlyAnimatingProperty(Animation::TRANSFORM,
+  return IsCurrentlyAnimatingProperty(AnimationTargetProperty::TRANSFORM,
                                       ObserverType::ACTIVE) ||
-         IsCurrentlyAnimatingProperty(Animation::TRANSFORM,
+         IsCurrentlyAnimatingProperty(AnimationTargetProperty::TRANSFORM,
                                       ObserverType::PENDING);
 }
 
 bool LayerAnimationController::FilterAnimationBoundsForBox(
     const gfx::BoxF& box, gfx::BoxF* bounds) const {
   // TODO(avallee): Implement.
   return false;
 }
 
 bool LayerAnimationController::TransformAnimationBoundsForBox(
     const gfx::BoxF& box,
     gfx::BoxF* bounds) const {
   DCHECK(HasTransformAnimationThatInflatesBounds())
       << "TransformAnimationBoundsForBox will give incorrect results if there "
       << "are no transform animations affecting bounds, non-animated transform "
       << "is not known";
 
   // Compute bounds based on animations for which is_finished() is false.
   // Do nothing if there are no such animations; in this case, it is assumed
   // that callers will take care of computing bounds based on the owning layer's
   // actual transform.
   *bounds = gfx::BoxF();
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
-        animations_[i]->target_property() != Animation::TRANSFORM)
+        animations_[i]->target_property() != AnimationTargetProperty::TRANSFORM)
       continue;
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     gfx::BoxF animation_bounds;
     bool success =
         transform_animation_curve->AnimatedBoundsForBox(box, &animation_bounds);
     if (!success)
       return false;
     bounds->Union(animation_bounds);
   }
 
   return true;
 }
 
 bool LayerAnimationController::HasAnimationThatAffectsScale() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
-        animations_[i]->target_property() != Animation::TRANSFORM)
+        animations_[i]->target_property() != AnimationTargetProperty::TRANSFORM)
       continue;
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     if (transform_animation_curve->AffectsScale())
       return true;
   }
 
   return false;
 }
 
 bool LayerAnimationController::HasOnlyTranslationTransforms(
     ObserverType observer_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
-        animations_[i]->target_property() != Animation::TRANSFORM)
+        animations_[i]->target_property() != AnimationTargetProperty::TRANSFORM)
       continue;
 
     if ((observer_type == ObserverType::ACTIVE &&
          !animations_[i]->affects_active_observers()) ||
         (observer_type == ObserverType::PENDING &&
          !animations_[i]->affects_pending_observers()))
       continue;
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     if (!transform_animation_curve->IsTranslation())
       return false;
   }
 
   return true;
 }
 
 bool LayerAnimationController::AnimationsPreserveAxisAlignment() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
-        animations_[i]->target_property() != Animation::TRANSFORM)
+        animations_[i]->target_property() != AnimationTargetProperty::TRANSFORM)
       continue;
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     if (!transform_animation_curve->PreservesAxisAlignment())
       return false;
   }
 
   return true;
 }
 
 bool LayerAnimationController::AnimationStartScale(ObserverType observer_type,
                                                    float* start_scale) const {
   *start_scale = 0.f;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
-        animations_[i]->target_property() != Animation::TRANSFORM)
+        animations_[i]->target_property() != AnimationTargetProperty::TRANSFORM)
       continue;
 
     if ((observer_type == ObserverType::ACTIVE &&
          !animations_[i]->affects_active_observers()) ||
         (observer_type == ObserverType::PENDING &&
          !animations_[i]->affects_pending_observers()))
       continue;
 
     bool forward_direction = true;
     switch (animations_[i]->direction()) {
@@ skipping 16 matching lines @@
     *start_scale = std::max(*start_scale, animation_start_scale);
   }
   return true;
 }
 
 bool LayerAnimationController::MaximumTargetScale(ObserverType observer_type,
                                                   float* max_scale) const {
   *max_scale = 0.f;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
-        animations_[i]->target_property() != Animation::TRANSFORM)
+        animations_[i]->target_property() != AnimationTargetProperty::TRANSFORM)
       continue;
 
     if ((observer_type == ObserverType::ACTIVE &&
          !animations_[i]->affects_active_observers()) ||
         (observer_type == ObserverType::PENDING &&
          !animations_[i]->affects_pending_observers()))
       continue;
 
     bool forward_direction = true;
     switch (animations_[i]->direction()) {
@@ skipping 22 matching lines @@
 void LayerAnimationController::PushNewAnimationsToImplThread(
     LayerAnimationController* controller_impl) const {
   // Any new animations owned by the main thread's controller are cloned and
   // add to the impl thread's controller.
   for (size_t i = 0; i < animations_.size(); ++i) {
     // If the animation is already running on the impl thread, there is no
     // need to copy it over.
     if (controller_impl->GetAnimationById(animations_[i]->id()))
       continue;
 
-    if (animations_[i]->target_property() == Animation::SCROLL_OFFSET &&
+    if (animations_[i]->target_property() ==
+            AnimationTargetProperty::SCROLL_OFFSET &&
         !animations_[i]
              ->curve()
              ->ToScrollOffsetAnimationCurve()
              ->HasSetInitialValue()) {
       gfx::ScrollOffset current_scroll_offset;
       if (controller_impl->value_provider_) {
         current_scroll_offset =
             controller_impl->value_provider_->ScrollOffsetForAnimation();
       } else {
         // The owning layer isn't yet in the active tree, so the main thread
@@ skipping 29 matching lines @@
     LayerAnimationController* controller_impl) const {
   bool removed_transform_animation = false;
   // Animations removed on the main thread should no longer affect pending
   // observers, and should stop affecting active observers after the next call
   // to ActivateAnimations. If already WAITING_FOR_DELETION, they can be removed
   // immediately.
   auto& animations = controller_impl->animations_;
   for (const auto& animation : animations) {
     if (IsCompleted(animation.get(), this)) {
       animation->set_affects_pending_observers(false);
-      if (animation->target_property() == Animation::TRANSFORM)
+      if (animation->target_property() == AnimationTargetProperty::TRANSFORM)
         removed_transform_animation = true;
     }
   }
   auto affects_active_only_and_is_waiting_for_deletion = [](
       const scoped_ptr<Animation>& animation) {
     return animation->run_state() == Animation::WAITING_FOR_DELETION &&
            !animation->affects_pending_observers();
   };
   animations.erase(
       std::remove_if(animations.begin(), animations.end(),
@@ skipping 135 matching lines @@
   }
 }
 
 void LayerAnimationController::MarkFinishedAnimations(
     base::TimeTicks monotonic_time) {
   bool finished_transform_animation = 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);
-      if (animations_[i]->target_property() == Animation::TRANSFORM) {
+      if (animations_[i]->target_property() ==
+          AnimationTargetProperty::TRANSFORM) {
         finished_transform_animation = true;
       }
     }
   }
   if (finished_transform_animation)
     UpdatePotentiallyAnimatingTransform();
 }
 
 void LayerAnimationController::MarkAnimationsForDeletion(
     base::TimeTicks monotonic_time,
@@ skipping 101 matching lines @@
   auto& animations_impl = controller_impl->animations_;
   for (const auto& animation_impl : animations_impl) {
     // If the animation has been aborted on the main thread, mark it for
     // deletion.
     if (Animation* animation = GetAnimationById(animation_impl->id())) {
       if (animation->run_state() == Animation::ABORTED) {
         animation_impl->SetRunState(Animation::WAITING_FOR_DELETION,
                                     controller_impl->last_tick_time_);
         animation->SetRunState(Animation::WAITING_FOR_DELETION,
                                last_tick_time_);
-        if (animation_impl->target_property() == Animation::TRANSFORM) {
+        if (animation_impl->target_property() ==
+            AnimationTargetProperty::TRANSFORM) {
           aborted_transform_animation = true;
         }
       }
     }
   }
 
   if (aborted_transform_animation)
     controller_impl->UpdatePotentiallyAnimatingTransform();
 }
 
@@ skipping 11 matching lines @@
     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 Animation::TRANSFORM: {
+        case AnimationTargetProperty::TRANSFORM: {
           const TransformAnimationCurve* transform_animation_curve =
               animations_[i]->curve()->ToTransformAnimationCurve();
           const gfx::Transform transform =
               transform_animation_curve->GetValue(trimmed);
           NotifyObserversTransformAnimated(
               transform,
               animations_[i]->affects_active_observers(),
               animations_[i]->affects_pending_observers());
           break;
         }
 
-        case Animation::OPACITY: {
+        case AnimationTargetProperty::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);
           NotifyObserversOpacityAnimated(
               opacity,
               animations_[i]->affects_active_observers(),
               animations_[i]->affects_pending_observers());
           break;
         }
 
-        case Animation::FILTER: {
+        case AnimationTargetProperty::FILTER: {
           const FilterAnimationCurve* filter_animation_curve =
               animations_[i]->curve()->ToFilterAnimationCurve();
           const FilterOperations filter =
               filter_animation_curve->GetValue(trimmed);
           NotifyObserversFilterAnimated(
               filter,
               animations_[i]->affects_active_observers(),
               animations_[i]->affects_pending_observers());
           break;
         }
 
-        case Animation::BACKGROUND_COLOR: {
+        case AnimationTargetProperty::BACKGROUND_COLOR: {
           // Not yet implemented.
           break;
         }
 
-        case Animation::SCROLL_OFFSET: {
+        case AnimationTargetProperty::SCROLL_OFFSET: {
           const ScrollOffsetAnimationCurve* scroll_offset_animation_curve =
               animations_[i]->curve()->ToScrollOffsetAnimationCurve();
           const gfx::ScrollOffset scroll_offset =
               scroll_offset_animation_curve->GetValue(trimmed);
           NotifyObserversScrollOffsetAnimated(
               scroll_offset,
               animations_[i]->affects_active_observers(),
               animations_[i]->affects_pending_observers());
           break;
         }
@@ skipping 129 matching lines @@
         &value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != nullptr)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc