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

ash/wm/window_animations.cc

 // 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.
 
 #include "ash/wm/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 42 matching lines @@
 // Brightness/grayscale values for hide/show window animations.
 const float kWindowAnimation_HideBrightnessGrayscale = 1.f;
 const float kWindowAnimation_ShowBrightnessGrayscale = 0.f;
 
 const float kWindowAnimation_HideOpacity = 0.f;
 const float kWindowAnimation_ShowOpacity = 1.f;
 // TODO(sky): if we end up sticking with 0, nuke the code doing the rotation.
 const float kWindowAnimation_MinimizeRotate = 0.f;
 
 // Tween type when cross fading a workspace window.
-const ui::Tween::Type kCrossFadeTweenType = ui::Tween::EASE_IN_OUT;
+const gfx::Tween::Type kCrossFadeTweenType = gfx::Tween::EASE_IN_OUT;
 
 // Scales for AshWindow above/below current workspace.
 const float kLayerScaleAboveSize = 1.1f;
 const float kLayerScaleBelowSize = .9f;
 
 int64 Round64(float f) {
   return static_cast<int64>(f + 0.5f);
 }
 
 }  // namespace
@@ skipping 35 matching lines @@
   rotation_about_pivot->SetReversed(show);
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
       kLayerAnimationsForMinimizeDurationMS);
 
   scoped_ptr<ui::LayerAnimationElement> transition(
       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
           rotation_about_pivot.release(), duration));
 
   transition->set_tween_type(
-      show ? ui::Tween::EASE_IN : ui::Tween::EASE_IN_OUT);
+      show ? gfx::Tween::EASE_IN : gfx::Tween::EASE_IN_OUT);
 
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(transition.release()));
 
   // When hiding a window, turn off blending until the animation is 3 / 4 done
   // to save bandwidth and reduce jank.
   if (!show) {
     window->layer()->GetAnimator()->SchedulePauseForProperties(
         (duration * 3) / 4, ui::LayerAnimationElement::OPACITY, -1);
   }
@@ skipping 181 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(CrossFadeObserver);
 };
 
 // Implementation of cross fading. Window is the window being cross faded. It
 // should be at the target bounds. |old_layer| the previous layer from |window|.
 // This takes ownership of |old_layer| and deletes when the animation is done.
 // |pause_duration| is the duration to pause at the current bounds before
 // animating. Returns the duration of the fade.
 base::TimeDelta CrossFadeImpl(aura::Window* window,
                               ui::Layer* old_layer,
-                              ui::Tween::Type tween_type) {
+                              gfx::Tween::Type tween_type) {
   const gfx::Rect old_bounds(old_layer->bounds());
   const gfx::Rect new_bounds(window->bounds());
   const bool old_on_top = (old_bounds.width() > new_bounds.width());
 
   // Shorten the animation if there's not much visual movement.
   const base::TimeDelta duration = GetCrossFadeDuration(old_bounds, new_bounds);
 
   // Scale up the old layer while translating to new position.
   {
     old_layer->GetAnimator()->StopAnimating();
@@ skipping 74 matching lines @@
   // Resize the window to the new size, which will force a layout and paint.
   window->SetBounds(new_bounds);
 
   // Ensure the higher-resolution layer is on top.
   bool old_on_top = (old_bounds.width() > new_bounds.width());
   if (old_on_top)
     old_layer->parent()->StackBelow(new_layer, old_layer);
   else
     old_layer->parent()->StackAbove(new_layer, old_layer);
 
-  CrossFadeImpl(window, old_layer, ui::Tween::EASE_OUT);
+  CrossFadeImpl(window, old_layer, gfx::Tween::EASE_OUT);
 }
 
 void CrossFadeWindowBetweenWorkspaces(aura::Window* new_workspace,
                                       aura::Window* window,
                                       ui::Layer* old_layer) {
   ui::Layer* layer_parent = new_workspace->layer()->parent();
   layer_parent->Add(old_layer);
   const bool restoring = old_layer->bounds().width() > window->bounds().width();
   if (restoring)
     layer_parent->StackAbove(old_layer, new_workspace->layer());
@@ skipping 39 matching lines @@
   if (visible)
     return AnimateShowWindow(window);
   // Don't start hiding the window again if it's already being hidden.
   return window->layer()->GetTargetOpacity() != 0.0f &&
       AnimateHideWindow(window);
 }
 
 std::vector<ui::LayerAnimationSequence*>
 CreateBrightnessGrayscaleAnimationSequence(float target_value,
                                            base::TimeDelta duration) {
-  ui::Tween::Type animation_type = ui::Tween::EASE_OUT;
+  gfx::Tween::Type animation_type = gfx::Tween::EASE_OUT;
   scoped_ptr<ui::LayerAnimationSequence> brightness_sequence(
       new ui::LayerAnimationSequence());
   scoped_ptr<ui::LayerAnimationSequence> grayscale_sequence(
       new ui::LayerAnimationSequence());
 
   scoped_ptr<ui::LayerAnimationElement> brightness_element(
       ui::LayerAnimationElement::CreateBrightnessElement(
           target_value, duration));
   brightness_element->set_tween_type(animation_type);
   brightness_sequence->AddElement(brightness_element.release());
@@ skipping 67 matching lines @@
   }
 
   // Assume the launcher is overflowed, zoom off to the bottom right of the
   // work area.
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(window).work_area();
   return gfx::Rect(work_area.right(), work_area.bottom(), 0, 0);
 }
 
 }  // namespace ash