Migrate ui::Transform to gfx::Transform

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 218 matching lines @@
 
   ui::Layer* layer_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceHidingWindowAnimationObserver);
 };
 
 // Shows a window using an animation, animating its opacity from 0.f to 1.f,
 // its visibility to true, and its transform from |start_transform| to
 // |end_transform|.
 void AnimateShowWindowCommon(aura::Window* window,
-                             const ui::Transform& start_transform,
-                             const ui::Transform& end_transform) {
+                             const gfx::Transform& start_transform,
+                             const gfx::Transform& end_transform) {
   window->layer()->set_delegate(window);
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   window->layer()->SetTransform(start_transform);
 
   {
     // Property sets within this scope will be implicitly animated.
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
     base::TimeDelta duration = GetWindowVisibilityAnimationDuration(window);
     if (duration.ToInternalValue() > 0)
       settings.SetTransitionDuration(duration);
 
     window->layer()->SetVisible(true);
     window->layer()->SetTransform(end_transform);
     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
   }
 }
 
 // Hides a window using an animation, animating its opacity from 1.f to 0.f,
 // its visibility to false, and its transform to |end_transform|.
 void AnimateHideWindowCommon(aura::Window* window,
-                             const ui::Transform& end_transform) {
+                             const gfx::Transform& end_transform) {
   window->layer()->set_delegate(NULL);
 
   // Property sets within this scope will be implicitly animated.
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   settings.AddObserver(new HidingWindowAnimationObserver(window));
 
   base::TimeDelta duration = GetWindowVisibilityAnimationDuration(window);
   if (duration.ToInternalValue() > 0)
     settings.SetTransitionDuration(duration);
 
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   window->layer()->SetTransform(end_transform);
   window->layer()->SetVisible(false);
 }
 
 // Show/Hide windows using a shrink animation.
 void AnimateShowWindow_Drop(aura::Window* window) {
-  ui::Transform transform;
+  gfx::Transform transform;
   transform.ConcatScale(kWindowAnimation_ScaleFactor,
                         kWindowAnimation_ScaleFactor);
   gfx::Rect bounds = window->bounds();
   transform.ConcatTranslate(
       kWindowAnimation_TranslateFactor * bounds.width(),
       kWindowAnimation_TranslateFactor * bounds.height());
-  AnimateShowWindowCommon(window, transform, ui::Transform());
+  AnimateShowWindowCommon(window, transform, gfx::Transform());
 }
 
 void AnimateHideWindow_Drop(aura::Window* window) {
-  ui::Transform transform;
+  gfx::Transform transform;
   transform.ConcatScale(kWindowAnimation_ScaleFactor,
                         kWindowAnimation_ScaleFactor);
   gfx::Rect bounds = window->bounds();
   transform.ConcatTranslate(
       kWindowAnimation_TranslateFactor * bounds.width(),
       kWindowAnimation_TranslateFactor * bounds.height());
   AnimateHideWindowCommon(window, transform);
 }
 
 // Show/Hide windows using a vertical Glenimation.
 void AnimateShowWindow_Vertical(aura::Window* window) {
-  ui::Transform transform;
+  gfx::Transform transform;
   transform.ConcatTranslate(0, window->GetProperty(
       kWindowVisibilityAnimationVerticalPositionKey));
-  AnimateShowWindowCommon(window, transform, ui::Transform());
+  AnimateShowWindowCommon(window, transform, gfx::Transform());
 }
 
 void AnimateHideWindow_Vertical(aura::Window* window) {
-  ui::Transform transform;
+  gfx::Transform transform;
   transform.ConcatTranslate(0, window->GetProperty(
       kWindowVisibilityAnimationVerticalPositionKey));
   AnimateHideWindowCommon(window, transform);
 }
 
 // Show/Hide windows using a fade.
 void AnimateShowWindow_Fade(aura::Window* window) {
-  AnimateShowWindowCommon(window, ui::Transform(), ui::Transform());
+  AnimateShowWindowCommon(window, gfx::Transform(), gfx::Transform());
 }
 
 void AnimateHideWindow_Fade(aura::Window* window) {
-  AnimateHideWindowCommon(window, ui::Transform());
+  AnimateHideWindowCommon(window, gfx::Transform());
 }
 
 // Builds the transform used when switching workspaces for the specified
 // window.
