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 214 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 332 matching lines @@
 
 // Used to identify what should animate in AnimateWorkspaceIn/Out.
 enum WorkspaceAnimateTypes {
   WORKSPACE_ANIMATE_OPACITY =    1 << 0,
   WORKSPACE_ANIMATE_BRIGHTNESS = 1 << 1,
 };
 
 void ApplyWorkspaceScale(ui::Layer* layer, WorkspaceScaleType type) {
   const float scale = type == WORKSPACE_SCALE_ABOVE ? kWorkspaceScaleAbove :
       kWorkspaceScaleBelow;
-  ui::Transform transform;
+  gfx::Transform transform;
   transform.ConcatScale(scale, scale);
   transform.ConcatTranslate(
       -layer->bounds().width() * (scale - 1.0f) / 2,
       -layer->bounds().height() * (scale - 1.0f) / 2);
   layer->SetTransform(transform);
 }
 
 // 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.
@@ skipping 16 matching lines @@
     ui::ScopedLayerAnimationSettings settings(old_layer->GetAnimator());
     settings.SetPreemptionStrategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
     old_layer->GetAnimator()->SchedulePauseForProperties(
         pause_duration, ui::LayerAnimationElement::TRANSFORM,
         ui::LayerAnimationElement::OPACITY, -1);
 
     // 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.SetPreemptionStrategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
     window->layer()->GetAnimator()->SchedulePauseForProperties(
         pause_duration, ui::LayerAnimationElement::TRANSFORM,
         ui::LayerAnimationElement::OPACITY, -1);
     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;
 }
 
 // Returns a TimeDelta from |time_ms|. If animations are disabled this returns
 // a TimeDelta of 0 (so the animation completes immediately).
@@ skipping 42 matching lines @@
           AdjustAnimationTime(pause_time_ms),
           ui::LayerAnimationElement::TRANSFORM,
           ui::LayerAnimationElement::OPACITY,
           ui::LayerAnimationElement::BRIGHTNESS,
           ui::LayerAnimationElement::VISIBILITY,
           -1);
     }
 
     settings.SetTweenType(tween_type);
     settings.SetTransitionDuration(duration);
-    window->layer()->SetTransform(ui::Transform());
+    window->layer()->SetTransform(gfx::Transform());
     window->layer()->SetOpacity(1.0f);
     window->layer()->SetLayerBrightness(0.0f);
   }
 }
 
 void AnimateWorkspaceOutImpl(aura::Window* window,
                              WorkspaceAnimationDirection direction,
                              uint32 animate_types,
                              int pause_time_ms,
                              ui::Tween::Type tween_type,
                              TimeDelta duration) {
   window->Show();
-  window->layer()->SetTransform(ui::Transform());
+  window->layer()->SetTransform(gfx::Transform());
   window->layer()->SetLayerBrightness(0.0f);
   window->layer()->SetOpacity(1.0f);
   window->layer()->GetAnimator()->StopAnimating();
 
   {
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
 
     if (pause_time_ms > 0) {
       settings.SetPreemptionStrategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
       window->layer()->GetAnimator()->SchedulePauseForProperties(
@@ skipping 17 matching lines @@
     if (animate_types & WORKSPACE_ANIMATE_OPACITY)
       window->layer()->SetOpacity(0.0f);
     if (animate_types & WORKSPACE_ANIMATE_BRIGHTNESS)
       window->layer()->SetLayerBrightness(kWorkspaceBrightness);
 
     // After the animation completes snap the transform back to the identity,
     // otherwise any one that asks for screen bounds gets a slightly scaled
     // version.
     settings.SetPreemptionStrategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
     settings.SetTransitionDuration(base::TimeDelta());
-    window->layer()->SetTransform(ui::Transform());
+    window->layer()->SetTransform(gfx::Transform());
   }
 }
 
 ui::Tween::Type TweenTypeForWorskpaceOut(WorkspaceType type) {
   return WORKSPACE_DESKTOP ? ui::Tween::LINEAR : ui::Tween::EASE_OUT;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 83 matching lines @@
     if (old_workspace)
       AnimateWorkspaceOutImpl(old_workspace, WORKSPACE_ANIMATE_UP,
                               WORKSPACE_ANIMATE_BRIGHTNESS,
                               0, workspace_tween_type, duration);
 
     // Ideally we would use AnimateWorkspaceIn() for |new_workspace|, but that
     // results in |window| animating with the workspace scale. We don't want
     // that, so we explicitly animate each of the children to give the effect of
     // the workspace scaling.
     new_workspace->Show();
-    new_workspace->SetTransform(ui::Transform());
+    new_workspace->SetTransform(gfx::Transform());
     new_workspace->layer()->SetOpacity(1.0f);
     new_workspace->layer()->SetLayerBrightness(0.0f);
     const Windows& children(new_workspace->children());
     for (Windows::const_iterator i = children.begin(); i != children.end();
          ++i) {
       aura::Window* child = *i;
       if (child == window)
         continue;
       child->SetTransform(ash::internal::BuildWorkspaceSwitchTransform(
                               child, kWorkspaceScaleBelow));
       child->layer()->SetLayerBrightness(kWorkspaceBrightness);
       ui::ScopedLayerAnimationSettings settings(child->layer()->GetAnimator());
       settings.SetTweenType(ui::Tween::EASE_OUT);
       settings.SetTransitionDuration(duration);
-      child->SetTransform(ui::Transform());
+      child->SetTransform(gfx::Transform());
       child->layer()->SetLayerBrightness(0.0f);
     }
   } else {
     if (old_workspace) {
       AnimateWorkspaceOutImpl(old_workspace, WORKSPACE_ANIMATE_DOWN,
                               WORKSPACE_ANIMATE_BRIGHTNESS,
                               0, workspace_tween_type, duration);
     }
 
     new_workspace->Show();
     new_workspace->layer()->SetOpacity(1.f);
-    new_workspace->layer()->SetTransform(ui::Transform());
+    new_workspace->layer()->SetTransform(gfx::Transform());
     new_workspace->layer()->SetLayerBrightness(0.0f);
   }
 }
 
 void AnimateBetweenWorkspaces(aura::Window* old_window,
                               WorkspaceType old_type,
                               bool animate_old,
                               aura::Window* new_window,
                               WorkspaceType new_type,
                               bool is_restoring_maximized_window) {
@@ skipping 104 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