Remove unneeded ScopedLayerAnimationSettings::LockTransitionDuration()

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 53 matching lines @@
 const float kLayerScaleBelowSize = .9f;
 
 int64 Round64(float f) {
   return static_cast<int64>(f + 0.5f);
 }
 
 }  // namespace
 
 const int kCrossFadeDurationMS = 200;
 
-void AddLayerAnimationsForMinimize(aura::Window* window, bool show) {
+void AddLayerAnimationsForMinimize(aura::Window* window,
+                                   const base::TimeDelta& duration,
+                                   bool show) {
   // Recalculate the transform at restore time since the launcher item may have
   // moved while the window was minimized.
   gfx::Rect bounds = window->bounds();
   gfx::Rect target_bounds = GetMinimizeAnimationTargetBoundsInScreen(window);
   target_bounds =
       ScreenAsh::ConvertRectFromScreen(window->parent(), target_bounds);
 
   float scale_x = static_cast<float>(target_bounds.width()) / bounds.width();
   float scale_y = static_cast<float>(target_bounds.height()) / bounds.height();
 
@@ skipping 13 matching lines @@
   scoped_ptr<ui::InterpolatedTransform> rotation_about_pivot(
       new ui::InterpolatedTransformAboutPivot(
           gfx::Point(bounds.width() * 0.5, bounds.height() * 0.5),
           rotation.release()));
 
   scale->SetChild(translation.release());
   rotation_about_pivot->SetChild(scale.release());
 
   rotation_about_pivot->SetReversed(show);
 
-  base::TimeDelta duration = window->layer()->GetAnimator()->
-      GetTransitionDuration();
-
   scoped_ptr<ui::LayerAnimationElement> transition(
       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
           rotation_about_pivot.release(), duration));
 
   transition->set_tween_type(
       show ? gfx::Tween::EASE_IN : gfx::Tween::EASE_IN_OUT);
 
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(transition.release()));
 
   // When hiding a window, turn off blending until the animation is 3 / 4 done
   // to save bandwidth and reduce jank.
   if (!show) {
     window->layer()->GetAnimator()->SchedulePauseForProperties(
         (duration * 3) / 4, ui::LayerAnimationElement::OPACITY, -1);
   }
 
   // Fade in and out quickly when the window is small to reduce jank.
   float opacity = show ? 1.0f : 0.0f;
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateOpacityElement(
               opacity, duration / 4)));
 }
 
 void AnimateShowWindow_Minimize(aura::Window* window) {
   window->layer()->set_delegate(window);
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
-      kLayerAnimationsForMinimizeDurationMS);
+  base::TimeDelta duration = views::corewm::GetWindowShowAnimationDuration(
+      window,
+      base::TimeDelta::FromMilliseconds(kLayerAnimationsForMinimizeDurationMS));

[varkha, 2014/01/02 22:26:41]

Shouldn't this use GetDefaultWindowVisibilityAnimationDuration(window) now?

[pkotwicz, 2014/01/02 22:45:51]

The default animation durations are different for each animation type.
views/corewm/window_animations.cc knows nothing about
ash/wm/window_animations.cc I could write a version of
GetDefaultWindowVisibilityAnimationDuration*( which handles the animations in
ash/wm/window_animations.cc but I do not think that doing this is particularly
useful.

[varkha, 2014/01/03 03:47:48]

Doesn't GetDefaultWindowVisibilityAnimationDuration currently return 200 (same
as kLayerAnimationsForMinimizeDurationMS) - forgetting about menu window type
for a second?

[pkotwicz, 2014/01/03 04:15:40]

But kBrightnessGrayscaleFadeDurationMs != 200

[varkha, 2014/01/03 04:39:19]

True, but I am not suggesting changing line 187, only here and in hide where you
seem to be using a 200ms constant.

[varkha, 2014/01/03 05:40:55]

I agree that this may be an overkill at this stage and the constants are not
necessarily same. Let's keep ash constants separate for now.

   settings.SetTransitionDuration(duration);
-  AddLayerAnimationsForMinimize(window, true);
+  AddLayerAnimationsForMinimize(window, duration, true);
 
   // Now that the window has been restored, we need to clear its animation style
   // to default so that normal animation applies.
   views::corewm::SetWindowVisibilityAnimationType(
       window, views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
 }
 
 void AnimateHideWindow_Minimize(aura::Window* window) {
   window->layer()->set_delegate(NULL);
 
   // Property sets within this scope will be implicitly animated.
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
-      kLayerAnimationsForMinimizeDurationMS);
+  base::TimeDelta duration = views::corewm::GetWindowHideAnimationDuration(
+      window,
+      base::TimeDelta::FromMilliseconds(kLayerAnimationsForMinimizeDurationMS));

[varkha, 2014/01/02 22:26:41]

Shouldn't this use GetDefaultWindowVisibilityAnimationDuration(window) now?

   settings.SetTransitionDuration(duration);
   settings.AddObserver(
       views::corewm::CreateHidingWindowAnimationObserver(window));
   window->layer()->SetVisible(false);
 
-  AddLayerAnimationsForMinimize(window, false);
+  AddLayerAnimationsForMinimize(window, duration, false);
 }
 
 void AnimateShowHideWindowCommon_BrightnessGrayscale(aura::Window* window,
                                                      bool show) {
   window->layer()->set_delegate(window);
 
   float start_value, end_value;
   if (show) {
     start_value = kWindowAnimation_HideBrightnessGrayscale;
     end_value = kWindowAnimation_ShowBrightnessGrayscale;
   } else {
     start_value = kWindowAnimation_ShowBrightnessGrayscale;
     end_value = kWindowAnimation_HideBrightnessGrayscale;
   }
 
   window->layer()->SetLayerBrightness(start_value);
   window->layer()->SetLayerGrayscale(start_value);
   if (show) {
     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
     window->layer()->SetVisible(true);
   }
 
-  base::TimeDelta duration =
+  base::TimeDelta default_duration =
       base::TimeDelta::FromMilliseconds(kBrightnessGrayscaleFadeDurationMs);
+  base::TimeDelta duration = show ?
+      views::corewm::GetWindowShowAnimationDuration(window, default_duration) :
+      views::corewm::GetWindowHideAnimationDuration(window, default_duration);
 
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   settings.SetTransitionDuration(duration);
   if (!show) {
     settings.AddObserver(
         views::corewm::CreateHidingWindowAnimationObserver(window));
   }
 
   window->layer()->GetAnimator()->
       ScheduleTogether(
@@ skipping 343 matching lines @@
   }
 
   // Assume the shelf is overflowed, zoom off to the bottom right of the
   // work area.
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(window).work_area();
   return gfx::Rect(work_area.right(), work_area.bottom(), 0, 0);
 }
 
 }  // namespace ash