-ui::Transform BuildWorkspaceSwitchTransform(aura::Window* window, float scale) {
+gfx::Transform BuildWorkspaceSwitchTransform(aura::Window* window,
+                                             float scale) {
   // Animations for transitioning workspaces scale all windows. To give the
   // effect of scaling from the center of the screen the windows are translated.
   gfx::Rect bounds = window->bounds();
   gfx::Rect parent_bounds(window->parent()->bounds());
 
   float mid_x = static_cast<float>(parent_bounds.width()) / 2.0f;
   float initial_x =
       (static_cast<float>(bounds.x()) - mid_x) * scale + mid_x;
   float mid_y = static_cast<float>(parent_bounds.height()) / 2.0f;
   float initial_y =
       (static_cast<float>(bounds.y()) - mid_y) * scale + mid_y;
 
-  ui::Transform transform;
+  gfx::Transform transform;
   transform.ConcatTranslate(
       initial_x - static_cast<float>(bounds.x()),
       initial_y - static_cast<float>(bounds.y()));
   transform.ConcatScale(scale, scale);
   return transform;
 }
 
 void AnimateShowWindow_Workspace(aura::Window* window) {
-  ui::Transform transform(
+  gfx::Transform transform(
       BuildWorkspaceSwitchTransform(window, kWorkspaceScale));
   // When we call SetOpacity here, if a hide sequence is already running,
   // the default animation preemption strategy fast forwards the hide sequence
   // to completion and notifies the WorkspaceHidingWindowAnimationObserver to
   // set the layer to be invisible. We should call SetVisible after SetOpacity
   // to ensure our layer is visible again.
   window->layer()->SetOpacity(0.0f);
   window->layer()->SetTransform(transform);
   window->layer()->SetVisible(true);
 
   {
     // Property sets within this scope will be implicitly animated.
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
 
-    window->layer()->SetTransform(ui::Transform());
+    window->layer()->SetTransform(gfx::Transform());
     // Opacity animates only during the first half of the animation.
     settings.SetTransitionDuration(settings.GetTransitionDuration() / 2);
     window->layer()->SetOpacity(1.0f);
   }
 }
 
 void AnimateHideWindow_Workspace(aura::Window* window) {
-  ui::Transform transform(
+  gfx::Transform transform(
       BuildWorkspaceSwitchTransform(window, kWorkspaceScale));
   window->layer()->SetOpacity(1.0f);
-  window->layer()->SetTransform(ui::Transform());
+  window->layer()->SetTransform(gfx::Transform());
 
   // Opacity animates from 1 to 0 only over the second half of the animation. To
   // get this functionality two animations are schedule for opacity, the first
   // from 1 to 1 (which effectively does nothing) the second from 1 to 0.
   // Because we're scheduling two animations of the same property we need to
   // change the preemption strategy.
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
   {
     // Property sets within this scope will be implicitly animated.
@@ skipping 318 matching lines @@
 
   // Scale up the old layer while translating to new position.
   {
     old_layer->GetAnimator()->StopAnimating();
     ui::ScopedLayerAnimationSettings settings(old_layer->GetAnimator());
 
     // Animation observer owns the old layer and deletes itself.
     settings.AddObserver(new internal::CrossFadeObserver(window, old_layer));
     settings.SetTransitionDuration(duration);
     settings.SetTweenType(tween_type);
-    ui::Transform out_transform;
+    gfx::Transform out_transform;
     float scale_x = static_cast<float>(new_bounds.width()) /
         static_cast<float>(old_bounds.width());
     float scale_y = static_cast<float>(new_bounds.height()) /
         static_cast<float>(old_bounds.height());
     out_transform.ConcatScale(scale_x, scale_y);
     out_transform.ConcatTranslate(new_bounds.x() - old_bounds.x(),
                                   new_bounds.y() - old_bounds.y());
     old_layer->SetTransform(out_transform);
     if (old_on_top) {
       // The old layer is on top, and should fade out.  The new layer below will
       // stay opaque to block the desktop.
       old_layer->SetOpacity(0.f);
     }
     // In tests |old_layer| is deleted here, as animations have zero duration.
     old_layer = NULL;
   }
 
   // Set the new layer's current transform, such that the user sees a scaled
   // version of the window with the original bounds at the original position.
-  ui::Transform in_transform;
+  gfx::Transform in_transform;
   const float scale_x = static_cast<float>(old_bounds.width()) /
       static_cast<float>(new_bounds.width());
   const float scale_y = static_cast<float>(old_bounds.height()) /
       static_cast<float>(new_bounds.height());
   in_transform.ConcatScale(scale_x, scale_y);
   in_transform.ConcatTranslate(old_bounds.x() - new_bounds.x(),
                                old_bounds.y() - new_bounds.y());
   window->layer()->SetTransform(in_transform);
   if (!old_on_top) {
     // The new layer is on top and should fade in.  The old layer below will
     // stay opaque and block the desktop.
     window->layer()->SetOpacity(0.f);
   }
   {
     // Animate the new layer to the identity transform, so the window goes to
     // its newly set bounds.
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
     settings.SetTransitionDuration(duration);
     settings.SetTweenType(tween_type);
-    window->layer()->SetTransform(ui::Transform());
+    window->layer()->SetTransform(gfx::Transform());
     if (!old_on_top) {
       // New layer is on top, fade it in.
       window->layer()->SetOpacity(1.f);
     }
   }
   return duration;
 }
 
 }  // namespace
 
@@ skipping 111 matching lines @@
     return AnimateShowWindow(window);
   } else {
     // Don't start hiding the window again if it's already being hidden.
     return window->layer()->GetTargetOpacity() != 0.0f &&
         AnimateHideWindow(window);
   }
 }
 
 }  // namespace internal
 }  // namespace ash