Polish lock animation - launcher should do a fade out.

ash/wm/power_button_controller.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/power_button_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
@@ skipping 151 matching lines @@
 // Fills |containers| with the containers described by |container_mask|.
 void GetContainers(int container_mask, aura::Window::Windows* containers) {
   aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
   containers->clear();
 
   if (container_mask & PowerButtonController::DESKTOP_BACKGROUND) {
     containers->push_back(Shell::GetContainer(
         root_window,
         internal::kShellWindowId_DesktopBackgroundContainer));
   }
+  if (container_mask & PowerButtonController::LAUNCHER) {
+    containers->push_back(Shell::GetContainer(
+        root_window,
+        internal::kShellWindowId_LauncherContainer));
+  }
   if (container_mask & PowerButtonController::NON_LOCK_SCREEN_CONTAINERS) {
     containers->push_back(Shell::GetContainer(
         root_window,
         internal::kShellWindowId_NonLockScreenContainersContainer));
   }
   if (container_mask & PowerButtonController::LOCK_SCREEN_BACKGROUND) {
     containers->push_back(Shell::GetContainer(
         root_window,
         internal::kShellWindowId_LockScreenBackgroundContainer));
   }
@@ skipping 94 matching lines @@
 }
 
 gfx::Rect PowerButtonController::TestApi::GetBlackLayerBounds() const {
   ui::Layer* layer = controller_->black_layer_.get();
   return layer ? layer->bounds() : gfx::Rect();
 }
 
 // static
 int PowerButtonController::GetAllContainersMask() {
   return PowerButtonController::DESKTOP_BACKGROUND |
+         PowerButtonController::LAUNCHER |
          PowerButtonController::NON_LOCK_SCREEN_CONTAINERS |
          GetAllLockScreenContainersMask();
 }
 
 // static
 int PowerButtonController::GetAllLockScreenContainersMask() {
   return PowerButtonController::LOCK_SCREEN_BACKGROUND |
          PowerButtonController::LOCK_SCREEN_CONTAINERS |
          PowerButtonController::LOCK_SCREEN_RELATED_CONTAINERS;
 }
@@ skipping 50 matching lines @@
     lock_fail_timer_.Stop();
 
     if (!has_legacy_power_button_ && power_button_down_) {
       lock_to_shutdown_timer_.Stop();
       lock_to_shutdown_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
           this, &PowerButtonController::OnLockToShutdownTimeout);
     }
   } else {
-    StartAnimation(DESKTOP_BACKGROUND | NON_LOCK_SCREEN_CONTAINERS,
+    StartAnimation(DESKTOP_BACKGROUND | LAUNCHER | NON_LOCK_SCREEN_CONTAINERS,
                    ANIMATION_RESTORE);
     HideBlackLayer();
   }
 }
 
 void PowerButtonController::OnScreenBrightnessChanged(double percent) {
   screen_is_off_ = percent <= 0.001;
 }
 
 void PowerButtonController::OnStartingLock() {
   if (shutting_down_ || login_status_ == user::LOGGED_IN_LOCKED)
     return;
 
   // Ensure that the black layer is visible -- if the screen was locked via
   // the wrench menu, we won't have already shown the black background
   // as part of the slow-close animation.
   ShowBlackLayer();
 
+  StartAnimation(LAUNCHER, ANIMATION_HIDE);
+
   StartAnimation(NON_LOCK_SCREEN_CONTAINERS, ANIMATION_FAST_CLOSE);
 
   // Hide the screen locker containers so we can make them fade in later.
   StartAnimation(LOCK_SCREEN_CONTAINERS, ANIMATION_HIDE);
 }
 
 void PowerButtonController::OnPowerButtonEvent(
     bool down, const base::TimeTicks& timestamp) {
   power_button_down_ = down;
 
@@ skipping 118 matching lines @@
   delegate_->RequestLockScreen();
   lock_fail_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLockFailTimeoutMs),
       this, &PowerButtonController::OnLockFailTimeout);
 }
 
 void PowerButtonController::OnLockFailTimeout() {
   DCHECK_NE(login_status_, user::LOGGED_IN_LOCKED);
   LOG(ERROR) << "Screen lock request timed out";
-  StartAnimation(NON_LOCK_SCREEN_CONTAINERS, ANIMATION_RESTORE);
+  StartAnimation(LAUNCHER | NON_LOCK_SCREEN_CONTAINERS, ANIMATION_RESTORE);
   HideBlackLayer();
 }
 
 void PowerButtonController::OnLockToShutdownTimeout() {
   DCHECK_EQ(login_status_, user::LOGGED_IN_LOCKED);
   StartShutdownTimer();
 }
 
 void PowerButtonController::OnShutdownTimeout() {
   if (!shutting_down_)
@@ skipping 29 matching lines @@
   shutting_down_ = true;
 
   Shell* shell = ash::Shell::GetInstance();
   shell->cursor_manager()->ShowCursor(false);
 
   ShowBlackLayer();
   if (login_status_ != user::LOGGED_IN_NONE) {
     // Hide the other containers before starting the animation.
     // ANIMATION_FAST_CLOSE will make the screen locker windows partially
     // transparent, and we don't want the other windows to show through.
-    StartAnimation(NON_LOCK_SCREEN_CONTAINERS, ANIMATION_HIDE);
+    StartAnimation(LAUNCHER | NON_LOCK_SCREEN_CONTAINERS, ANIMATION_HIDE);
     StartAnimation(GetAllLockScreenContainersMask(), ANIMATION_FAST_CLOSE);
   } else {
     StartAnimation(GetAllContainersMask(), ANIMATION_FAST_CLOSE);
   }
 
   real_shutdown_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(
           kFastCloseAnimMs + kShutdownRequestDelayMs),
       this, &PowerButtonController::OnRealShutdownTimeout);
@@ skipping 13 matching lines @@
     root_layer->StackAtBottom(black_layer_.get());
   }
   black_layer_->SetVisible(true);
 }
 
 void PowerButtonController::HideBlackLayer() {
   black_layer_.reset();
 }
 
 }  // namespace ash