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

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 "base/macros.h"
 #include "cc/animation/animation_delegate.h"
@@ skipping 36 matching lines @@
                              const gfx::ScrollOffset& target_offset,
                              const gfx::ScrollOffset& current_offset) {
     scoped_ptr<ScrollOffsetAnimationCurve> curve =
         ScrollOffsetAnimationCurve::Create(
             target_offset, EaseInOutTimingFunction::Create(),
             ScrollOffsetAnimationCurve::DurationBehavior::INVERSE_DELTA);
     curve->SetInitialValue(current_offset);
 
     scoped_ptr<Animation> animation = Animation::Create(
         std::move(curve), AnimationIdProvider::NextAnimationId(),
-        AnimationIdProvider::NextGroupId(), Animation::SCROLL_OFFSET);
+        AnimationIdProvider::NextGroupId(), TargetProperty::SCROLL_OFFSET);
     animation->set_is_impl_only(true);
 
     DCHECK(scroll_offset_animation_player_);
     DCHECK(scroll_offset_animation_player_->animation_timeline());
 
     ReattachScrollOffsetPlayerIfNeeded(layer_id);
 
     scroll_offset_animation_player_->AddAnimation(std::move(animation));
   }
 
   bool ScrollAnimationUpdateTarget(int layer_id,
                                    const gfx::Vector2dF& scroll_delta,
                                    const gfx::ScrollOffset& max_scroll_offset,
                                    base::TimeTicks frame_monotonic_time) {
     DCHECK(scroll_offset_animation_player_);
     if (!scroll_offset_animation_player_->element_animations())
       return false;
 
     DCHECK_EQ(layer_id, scroll_offset_animation_player_->layer_id());
 
     Animation* animation = scroll_offset_animation_player_->element_animations()
                                ->layer_animation_controller()
-                               ->GetAnimation(Animation::SCROLL_OFFSET);
+                               ->GetAnimation(TargetProperty::SCROLL_OFFSET);
     if (!animation) {
       scroll_offset_animation_player_->DetachLayer();
       return false;
     }
 
     ScrollOffsetAnimationCurve* curve =
         animation->curve()->ToScrollOffsetAnimationCurve();
 
     gfx::ScrollOffset new_target =
         gfx::ScrollOffsetWithDelta(curve->target_value(), scroll_delta);
     new_target.SetToMax(gfx::ScrollOffset());
     new_target.SetToMin(max_scroll_offset);
 
     curve->UpdateTarget(animation->TrimTimeToCurrentIteration(
                                        frame_monotonic_time).InSecondsF(),
                         new_target);
 
     return true;
   }
 
   void ScrollAnimationAbort() {
     DCHECK(scroll_offset_animation_player_);
-    scroll_offset_animation_player_->AbortAnimations(Animation::SCROLL_OFFSET);
+    scroll_offset_animation_player_->AbortAnimations(
+        TargetProperty::SCROLL_OFFSET);
   }
 
   // AnimationDelegate implementation.
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
-                              Animation::TargetProperty target_property,
+                              TargetProperty::Type target_property,
                               int group) override {}
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
-                               Animation::TargetProperty target_property,
+                               TargetProperty::Type target_property,
                                int group) override {
-    DCHECK_EQ(target_property, Animation::SCROLL_OFFSET);
+    DCHECK_EQ(target_property, TargetProperty::SCROLL_OFFSET);
     DCHECK(animation_host_->mutator_host_client());
     animation_host_->mutator_host_client()->ScrollOffsetAnimationFinished();
   }
   void NotifyAnimationAborted(base::TimeTicks monotonic_time,
-                              Animation::TargetProperty target_property,
+                              TargetProperty::Type target_property,
                               int group) override {}
 
  private:
   void ReattachScrollOffsetPlayerIfNeeded(int layer_id) {
     if (scroll_offset_animation_player_->layer_id() != layer_id) {
       if (scroll_offset_animation_player_->layer_id())
         scroll_offset_animation_player_->DetachLayer();
       if (layer_id)
         scroll_offset_animation_player_->AttachLayer(layer_id);
     }
@@ skipping 256 matching lines @@
   return tree_type == LayerTreeType::ACTIVE
              ? LayerAnimationController::ObserverType::ACTIVE
              : LayerAnimationController::ObserverType::PENDING;
 }
 
 bool AnimationHost::IsAnimatingFilterProperty(int layer_id,
                                               LayerTreeType tree_type) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   return controller
              ? controller->IsCurrentlyAnimatingProperty(
-                   Animation::FILTER, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::FILTER, ObserverTypeFromTreeType(tree_type))
              : false;
 }
 
 bool AnimationHost::IsAnimatingOpacityProperty(int layer_id,
                                                LayerTreeType tree_type) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   return controller
              ? controller->IsCurrentlyAnimatingProperty(
-                   Animation::OPACITY, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::OPACITY, ObserverTypeFromTreeType(tree_type))
              : false;
 }
 
 bool AnimationHost::IsAnimatingTransformProperty(
     int layer_id,
     LayerTreeType tree_type) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   return controller
              ? controller->IsCurrentlyAnimatingProperty(
-                   Animation::TRANSFORM, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::TRANSFORM,
+                   ObserverTypeFromTreeType(tree_type))
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningFilterAnimation(
     int layer_id,
     LayerTreeType tree_type) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   return controller
              ? controller->IsPotentiallyAnimatingProperty(
-                   Animation::FILTER, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::FILTER, ObserverTypeFromTreeType(tree_type))
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningOpacityAnimation(
     int layer_id,
     LayerTreeType tree_type) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   return controller
              ? controller->IsPotentiallyAnimatingProperty(
-                   Animation::OPACITY, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::OPACITY, ObserverTypeFromTreeType(tree_type))
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningTransformAnimation(
     int layer_id,
     LayerTreeType tree_type) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   return controller
              ? controller->IsPotentiallyAnimatingProperty(
-                   Animation::TRANSFORM, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::TRANSFORM,
+                   ObserverTypeFromTreeType(tree_type))
              : false;
 }
 
 bool AnimationHost::HasAnyAnimationTargetingProperty(
     int layer_id,
-    Animation::TargetProperty property) const {
+    TargetProperty::Type property) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   if (!controller)
     return false;
 
   return !!controller->GetAnimation(property);
 }
 
 bool AnimationHost::FilterIsAnimatingOnImplOnly(int layer_id) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   if (!controller)
     return false;
 
