ash: Clean up system background layer.

ash/wm/session_state_controller_impl.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_controller_impl.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
@@ skipping 35 matching lines @@
 }
 
 void SessionStateControllerImpl::OnAppTerminating() {
   // If we hear that Chrome is exiting but didn't request it ourselves, all we
   // can really hope for is that we'll have time to clear the screen.
   if (!shutting_down_) {
     shutting_down_ = true;
     Shell* shell = ash::Shell::GetInstance();
     shell->env_filter()->set_cursor_hidden_by_filter(false);
     shell->cursor_manager()->ShowCursor(false);
-    animator_->ShowBlackLayer();
     animator_->StartAnimation(
         internal::SessionStateAnimator::kAllContainersMask,
         internal::SessionStateAnimator::ANIMATION_HIDE);
   }
 }
 
 void SessionStateControllerImpl::OnLockStateChanged(bool locked) {
   if (shutting_down_ || (IsLocked()) == locked)
     return;
 
   system_is_locked_ = locked;
 
   if (locked) {
     animator_->StartAnimation(
         internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
         internal::SessionStateAnimator::ANIMATION_FADE_IN);
     lock_timer_.Stop();
     lock_fail_timer_.Stop();
 
     if (shutdown_after_lock_) {
       shutdown_after_lock_ = false;
       StartLockToShutdownTimer();
     }
   } else {
     animator_->StartAnimation(
         internal::SessionStateAnimator::DESKTOP_BACKGROUND |
         internal::SessionStateAnimator::LAUNCHER |
         internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
         internal::SessionStateAnimator::ANIMATION_RESTORE);
-    animator_->DropBlackLayer();
   }
 }
 
 void SessionStateControllerImpl::OnStartingLock() {
   if (shutting_down_ || system_is_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.
-  animator_->ShowBlackLayer();
-
   animator_->StartAnimation(
       internal::SessionStateAnimator::LAUNCHER,
       internal::SessionStateAnimator::ANIMATION_HIDE);
 
   animator_->StartAnimation(
       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_FULL_CLOSE);
 
   // Hide the screen locker containers so we can make them fade in later.
   animator_->StartAnimation(
       internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_HIDE);
 }
 
 void SessionStateControllerImpl::StartLockAnimationAndLockImmediately() {
-  animator_->ShowBlackLayer();
   animator_->StartAnimation(
       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE);
   OnLockTimeout();
 }
 
 void SessionStateControllerImpl::StartLockAnimation(bool shutdown_after_lock) {
   shutdown_after_lock_ = shutdown_after_lock;
 
-  animator_->ShowBlackLayer();
   animator_->StartAnimation(
       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE);
   StartLockTimer();
 }
 
 void SessionStateControllerImpl::StartShutdownAnimation() {
-  animator_->ShowBlackLayer();
   animator_->StartAnimation(
       internal::SessionStateAnimator::kAllContainersMask,
       internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE);
 
   StartPreShutdownAnimationTimer();
 }
 
 bool SessionStateControllerImpl::IsEligibleForLock() {
   return IsLoggedInAsNonGuest() && !IsLocked() && !LockRequested();
 }
@@ skipping 14 matching lines @@
   return lock_timer_.IsRunning();
 }
 
 void SessionStateControllerImpl::CancelLockAnimation() {
   if (!CanCancelLockAnimation())
     return;
   shutdown_after_lock_ = false;
   animator_->StartAnimation(
       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE);
-  animator_->ScheduleDropBlackLayer();
   lock_timer_.Stop();
 }
 
 bool SessionStateControllerImpl::CanCancelShutdownAnimation() {
   return pre_shutdown_timer_.IsRunning() ||
          shutdown_after_lock_ ||
          lock_to_shutdown_timer_.IsRunning();
 }
 
 void SessionStateControllerImpl::CancelShutdownAnimation() {
@@ skipping 10 matching lines @@
 
   if (system_is_locked_) {
     // If we've already started shutdown transition at lock screen
     // desktop background needs to be restored immediately.
     animator_->StartAnimation(
         internal::SessionStateAnimator::DESKTOP_BACKGROUND,
         internal::SessionStateAnimator::ANIMATION_RESTORE);
     animator_->StartAnimation(
         internal::SessionStateAnimator::kAllLockScreenContainersMask,
         internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE);
-    animator_->ScheduleDropBlackLayer();
   } else {
     animator_->StartAnimation(
         internal::SessionStateAnimator::kAllContainersMask,
         internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE);
-    animator_->ScheduleDropBlackLayer();
   }
   pre_shutdown_timer_.Stop();
 }
 
 void SessionStateControllerImpl::RequestShutdown() {
   if (!shutting_down_)
-    animator_->ShowBlackLayer();
     RequestShutdownImpl();
 }
 
 void SessionStateControllerImpl::RequestShutdownImpl() {
   DCHECK(!shutting_down_);
   shutting_down_ = true;
 
   Shell* shell = ash::Shell::GetInstance();
   shell->env_filter()->set_cursor_hidden_by_filter(false);
   shell->cursor_manager()->ShowCursor(false);
 
-  animator_->ShowBlackLayer();
   if (login_status_ != user::LOGGED_IN_NONE) {
     // Hide the other containers before starting the animation.
     // ANIMATION_FULL_CLOSE will make the screen locker windows partially
     // transparent, and we don't want the other windows to show through.
     animator_->StartAnimation(
         internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
         internal::SessionStateAnimator::LAUNCHER,
         internal::SessionStateAnimator::ANIMATION_HIDE);
     animator_->StartAnimation(
         internal::SessionStateAnimator::kAllLockScreenContainersMask,
@@ skipping 33 matching lines @@
       this, &SessionStateControllerImpl::OnLockFailTimeout);
 }
 
 void SessionStateControllerImpl::OnLockFailTimeout() {
   DCHECK(!system_is_locked_);
   // Undo lock animation.
   animator_->StartAnimation(
       internal::SessionStateAnimator::LAUNCHER |
       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_RESTORE);
-  animator_->DropBlackLayer();
 }
 
 void SessionStateControllerImpl::StartLockToShutdownTimer() {
   shutdown_after_lock_ = false;
   lock_to_shutdown_timer_.Stop();
   lock_to_shutdown_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
       this, &SessionStateControllerImpl::OnLockToShutdownTimeout);
 }
@@ skipping 33 matching lines @@
     if (delegate) {
       delegate->Exit();
       return;
     }
   }
 #endif
   delegate_->RequestShutdown();
 }
 
 }  // namespace ash