Migrate ui::Transform to gfx::Transform

ash/wm/session_state_animator.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/session_state_animator.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ui/aura/root_window.h"
 #include "ui/compositor/layer_animation_sequence.h"
@@ skipping 20 matching lines @@
 // Amount of time taken to make the lock window fade in when the screen is
 // locked.
 const int kLockFadeInAnimMs = 200;
 
 // Slightly-smaller size that we scale the screen down to for the pre-lock and
 // pre-shutdown states.
 const float kSlowCloseSizeRatio = 0.95f;
 
 // Returns the transform that should be applied to containers for the slow-close
 // animation.
-ui::Transform GetSlowCloseTransform() {
+gfx::Transform GetSlowCloseTransform() {
   gfx::Size root_size = Shell::GetPrimaryRootWindow()->bounds().size();
-  ui::Transform transform;
+  gfx::Transform transform;
   transform.SetScale(kSlowCloseSizeRatio, kSlowCloseSizeRatio);
   transform.ConcatTranslate(
       floor(0.5 * (1.0 - kSlowCloseSizeRatio) * root_size.width() + 0.5),
       floor(0.5 * (1.0 - kSlowCloseSizeRatio) * root_size.height() + 0.5));
   return transform;
 }
 
 // Returns the transform that should be applied to containers for the fast-close
 // animation.
-ui::Transform GetFastCloseTransform() {
+gfx::Transform GetFastCloseTransform() {
   gfx::Size root_size = Shell::GetPrimaryRootWindow()->bounds().size();
-  ui::Transform transform;
+  gfx::Transform transform;
   transform.SetScale(0.0, 0.0);
   transform.ConcatTranslate(floor(0.5 * root_size.width() + 0.5),
                             floor(0.5 * root_size.height() + 0.5));
   return transform;
 }
 
 // Slowly shrinks |window| to a slightly-smaller size.
 void StartSlowCloseAnimationForWindow(aura::Window* window) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   animator->StartAnimation(
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateTransformElement(
               GetSlowCloseTransform(),
               base::TimeDelta::FromMilliseconds(kSlowCloseAnimMs))));
 }
 
 // Quickly undoes the effects of the slow-close animation on |window|.
 void StartUndoSlowCloseAnimationForWindow(aura::Window* window) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   animator->StartAnimation(
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateTransformElement(
-              ui::Transform(),
+              gfx::Transform(),
               base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs))));
 }
 
 // Quickly shrinks |window| down to a point in the center of the screen and
 // fades it out to 0 opacity.
 void StartFastCloseAnimationForWindow(aura::Window* window) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   animator->StartAnimation(
@@ skipping 19 matching lines @@
 }
 
 // Makes |window| fully transparent instantaneously.
 void HideWindow(aura::Window* window) {
   window->layer()->SetOpacity(0.0);
 }
 
 // Restores |window| to its original position and scale and full opacity
 // instantaneously.
 void RestoreWindow(aura::Window* window) {
-  window->layer()->SetTransform(ui::Transform());
+  window->layer()->SetTransform(gfx::Transform());
   window->layer()->SetOpacity(1.0);
 }
 
 }  // namespace
 
 void SessionStateAnimator::TestApi::TriggerHideBlackLayerTimeout() {
       animator_->DropBlackLayer();
       animator_->hide_black_layer_timer_.Stop();
 }
 
 bool SessionStateAnimator::TestApi::ContainersAreAnimated(
     int container_mask, AnimationType type) const {
   aura::Window::Windows containers;
   animator_->GetContainers(container_mask, &containers);
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     aura::Window* window = *it;
     ui::Layer* layer = window->layer();
 
     switch (type) {
       case ANIMATION_SLOW_CLOSE:
         if (layer->GetTargetTransform() != GetSlowCloseTransform())
           return false;
         break;
       case ANIMATION_UNDO_SLOW_CLOSE:
-        if (layer->GetTargetTransform() != ui::Transform())
+        if (layer->GetTargetTransform() != gfx::Transform())
           return false;
         break;
       case ANIMATION_FAST_CLOSE:
         if (layer->GetTargetTransform() != GetFastCloseTransform() ||
             layer->GetTargetOpacity() > 0.0001)
           return false;
         break;
       case ANIMATION_FADE_IN:
         if (layer->GetTargetOpacity() < 0.9999)
           return false;
         break;
       case ANIMATION_HIDE:
         if (layer->GetTargetOpacity() > 0.0001)
           return false;
         break;
       case ANIMATION_RESTORE:
-        if (layer->opacity() < 0.9999 || layer->transform() != ui::Transform())
+        if (layer->opacity() < 0.9999 || layer->transform() != gfx::Transform())
           return false;
         break;
       default:
         NOTREACHED() << "Unhandled animation type " << type;
         return false;
     }
   }
   return true;
 }
 
@@ skipping 138 matching lines @@
 void SessionStateAnimator::ScheduleDropBlackLayer() {
   hide_black_layer_timer_.Stop();
   hide_black_layer_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs),
       this, &SessionStateAnimator::DropBlackLayer);
 }
 
 }  // namespace internal
 }  // namespace ash