Remove unneeded ScopedLayerAnimationSettings::LockTransitionDuration()

ui/views/corewm/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 "ui/views/corewm/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 38 matching lines @@
 
 namespace views {
 namespace corewm {
 namespace {
 const float kWindowAnimation_Vertical_TranslateY = 15.f;
 }  // namespace
 
 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);
 DEFINE_WINDOW_PROPERTY_KEY(float,
                            kWindowVisibilityAnimationVerticalPositionKey,
                            kWindowAnimation_Vertical_TranslateY);
 
 namespace {
 
+const int kDefaultAnimationDurationMS = 200;
 const int kDefaultAnimationDurationForMenuMS = 150;
 
 const float kWindowAnimation_HideOpacity = 0.f;
 const float kWindowAnimation_ShowOpacity = 1.f;
 const float kWindowAnimation_TranslateFactor = 0.5f;
 const float kWindowAnimation_ScaleFactor = .95f;
 
 const int kWindowAnimation_Rotate_DurationMS = 180;
 const int kWindowAnimation_Rotate_OpacityDurationPercent = 90;
 const float kWindowAnimation_Rotate_TranslateY = -20.f;
 const float kWindowAnimation_Rotate_PerspectiveDepth = 500.f;
 const float kWindowAnimation_Rotate_DegreesX = 5.f;
 const float kWindowAnimation_Rotate_ScaleFactor = .99f;
 
 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.
 // TODO(beng): redundant/fold into method on public api?
 int GetWindowVisibilityAnimationType(aura::Window* window) {
   int type = window->GetProperty(kWindowVisibilityAnimationTypeKey);
   if (type == WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT) {
     return (window->type() == ui::wm::WINDOW_TYPE_MENU ||
             window->type() == ui::wm::WINDOW_TYPE_TOOLTIP)
                ? WINDOW_VISIBILITY_ANIMATION_TYPE_FADE
@@ skipping 143 matching lines @@
 
   AugmentWindowSize(window, end_transform);
 
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   window->layer()->SetTransform(start_transform);
   window->layer()->SetVisible(true);
 
   {
     // 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);
   }
 }
 
 // Hides a window using an animation, animating its opacity from 1.f to 0.f,
 // its visibility to false, and its transform to |end_transform|.
 void AnimateHideWindowCommon(aura::Window* window,
                              const gfx::Transform& end_transform) {
   AugmentWindowSize(window, 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));
-
-  base::TimeDelta duration = GetWindowVisibilityAnimationDuration(window);
-  if (duration.ToInternalValue() > 0)
-    settings.SetTransitionDuration(duration);
+  settings.AddObserver(CreateHidingWindowAnimationObserver(window));
+  base::TimeDelta duration = GetWindowHideAnimationDuration(window,
+      GetDefaultWindowVisibilityAnimationDuration(window));
+  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(),
@@ skipping 72 matching lines @@
       base::TimeDelta::FromMilliseconds(
         kWindowAnimation_Bounce_DurationMS *
             (100 - 2 * kWindowAnimation_Bounce_GrowShrinkDurationPercent) /
             100)));
   sequence->AddElement(CreateGrowShrinkElement(window, false));
   window->layer()->GetAnimator()->StartAnimation(sequence.release());
 }
 
 void AddLayerAnimationsForRotate(aura::Window* window, bool show) {
   window->layer()->set_delegate(window);
-  if (show)
+  if (show) {
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
+    window->layer()->SetVisible(true);
+  }
 
-  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) {
-    new HidingWindowAnimationObserver(window);
+    settings.AddObserver(CreateHidingWindowAnimationObserver(window));
     window->layer()->GetAnimator()->SchedulePauseForProperties(
         duration * (100 - kWindowAnimation_Rotate_OpacityDurationPercent) / 100,
         ui::LayerAnimationElement::OPACITY);
+    window->layer()->SetVisible(false);
   }
   scoped_ptr<ui::LayerAnimationElement> opacity(
       ui::LayerAnimationElement::CreateOpacityElement(
           show ? kWindowAnimation_ShowOpacity : kWindowAnimation_HideOpacity,
           duration * kWindowAnimation_Rotate_OpacityDurationPercent / 100));
   opacity->set_tween_type(gfx::Tween::EASE_IN_OUT);
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(opacity.release()));
 
   float xcenter = window->bounds().width() * 0.5;
@@ skipping 121 matching lines @@
 }
 
 bool HasWindowVisibilityAnimationTransition(
     aura::Window* window,
     WindowVisibilityAnimationTransition transition) {
   WindowVisibilityAnimationTransition prop = window->GetProperty(
       kWindowVisibilityAnimationTransitionKey);
   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);
 }
 
 ui::ImplicitAnimationObserver* CreateHidingWindowAnimationObserver(
     aura::Window* window) {
   return new HidingWindowAnimationObserver(window);
 }
 
@@ skipping 20 matching lines @@
 
 bool WindowAnimationsDisabled(aura::Window* window) {
   return (window &&
           window->GetProperty(aura::client::kAnimationsDisabledKey)) ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWindowAnimationsDisabled);
 }
 
 }  // namespace corewm
 }  // namespace views