gfx::Transform API clean-up

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 16 matching lines @@
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_property.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/screen.h"
+#include "ui/gfx/vector3d_f.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(int)
 DECLARE_WINDOW_PROPERTY_TYPE(ash::WindowVisibilityAnimationType)
 DECLARE_WINDOW_PROPERTY_TYPE(ash::WindowVisibilityAnimationTransition)
 DECLARE_WINDOW_PROPERTY_TYPE(float)
 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(ASH_EXPORT, bool)
 
 using aura::Window;
@@ skipping 225 matching lines @@
 
   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);
 }
 
+static gfx::Transform GetScaleForWindow(aura::Window* window) {
+  gfx::Rect bounds = window->bounds();
+  gfx::Transform scale = gfx::GetScaleTransform(
+      gfx::Point(kWindowAnimation_TranslateFactor * bounds.width(),
+                 kWindowAnimation_TranslateFactor * bounds.height()),
+      kWindowAnimation_ScaleFactor);
+  return scale;
+}
+
 // Show/Hide windows using a shrink animation.
 void AnimateShowWindow_Drop(aura::Window* window) {
-  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, gfx::Transform());
+  AnimateShowWindowCommon(window, GetScaleForWindow(window), gfx::Transform());
 }
 
 void AnimateHideWindow_Drop(aura::Window* window) {
-  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);
+  AnimateHideWindowCommon(window, GetScaleForWindow(window));
 }
 
 // Show/Hide windows using a vertical Glenimation.
 void AnimateShowWindow_Vertical(aura::Window* window) {
   gfx::Transform transform;
-  transform.ConcatTranslate(0, window->GetProperty(
+  transform.Translate(0, window->GetProperty(
       kWindowVisibilityAnimationVerticalPositionKey));
   AnimateShowWindowCommon(window, transform, gfx::Transform());
 }
 
 void AnimateHideWindow_Vertical(aura::Window* window) {
   gfx::Transform transform;
-  transform.ConcatTranslate(0, window->GetProperty(
+  transform.Translate(0, window->GetProperty(
       kWindowVisibilityAnimationVerticalPositionKey));
   AnimateHideWindowCommon(window, transform);
 }
 
 // Show/Hide windows using a fade.
 void AnimateShowWindow_Fade(aura::Window* window) {
   AnimateShowWindowCommon(window, gfx::Transform(), gfx::Transform());
 }
 
 void AnimateHideWindow_Fade(aura::Window* window) {
@@ skipping 169 matching lines @@
       ui::LayerAnimationElement::CreateOpacityElement(
           show ? kWindowAnimation_ShowOpacity : kWindowAnimation_HideOpacity,
           duration * kWindowAnimation_Rotate_OpacityDurationPercent / 100));
   opacity->set_tween_type(ui::Tween::EASE_IN_OUT);
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(opacity.release()));
 
   float xcenter = window->bounds().width() * 0.5;
 
   gfx::Transform transform;
-  transform.ConcatTranslate(-xcenter, 0);
-  transform.ConcatPerspectiveDepth(kWindowAnimation_Rotate_PerspectiveDepth);
-  transform.ConcatTranslate(xcenter, 0);
+  transform.Translate(xcenter, 0);
+  transform.ApplyPerspectiveDepth(kWindowAnimation_Rotate_PerspectiveDepth);
+  transform.Translate(-xcenter, 0);
   scoped_ptr<ui::InterpolatedTransform> perspective(
       new ui::InterpolatedConstantTransform(transform));
 
   scoped_ptr<ui::InterpolatedTransform> scale(
       new ui::InterpolatedScale(1, kWindowAnimation_Rotate_ScaleFactor));
   scoped_ptr<ui::InterpolatedTransform> scale_about_pivot(
       new ui::InterpolatedTransformAboutPivot(
           gfx::Point(xcenter, kWindowAnimation_Rotate_TranslateY),
           scale.release()));
 
   scoped_ptr<ui::InterpolatedTransform> translation(
       new ui::InterpolatedTranslation(gfx::Point(), gfx::Point(
           0, kWindowAnimation_Rotate_TranslateY)));
 
   scoped_ptr<ui::InterpolatedTransform> rotation(
       new ui::InterpolatedAxisAngleRotation(
-          gfx::Point3F(1, 0, 0), 0, kWindowAnimation_Rotate_DegreesX));
+          gfx::Vector3dF(1, 0, 0), 0, kWindowAnimation_Rotate_DegreesX));
 
   scale_about_pivot->SetChild(perspective.release());
   translation->SetChild(scale_about_pivot.release());
   rotation->SetChild(translation.release());
   rotation->SetReversed(show);
 
   scoped_ptr<ui::LayerAnimationElement> transition(
       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
           rotation.release(), duration));
 
@@ skipping 150 matching lines @@
 
     // Animation observer owns the old layer and deletes itself.
     settings.AddObserver(new internal::CrossFadeObserver(window, old_layer));
     settings.SetTransitionDuration(duration);
     settings.SetTweenType(tween_type);
     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());
+    out_transform.Translate(new_bounds.x() - old_bounds.x(),
+                            new_bounds.y() - old_bounds.y());
+    out_transform.Scale(scale_x, scale_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.
   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(),
+  in_transform.Translate(old_bounds.x() - new_bounds.x(),
                                old_bounds.y() - new_bounds.y());
+  in_transform.Scale(scale_x, scale_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());
@@ skipping 157 matching lines @@
 
   std::vector<ui::LayerAnimationSequence*> animations;
   animations.push_back(brightness_sequence.release());
   animations.push_back(grayscale_sequence.release());
 
   return animations;
 }
 
 }  // namespace internal
 }  // namespace ash