ash: Fix abort-shutdown animation.

ash/wm/session_state_animator.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/session_state_animator.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_animations.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 228 matching lines @@
 
   TransformWindowToBaseState(window, duration, observer);
 }
 
 // Starts grayscale/brightness animation for |window| over |duration|. Target
 // value for both grayscale and brightness are specified by |target|.
 void StartGrayscaleBrightnessAnimationForWindow(
     aura::Window* window,
     float target,
     base::TimeDelta duration,
+    ui::Tween::Type tween_type,
     ui::LayerAnimationObserver* observer) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
 
   scoped_ptr<ui::LayerAnimationSequence> brightness_sequence(
       new ui::LayerAnimationSequence());
   scoped_ptr<ui::LayerAnimationSequence> grayscale_sequence(
       new ui::LayerAnimationSequence());
 
   scoped_ptr<ui::LayerAnimationElement> brightness_element(
       ui::LayerAnimationElement::CreateBrightnessElement(
           target, duration));
-  brightness_element->set_tween_type(ui::Tween::EASE_IN);
+  brightness_element->set_tween_type(tween_type);
   brightness_sequence->AddElement(brightness_element.release());
 
   scoped_ptr<ui::LayerAnimationElement> grayscale_element(
       ui::LayerAnimationElement::CreateGrayscaleElement(
           target, duration));
-  grayscale_element->set_tween_type(ui::Tween::EASE_IN);
+  grayscale_element->set_tween_type(tween_type);
   grayscale_sequence->AddElement(grayscale_element.release());
 
   std::vector<ui::LayerAnimationSequence*> animations;
   animations.push_back(brightness_sequence.release());
   animations.push_back(grayscale_sequence.release());
 
   if (observer)
     animations[0]->AddObserver(observer);
 
   animator->set_preemption_strategy(
@@ skipping 155 matching lines @@
       return base::TimeDelta::FromMilliseconds(400);
     case ANIMATION_SPEED_REVERT:
       return base::TimeDelta::FromMilliseconds(150);
     case ANIMATION_SPEED_FAST:
       return base::TimeDelta::FromMilliseconds(150);
     case ANIMATION_SPEED_SHOW_LOCK_SCREEN:
       return base::TimeDelta::FromMilliseconds(200);
     case ANIMATION_SPEED_MOVE_WINDOWS:
       return base::TimeDelta::FromMilliseconds(350);
     case ANIMATION_SPEED_UNDO_MOVE_WINDOWS:
-      return base::TimeDelta::FromMilliseconds(500);
+      return base::TimeDelta::FromMilliseconds(350);
     case ANIMATION_SPEED_SHUTDOWN:
       return base::TimeDelta::FromMilliseconds(1000);
     case ANIMATION_SPEED_REVERT_SHUTDOWN:
-      return base::TimeDelta::FromMilliseconds(1500);
+      return base::TimeDelta::FromMilliseconds(500);
   }
   // Satisfy compilers that do not understand that we will return from switch
   // above anyway.
   DCHECK(false) << "Unhandled animation speed " << speed;
   return base::TimeDelta();
 }
 
 // Fills |containers| with the containers described by |container_mask|.
 void SessionStateAnimator::GetContainers(int container_mask,
                                          aura::Window::Windows* containers) {
@@ skipping 139 matching lines @@
           window, kPartialFadeRatio, duration, observer);
       break;
     case ANIMATION_UNDO_PARTIAL_FADE_IN:
       StartPartialFadeAnimation(window, 0.0, duration, observer);
       break;
     case ANIMATION_FULL_FADE_IN:
       StartPartialFadeAnimation(window, 1.0, duration, observer);
       break;
     case ANIMATION_GRAYSCALE_BRIGHTNESS:
       StartGrayscaleBrightnessAnimationForWindow(
-          window, 1.0, duration, observer);
+          window, 1.0, duration, ui::Tween::EASE_IN, observer);
       break;
     case ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS:
       StartGrayscaleBrightnessAnimationForWindow(
-          window, 0.0, duration, observer);
+          window, 0.0, duration, ui::Tween::EASE_IN_OUT, observer);
       break;
   }
 }
 
 void SessionStateAnimator::CreateForeground() {
   if (foreground_.get())
     return;
   aura::Window* window = Shell::GetContainer(
       Shell::GetPrimaryRootWindow(),
       internal::kShellWindowId_PowerButtonAnimationContainer);
   HideWindowImmediately(window, NULL);
   foreground_.reset(
       new ColoredWindowController(window, "SessionStateAnimatorForeground"));
   foreground_->SetColor(SK_ColorWHITE);
   foreground_->GetWidget()->Show();
 }
 
 void SessionStateAnimator::DropForeground() {
   foreground_.reset();
 }
 
 }  // namespace internal
 }  // namespace ash