ui/base/animation -> ui/gfx/animation

ui/compositor/layer_animator.h

 // Copyright (c) 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.
 
 #ifndef UI_COMPOSITOR_LAYER_ANIMATOR_H_
 #define UI_COMPOSITOR_LAYER_ANIMATOR_H_
 
 #include <deque>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
-#include "ui/base/animation/animation_container_element.h"
-#include "ui/base/animation/tween.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/compositor/layer_animation_element.h"
+#include "ui/gfx/animation/animation_container_element.h"
+#include "ui/gfx/animation/tween.h"
 
 namespace gfx {
+class Animation;
 class Rect;
 class Transform;
 }
 
 namespace ui {
-class Animation;
 class Layer;
 class LayerAnimationSequence;
 class LayerAnimationDelegate;
 class LayerAnimationObserver;
 class ScopedLayerAnimationSettings;
 
 // When a property of layer needs to be changed it is set by way of
 // LayerAnimator. This enables LayerAnimator to animate property changes.
 // NB: during many tests, set_disable_animations_for_test is used and causes
 // all animations to complete immediately. The layer animation is ref counted
 // so that if its owning layer is deleted (and the owning layer is only other
 // class that should ever hold a ref ptr to a LayerAnimator), the animator can
 // ensure that it is not disposed of until it finishes executing. It does this
 // by holding a reference to itself for the duration of methods for which it
 // must guarantee that |this| is valid.
 class COMPOSITOR_EXPORT LayerAnimator
-    : public AnimationContainerElement, public base::RefCounted<LayerAnimator> {
+    : public gfx::AnimationContainerElement,
+      public base::RefCounted<LayerAnimator> {
  public:
   enum PreemptionStrategy {
     IMMEDIATELY_SET_NEW_TARGET,
     IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
     ENQUEUE_NEW_ANIMATION,
     REPLACE_QUEUED_ANIMATIONS,
     BLEND_WITH_CURRENT_ANIMATION
   };
 
   explicit LayerAnimator(base::TimeDelta transition_duration);
@@ skipping 109 matching lines @@
   // list. The observers are notified when animations end.
   void AddObserver(LayerAnimationObserver* observer);
   void RemoveObserver(LayerAnimationObserver* observer);
 
   // Called when a threaded animation is actually started.
   void OnThreadedAnimationStarted(const cc::AnimationEvent& event);
 
   // This determines how implicit animations will be tweened. This has no
   // effect on animations that are explicitly started or scheduled. The default
   // is Tween::LINEAR.
-  void set_tween_type(Tween::Type tween_type) { tween_type_ = tween_type; }
-  Tween::Type tween_type() const { return tween_type_; }
+  void set_tween_type(gfx::Tween::Type tween_type) { tween_type_ = tween_type; }
+  gfx::Tween::Type tween_type() const { return tween_type_; }
 
   // For testing purposes only.
   void set_disable_timer_for_test(bool disable_timer) {
     disable_timer_for_test_ = disable_timer;
   }
 
   void set_last_step_time(base::TimeTicks time) {
     last_step_time_ = time;
   }
   base::TimeTicks last_step_time() const { return last_step_time_; }
@@ skipping 127 matching lines @@
   // The currently running animations.
   RunningAnimations running_animations_;
 
   // Determines how animations are replaced.
   PreemptionStrategy preemption_strategy_;
 
   // The default length of animations.
   base::TimeDelta transition_duration_;
 
   // The default tween type for implicit transitions
-  Tween::Type tween_type_;
+  gfx::Tween::Type tween_type_;
 
   // Used for coordinating the starting of animations.
   base::TimeTicks last_step_time_;
 
   // True if we are being stepped by our container.
   bool is_started_;
 
   // This prevents the animator from automatically stepping through animations
   // and allows for manual stepping.
   bool disable_timer_for_test_;
 
   // Prevents timer adjustments in case when we start multiple animations
   // with preemption strategies that discard previous animations.
   bool adding_animations_;
 
   // Observers are notified when layer animations end, are scheduled or are
   // aborted.
   ObserverList<LayerAnimationObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimator);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATOR_H_