Remove unneeded ScopedLayerAnimationSettings::LockTransitionDuration()

ui/views/corewm/window_animations.cc

Index: ui/views/corewm/window_animations.cc
diff --git a/ui/views/corewm/window_animations.cc b/ui/views/corewm/window_animations.cc
index d5d4da7f3cf2822936f71b457d708e2294e191eb..c8c8677d5cf309002eb8240ac0ba34f645fdbc26 100644
--- a/ui/views/corewm/window_animations.cc
+++ b/ui/views/corewm/window_animations.cc
@@ -56,7 +56,8 @@ const float kWindowAnimation_Vertical_TranslateY = 15.f;
 DEFINE_WINDOW_PROPERTY_KEY(int,
                            kWindowVisibilityAnimationTypeKey,
                            WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
-DEFINE_WINDOW_PROPERTY_KEY(int, kWindowVisibilityAnimationDurationKey, 0);
+DEFINE_WINDOW_PROPERTY_KEY(int, kWindowShowAnimationDurationKey, 0);
+DEFINE_WINDOW_PROPERTY_KEY(int, kWindowHideAnimationDurationKey, 0);
 DEFINE_WINDOW_PROPERTY_KEY(WindowVisibilityAnimationTransition,
                            kWindowVisibilityAnimationTransitionKey,
                            ANIMATE_BOTH);
@@ -66,6 +67,7 @@ DEFINE_WINDOW_PROPERTY_KEY(float,
 
 namespace {
 
+const int kDefaultAnimationDurationMS = 200;
 const int kDefaultAnimationDurationForMenuMS = 150;
 
 const float kWindowAnimation_HideOpacity = 0.f;
@@ -84,14 +86,11 @@ const float kWindowAnimation_Bounce_Scale = 1.02f;
 const int kWindowAnimation_Bounce_DurationMS = 180;
 const int kWindowAnimation_Bounce_GrowShrinkDurationPercent = 40;
 
-base::TimeDelta GetWindowVisibilityAnimationDuration(aura::Window* window) {
-  int duration =
-      window->GetProperty(kWindowVisibilityAnimationDurationKey);
-  if (duration == 0 && window->type() == ui::wm::WINDOW_TYPE_MENU) {
-    return base::TimeDelta::FromMilliseconds(
-        kDefaultAnimationDurationForMenuMS);
-  }
-  return TimeDelta::FromInternalValue(duration);
+base::TimeDelta GetDefaultWindowVisibilityAnimationDuration(
+    aura::Window* window) {
+  int duration_ms = (window->type() == ui::wm::WINDOW_TYPE_MENU) ?
+      kDefaultAnimationDurationForMenuMS : kDefaultAnimationDurationMS;
+  return base::TimeDelta::FromMilliseconds(duration_ms);
 }
 
 // Gets/sets the WindowVisibilityAnimationType associated with a window.
@@ -255,9 +254,9 @@ void AnimateShowWindowCommon(aura::Window* window,
   {
     // 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);
+    base::TimeDelta duration = GetWindowShowAnimationDuration(window,
+        GetDefaultWindowVisibilityAnimationDuration(window));
+    settings.SetTransitionDuration(duration);
 
     window->layer()->SetTransform(end_transform);
     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
@@ -274,10 +273,9 @@ void AnimateHideWindowCommon(aura::Window* window,
   // 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);
+  base::TimeDelta duration = GetWindowHideAnimationDuration(window,
+      GetDefaultWindowVisibilityAnimationDuration(window));
+  settings.SetTransitionDuration(duration);
 
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   window->layer()->SetTransform(end_transform);
@@ -372,18 +370,27 @@ void AnimateBounce(aura::Window* window) {
 
 void AddLayerAnimationsForRotate(aura::Window* window, bool show) {
   window->layer()->set_delegate(window);
-  if (show)
+  if (show) {
+    window->layer()->SetVisible(true);
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
+  }
 
-  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
+  base::TimeDelta default_duration = base::TimeDelta::FromMilliseconds(
       kWindowAnimation_Rotate_DurationMS);
+  base::TimeDelta duration = show ?
+      GetWindowShowAnimationDuration(window, default_duration) :
+      GetWindowHideAnimationDuration(window, default_duration);
+
+  ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
+  settings.SetTransitionDuration(duration);
 
   if (!show) {

[pkotwicz, 2013/12/23 01:12:06]

Previously, we were leaking memory here.

[varkha, 2014/01/02 20:24:26]

Why wasn't the hiding observer deleting itself upon completion of the animation?

[pkotwicz, 2014/01/02 20:30:00]

We were never setting the HidingWindowAnimationObserver as an observer of an
animation. Hence, the observer was never getting notified when the animation
terminated

[varkha, 2014/01/02 21:35:27]

I see. Don't you want to use views::corewm::CreateHidingWindowAnimationObserver
as elsewhere. Same in
https://code.google.com/p/chromium/codesearch#chromium/src/ui/views/corewm/wi...

-    new HidingWindowAnimationObserver(window);
+    settings.AddObserver(new HidingWindowAnimationObserver(window));
     window->layer()->GetAnimator()->SchedulePauseForProperties(
         duration * (100 - kWindowAnimation_Rotate_OpacityDurationPercent) / 100,
         ui::LayerAnimationElement::OPACITY,
         -1);
+    window->layer()->SetVisible(false);
   }
   scoped_ptr<ui::LayerAnimationElement> opacity(
       ui::LayerAnimationElement::CreateOpacityElement(
@@ -525,12 +532,34 @@ bool HasWindowVisibilityAnimationTransition(
   return (prop & transition) != 0;
 }
 
-void SetWindowVisibilityAnimationDuration(aura::Window* window,
-                                          const TimeDelta& duration) {
-  window->SetProperty(kWindowVisibilityAnimationDurationKey,
+void SetWindowShowAnimationDuration(aura::Window* window,
+                                    const base::TimeDelta& duration) {
+  window->SetProperty(kWindowShowAnimationDurationKey,
                       static_cast<int>(duration.ToInternalValue()));
 }
 
+void SetWindowHideAnimationDuration(aura::Window* window,
+                                    const base::TimeDelta& duration) {
+  window->SetProperty(kWindowHideAnimationDurationKey,
+                      static_cast<int>(duration.ToInternalValue()));
+}
+
+base::TimeDelta GetWindowShowAnimationDuration(
+    aura::Window* window,
+    const base::TimeDelta& default_duration) {
+  int duration = window->GetProperty(kWindowShowAnimationDurationKey);
+  return (duration == 0) ?
+      default_duration : base::TimeDelta::FromInternalValue(duration);
+}
+
+base::TimeDelta GetWindowHideAnimationDuration(
+    aura::Window* window,
+    const base::TimeDelta& default_duration) {
+  int duration = window->GetProperty(kWindowHideAnimationDurationKey);
+  return (duration == 0) ?
+      default_duration : base::TimeDelta::FromInternalValue(duration);
+}
+
 void SetWindowVisibilityAnimationVerticalPosition(aura::Window* window,
                                                   float position) {
   window->SetProperty(kWindowVisibilityAnimationVerticalPositionKey, position);