-  Animation* animation = controller->GetAnimation(Animation::FILTER);
+  Animation* animation = controller->GetAnimation(TargetProperty::FILTER);
   return animation && animation->is_impl_only();
 }
 
 bool AnimationHost::OpacityIsAnimatingOnImplOnly(int layer_id) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   if (!controller)
     return false;
 
-  Animation* animation = controller->GetAnimation(Animation::OPACITY);
+  Animation* animation = controller->GetAnimation(TargetProperty::OPACITY);
   return animation && animation->is_impl_only();
 }
 
 bool AnimationHost::TransformIsAnimatingOnImplOnly(int layer_id) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   if (!controller)
     return false;
 
-  Animation* animation = controller->GetAnimation(Animation::TRANSFORM);
+  Animation* animation = controller->GetAnimation(TargetProperty::TRANSFORM);
   return animation && animation->is_impl_only();
 }
 
 bool AnimationHost::HasFilterAnimationThatInflatesBounds(int layer_id) const {
   LayerAnimationController* controller = GetControllerForLayerId(layer_id);
   return controller ? controller->HasFilterAnimationThatInflatesBounds()
                     : false;
 }
 
 bool AnimationHost::HasTransformAnimationThatInflatesBounds(
@@ skipping 90 matching lines @@
   return scroll_offset_animations_->ScrollAnimationUpdateTarget(
       layer_id, scroll_delta, max_scroll_offset, frame_monotonic_time);
 }
 
 void AnimationHost::ScrollAnimationAbort() {
   DCHECK(scroll_offset_animations_);
   return scroll_offset_animations_->ScrollAnimationAbort();
 }
 
 }  // namespace cc