Adjust window timings to match Cole's video.

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 "ash/animation_timings.h"
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 48 matching lines @@
   WindowVisibilityAnimationTransition prop = window->GetProperty(
       internal::kWindowVisibilityAnimationTransitionKey);
   return (prop & transition) != 0;
 }
 
 namespace internal {
 namespace {
 
 const float kWindowAnimation_HideOpacity = 0.f;
 const float kWindowAnimation_ShowOpacity = 1.f;
-const float kWindowAnimation_TranslateFactor = -0.025f;
-const float kWindowAnimation_ScaleFactor = 1.05f;
+const float kWindowAnimation_TranslateX = 3.f;
+const float kWindowAnimation_TranslateY = -12.f;
+const float kWindowAnimation_ScaleFactor = .95f;
 const float kWindowAnimation_MinimizeRotate = -5.f;
-
 const float kWindowAnimation_Vertical_TranslateY = 15.f;
 
 // Amount windows are scaled during workspace animations.
 const float kWorkspaceScale = .95f;
 
 // Gets/sets the WindowVisibilityAnimationType associated with a window.
 WindowVisibilityAnimationType GetWindowVisibilityAnimationType(
     aura::Window* window) {
   WindowVisibilityAnimationType type =
       window->GetProperty(kWindowVisibilityAnimationTypeKey);
@@ skipping 87 matching lines @@
     // Restore the correct visibility value (overridden for the duration of the
     // animation in AnimateHideWindow()).
     layer_->SetVisible(false);
   }
 
   ui::Layer* layer_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceHidingWindowAnimationObserver);
 };
 
+base::TimeDelta GetAnimationDurationForWindow(aura::Window* window) {
+  int duration =
+      window->GetProperty(internal::kWindowVisibilityAnimationDurationKey);
+  if (duration > 0)
+    return TimeDelta::FromInternalValue(duration);
+  return TimeDelta::FromMilliseconds(kStandardTransitionDuration);
+}
+
 // Shows a window using an animation, animating its opacity from 0.f to 1.f, and
 // its transform from |start_transform| to |end_transform|.
 void AnimateShowWindowCommon(aura::Window* window,
                              const ui::Transform& start_transform,
                              const ui::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());
-    int duration =
-        window->GetProperty(internal::kWindowVisibilityAnimationDurationKey);
-    if (duration > 0)
-      settings.SetTransitionDuration(TimeDelta::FromInternalValue(duration));
-
+    settings.SetTransitionDuration(GetAnimationDurationForWindow(window));
     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, and
 // its transform to |end_transform|.
 void AnimateHideWindowCommon(aura::Window* window,
                              const ui::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));
 
-  int duration =
-      window->GetProperty(internal::kWindowVisibilityAnimationDurationKey);
-  if (duration > 0)
-    settings.SetTransitionDuration(TimeDelta::FromInternalValue(duration));
-
+  settings.SetTransitionDuration(GetAnimationDurationForWindow(window));
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   window->layer()->SetTransform(end_transform);
 }
 
 // Show/Hide windows using a shrink animation.
 void AnimateShowWindow_Drop(aura::Window* window) {
   ui::Transform transform;
   transform.ConcatScale(kWindowAnimation_ScaleFactor,
                         kWindowAnimation_ScaleFactor);
-  transform.ConcatTranslate(
-      kWindowAnimation_TranslateFactor * window->bounds().width(),
-      kWindowAnimation_TranslateFactor * window->bounds().height());
+  transform.ConcatTranslate(kWindowAnimation_TranslateX,
+                            kWindowAnimation_TranslateY);
   AnimateShowWindowCommon(window, transform, ui::Transform());
 }
 
 void AnimateHideWindow_Drop(aura::Window* window) {
   ui::Transform transform;
   transform.ConcatScale(kWindowAnimation_ScaleFactor,
                         kWindowAnimation_ScaleFactor);
-  transform.ConcatTranslate(
-      kWindowAnimation_TranslateFactor * window->bounds().width(),
-      kWindowAnimation_TranslateFactor * window->bounds().height());
+  // Window keeps dropping vertically when hidden (i.e. doesn't reverse
+  // direction)
+  transform.ConcatTranslate(kWindowAnimation_TranslateX,
+                            -kWindowAnimation_TranslateY);
   AnimateHideWindowCommon(window, transform);
 }
 
 // Show/Hide windows using a vertical Glenimation.
 void AnimateShowWindow_Vertical(aura::Window* window) {
   ui::Transform transform;
   transform.ConcatTranslate(0, kWindowAnimation_Vertical_TranslateY);
   AnimateShowWindowCommon(window, transform, ui::Transform());
 }
 
@@ skipping 37 matching lines @@
 
 void AnimateShowWindow_Workspace(aura::Window* window) {
   ui::Transform transform(BuildWorkspaceSwitchTransform(window));
   window->layer()->SetVisible(true);
   window->layer()->SetOpacity(0.0f);
   window->layer()->SetTransform(transform);
 
   {
     // Property sets within this scope will be implicitly animated.
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
+    settings.SetTransitionDuration(
+        TimeDelta::FromMilliseconds(kSlowTransitionDuration));
 
     window->layer()->SetTransform(ui::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(BuildWorkspaceSwitchTransform(window));
   window->layer()->SetOpacity(1.0f);
   window->layer()->SetTransform(ui::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.
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
+    settings.SetTransitionDuration(
+        TimeDelta::FromMilliseconds(kSlowTransitionDuration));
     // Add an observer that sets visibility of the layer to false once animation
     // completes.
     settings.AddObserver(new WorkspaceHidingWindowAnimationObserver(window));
     window->layer()->SetTransform(transform);
     settings.SetTransitionDuration(settings.GetTransitionDuration() / 2);
     window->layer()->SetOpacity(1.0f);
     window->layer()->SetOpacity(0.0f);
   }
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
@@ skipping 148 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