ash: Remove old lock animation implementation.

ash/wm/lock_state_controller_impl2.cc

Index: ash/wm/lock_state_controller_impl2.cc
diff --git a/ash/wm/lock_state_controller_impl2.cc b/ash/wm/lock_state_controller_impl2.cc
deleted file mode 100644
index dae62c4a0cd3bf455867ca49b2a3b0208de0b792..0000000000000000000000000000000000000000
--- a/ash/wm/lock_state_controller_impl2.cc
+++ /dev/null
@@ -1,643 +0,0 @@
-// Copyright 2013 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/lock_state_controller_impl2.h"
-
-#include "ash/ash_switches.h"
-#include "ash/cancel_mode.h"
-#include "ash/shell.h"
-#include "ash/shell_delegate.h"
-#include "ash/shell_window_ids.h"
-#include "ash/wm/session_state_animator.h"
-#include "base/bind_helpers.h"
-#include "base/command_line.h"
-#include "base/sys_info.h"
-#include "base/timer/timer.h"
-#include "ui/aura/root_window.h"
-#include "ui/compositor/layer_animation_sequence.h"
-#include "ui/compositor/scoped_layer_animation_settings.h"
-#include "ui/views/corewm/compound_event_filter.h"
-
-namespace ash {
-
-namespace {
-
-aura::Window* GetBackground() {
-  aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
-  return Shell::GetContainer(root_window,
-      internal::kShellWindowId_DesktopBackgroundContainer);
-}
-
-bool IsBackgroundHidden() {
-  return !GetBackground()->IsVisible();
-}
-
-void ShowBackground() {
-  ui::ScopedLayerAnimationSettings settings(
-      GetBackground()->layer()->GetAnimator());
-  settings.SetTransitionDuration(base::TimeDelta());
-  GetBackground()->Show();
-}
-
-void HideBackground() {
-  ui::ScopedLayerAnimationSettings settings(
-      GetBackground()->layer()->GetAnimator());
-  settings.SetTransitionDuration(base::TimeDelta());
-  GetBackground()->Hide();
-}
-
-// This observer is intended to use in cases when some action has to be taken
-// once some animation successfully completes (i.e. it was not aborted).
-// Observer will count a number of sequences it is attached to, and a number of
-// finished sequences (either Ended or Aborted). Once these two numbers are
-// equal, observer will delete itself, calling callback passed to constructor if
-// there were no aborted animations.
-// This way it can be either used to wait for some animation to be finished in
-// multiple layers, to wait once a sequence of animations is finished in one
-// layer or the mixture of both.
-class AnimationFinishedObserver : public ui::LayerAnimationObserver {
- public:
-  explicit AnimationFinishedObserver(base::Closure &callback)
-      : callback_(callback),
-        sequences_attached_(0),
-        sequences_completed_(0),
-        paused_(false) {
-  }
-
-  // Pauses observer: no checks will be made while paused. It can be used when
-  // a sequence has some immediate animations in the beginning, and for
-  // animations that can be tested with flag that makes all animations
-  // immediate.
-  void Pause() {
-    paused_ = true;
-  }
-
-  // Unpauses observer. It does a check and calls callback if conditions are
-  // met.
-  void Unpause() {
-    if (!paused_)
-      return;
-    paused_ = false;
-    if (sequences_completed_ == sequences_attached_) {
-      callback_.Run();
-      delete this;
-    }
-  }
-
- private:
-  virtual ~AnimationFinishedObserver() {
-  }
-
-  // LayerAnimationObserver implementation
-  virtual void OnLayerAnimationEnded(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {
-    sequences_completed_++;
-    if ((sequences_completed_ == sequences_attached_) && !paused_) {
-      callback_.Run();
-      delete this;
-    }
-  }
-
-  virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {
-    sequences_completed_++;
-    if ((sequences_completed_ == sequences_attached_) && !paused_)
-      delete this;
-  }
-
-  virtual void OnLayerAnimationScheduled(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {
-  }
-
-  virtual void OnAttachedToSequence(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {
-    LayerAnimationObserver::OnAttachedToSequence(sequence);
-    sequences_attached_++;
-  }
-
-  // Callback to be called.
-  base::Closure callback_;
-
-  // Number of sequences this observer was attached to.
-  int sequences_attached_;
-
-  // Number of sequences either ended or aborted.
-  int sequences_completed_;
-
-  bool paused_;
-
-  DISALLOW_COPY_AND_ASSIGN(AnimationFinishedObserver);
-};
-
-} // namespace
-
-LockStateControllerImpl2::TestApi::TestApi(
-    LockStateControllerImpl2* controller)
-    : controller_(controller) {
-}
-
-LockStateControllerImpl2::TestApi::~TestApi() {
-}
-
-LockStateControllerImpl2::LockStateControllerImpl2()
-    : login_status_(user::LOGGED_IN_NONE),
-      system_is_locked_(false),
-      shutting_down_(false),
-      shutdown_after_lock_(false),
-      animating_lock_(false),
-      can_cancel_lock_animation_(false) {
-  Shell::GetPrimaryRootWindow()->AddRootWindowObserver(this);
-}
-
-LockStateControllerImpl2::~LockStateControllerImpl2() {
-  Shell::GetPrimaryRootWindow()->RemoveRootWindowObserver(this);
-}
-
-void LockStateControllerImpl2::OnLoginStateChanged(
-    user::LoginStatus status) {
-  if (status != user::LOGGED_IN_LOCKED)
-    login_status_ = status;
-  system_is_locked_ = (status == user::LOGGED_IN_LOCKED);
-}
-
-void LockStateControllerImpl2::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.
-  // This is also the case when the user signs off.
-  if (!shutting_down_) {
-    shutting_down_ = true;
-    Shell* shell = ash::Shell::GetInstance();
-    shell->env_filter()->set_cursor_hidden_by_filter(false);
-    shell->cursor_manager()->HideCursor();
-    animator_->StartAnimation(
-        internal::SessionStateAnimator::kAllContainersMask,
-        internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
-        internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
-  }
-}
-
-void LockStateControllerImpl2::OnLockStateChanged(bool locked) {
-  if (shutting_down_ || (system_is_locked_ == locked))
-    return;
-
-  system_is_locked_ = locked;
-
-  if (locked) {
-    StartPostLockAnimation();
-    lock_fail_timer_.Stop();
-  } else {
-    StartUnlockAnimationAfterUIDestroyed();
-  }
-}
-
-void LockStateControllerImpl2::SetLockScreenDisplayedCallback(
-    base::Closure& callback) {
-  lock_screen_displayed_callback_ = callback;
-}
-
-void LockStateControllerImpl2::OnStartingLock() {
-  if (shutting_down_ || system_is_locked_)
-    return;
-  if (animating_lock_)
-    return;
-  StartImmediatePreLockAnimation(false /* request_lock_on_completion */);
-}
-
-void LockStateControllerImpl2::StartLockAnimationAndLockImmediately() {
-  if (animating_lock_)
-    return;
-  StartImmediatePreLockAnimation(true /* request_lock_on_completion */);
-}
-
-void LockStateControllerImpl2::StartLockAnimation(
-    bool shutdown_after_lock) {
-  if (animating_lock_)
-    return;
-  shutdown_after_lock_ = shutdown_after_lock;
-  can_cancel_lock_animation_ = true;
-
-  StartCancellablePreLockAnimation();
-}
-
-bool LockStateControllerImpl2::LockRequested() {
-  return lock_fail_timer_.IsRunning();
-}
-
-bool LockStateControllerImpl2::ShutdownRequested() {
-  return shutting_down_;
-}
-
-bool LockStateControllerImpl2::CanCancelLockAnimation() {
-  return can_cancel_lock_animation_;
-}
-
-void LockStateControllerImpl2::CancelLockAnimation() {
-  if (!CanCancelLockAnimation())
-    return;
-  shutdown_after_lock_ = false;
-  animating_lock_ = false;
-  CancelPreLockAnimation();
-}
-
-bool LockStateControllerImpl2::CanCancelShutdownAnimation() {
-  return pre_shutdown_timer_.IsRunning() ||
-         shutdown_after_lock_ ||
-         lock_to_shutdown_timer_.IsRunning();
-}
-
-void LockStateControllerImpl2::StartShutdownAnimation() {
-  StartCancellableShutdownAnimation();
-}
-
-void LockStateControllerImpl2::CancelShutdownAnimation() {
-  if (!CanCancelShutdownAnimation())
-    return;
-  if (lock_to_shutdown_timer_.IsRunning()) {
-    lock_to_shutdown_timer_.Stop();
-    return;
-  }
-  if (shutdown_after_lock_) {
-    shutdown_after_lock_ = false;
-    return;
-  }
-
-  animator_->StartGlobalAnimation(
-      internal::SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS,
-      internal::SessionStateAnimator::ANIMATION_SPEED_REVERT_SHUTDOWN);
-  pre_shutdown_timer_.Stop();
-}
-
-void LockStateControllerImpl2::RequestShutdown() {
-  if (!shutting_down_)
-    RequestShutdownImpl();
-}
-
-void LockStateControllerImpl2::RequestShutdownImpl() {
-  DCHECK(!shutting_down_);
-  shutting_down_ = true;
-
-  Shell* shell = ash::Shell::GetInstance();
-  shell->env_filter()->set_cursor_hidden_by_filter(false);
-  shell->cursor_manager()->HideCursor();
-
-  StartShutdownAnimationImpl();
-}
-
-void LockStateControllerImpl2::OnRootWindowHostCloseRequested(
-                                                const aura::RootWindow*) {
-  Shell::GetInstance()->delegate()->Exit();
-}
-
-void LockStateControllerImpl2::OnLockFailTimeout() {
-  DCHECK(!system_is_locked_);
-  // Undo lock animation.
-  StartUnlockAnimationAfterUIDestroyed();
-}
-
-void LockStateControllerImpl2::StartLockToShutdownTimer() {
-  shutdown_after_lock_ = false;
-  lock_to_shutdown_timer_.Stop();
-  lock_to_shutdown_timer_.Start(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
-      this, &LockStateControllerImpl2::OnLockToShutdownTimeout);
-}
-
-void LockStateControllerImpl2::OnLockToShutdownTimeout() {
-  DCHECK(system_is_locked_);
-  StartCancellableShutdownAnimation();
-}
-
-void LockStateControllerImpl2::StartCancellableShutdownAnimation() {
-  Shell* shell = ash::Shell::GetInstance();
-  // Hide cursor, but let it reappear if the mouse moves.
-  shell->env_filter()->set_cursor_hidden_by_filter(true);
-  shell->cursor_manager()->HideCursor();
-
-  animator_->StartGlobalAnimation(
-      internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
-      internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
-  StartPreShutdownAnimationTimer();
-}
-
-void LockStateControllerImpl2::StartShutdownAnimationImpl() {
-  animator_->StartGlobalAnimation(
-      internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
-      internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
-  StartRealShutdownTimer(true);
-}
-
-void LockStateControllerImpl2::StartPreShutdownAnimationTimer() {
-  pre_shutdown_timer_.Stop();
-  pre_shutdown_timer_.Start(
-      FROM_HERE,
-      animator_->
-          GetDuration(internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN),
-      this,
-      &LockStateControllerImpl2::OnPreShutdownAnimationTimeout);
-}
-
-void LockStateControllerImpl2::OnPreShutdownAnimationTimeout() {
-  shutting_down_ = true;
-
-  Shell* shell = ash::Shell::GetInstance();
-  shell->env_filter()->set_cursor_hidden_by_filter(false);
-  shell->cursor_manager()->HideCursor();
-
-  StartRealShutdownTimer(false);
-}
-
-void LockStateControllerImpl2::StartRealShutdownTimer(
-    bool with_animation_time) {
-  base::TimeDelta duration =
-      base::TimeDelta::FromMilliseconds(kShutdownRequestDelayMs);
-  if (with_animation_time) {
-    duration += animator_->GetDuration(
-        internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
-  }
-  real_shutdown_timer_.Start(
-      FROM_HERE,
-      duration,
-      this,
-      &LockStateControllerImpl2::OnRealShutdownTimeout);
-}
-
-void LockStateControllerImpl2::OnRealShutdownTimeout() {
-  DCHECK(shutting_down_);
-#if defined(OS_CHROMEOS)
-  if (!base::SysInfo::IsRunningOnChromeOS()) {
-    ShellDelegate* delegate = Shell::GetInstance()->delegate();
-    if (delegate) {
-      delegate->Exit();
-      return;
-    }
-  }
-#endif
-  Shell::GetInstance()->delegate()->RecordUserMetricsAction(
-      UMA_ACCEL_SHUT_DOWN_POWER_BUTTON);
-  delegate_->RequestShutdown();
-}
-
-void LockStateControllerImpl2::OnLockScreenHide(
-  base::Callback<void(void)>& callback) {
-  StartUnlockAnimationBeforeUIDestroyed(callback);
-}
-
-void LockStateControllerImpl2::LockAnimationCancelled() {
-  can_cancel_lock_animation_ = false;
-  RestoreUnlockedProperties();
-}
-
-void LockStateControllerImpl2::PreLockAnimationFinished(
-    bool request_lock) {
-  can_cancel_lock_animation_ = false;
-
-  if (request_lock) {
-    Shell::GetInstance()->delegate()->RecordUserMetricsAction(
-        shutdown_after_lock_ ?
-        UMA_ACCEL_LOCK_SCREEN_POWER_BUTTON :
-        UMA_ACCEL_LOCK_SCREEN_LOCK_BUTTON);
-    delegate_->RequestLockScreen();
-  }
-
-  lock_fail_timer_.Start(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kLockFailTimeoutMs),
-      this,
-      &LockStateControllerImpl2::OnLockFailTimeout);
-}
-
-void LockStateControllerImpl2::PostLockAnimationFinished() {
-  animating_lock_ = false;
-
-  FOR_EACH_OBSERVER(LockStateObserver, observers_,
-      OnLockStateEvent(LockStateObserver::EVENT_LOCK_ANIMATION_FINISHED));
-  if (!lock_screen_displayed_callback_.is_null()) {
-    lock_screen_displayed_callback_.Run();
-    lock_screen_displayed_callback_.Reset();
-  }
-  if (shutdown_after_lock_) {
-    shutdown_after_lock_ = false;
-    StartLockToShutdownTimer();
-  }
-}
-
-void LockStateControllerImpl2::
-UnlockAnimationAfterUIDestroyedFinished() {
-  RestoreUnlockedProperties();
-}
-
-void LockStateControllerImpl2::StartImmediatePreLockAnimation(
-    bool request_lock_on_completion) {
-  animating_lock_ = true;
-
-  StoreUnlockedProperties();
-
-  base::Closure next_animation_starter =
-      base::Bind(&LockStateControllerImpl2::PreLockAnimationFinished,
-      base::Unretained(this), request_lock_on_completion);
-  AnimationFinishedObserver* observer =
-      new AnimationFinishedObserver(next_animation_starter);
-
-  observer->Pause();
-
-  animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_LIFT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      observer);
-  animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LAUNCHER,
-      internal::SessionStateAnimator::ANIMATION_FADE_OUT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      observer);
-  // Hide the screen locker containers so we can raise them later.
-  animator_->StartAnimation(
-      internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
-      internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
-  AnimateBackgroundAppearanceIfNecessary(
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      observer);
-
-  observer->Unpause();
-
-  DispatchCancelMode();
-  FOR_EACH_OBSERVER(LockStateObserver, observers_,
-      OnLockStateEvent(LockStateObserver::EVENT_LOCK_ANIMATION_STARTED));
-}
-
-void LockStateControllerImpl2::StartCancellablePreLockAnimation() {
-  animating_lock_ = true;
-  StoreUnlockedProperties();
-
-  base::Closure next_animation_starter =
-      base::Bind(&LockStateControllerImpl2::PreLockAnimationFinished,
-      base::Unretained(this), true /* request_lock */);
-  AnimationFinishedObserver* observer =
-      new AnimationFinishedObserver(next_animation_starter);
-
-  observer->Pause();
-
-  animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_LIFT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
-      observer);
-  animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LAUNCHER,
-      internal::SessionStateAnimator::ANIMATION_FADE_OUT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
-      observer);
-  // Hide the screen locker containers so we can raise them later.
-  animator_->StartAnimation(
-      internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
-      internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
-  AnimateBackgroundAppearanceIfNecessary(
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
-      observer);
-
-  DispatchCancelMode();
-  FOR_EACH_OBSERVER(LockStateObserver, observers_,
-      OnLockStateEvent(LockStateObserver::EVENT_PRELOCK_ANIMATION_STARTED));
-  observer->Unpause();
-}
-
-void LockStateControllerImpl2::CancelPreLockAnimation() {
-  base::Closure next_animation_starter =
-      base::Bind(&LockStateControllerImpl2::LockAnimationCancelled,
-      base::Unretained(this));
-  AnimationFinishedObserver* observer =
-      new AnimationFinishedObserver(next_animation_starter);
-
-  observer->Pause();
-
-  animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_UNDO_LIFT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
-      observer);
-  animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LAUNCHER,
-      internal::SessionStateAnimator::ANIMATION_FADE_IN,
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
-      observer);
-  AnimateBackgroundHidingIfNecessary(
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
-      observer);
-
-  observer->Unpause();
-}
-
-void LockStateControllerImpl2::StartPostLockAnimation() {
-  base::Closure next_animation_starter =
-      base::Bind(&LockStateControllerImpl2::PostLockAnimationFinished,
-      base::Unretained(this));
-
-  AnimationFinishedObserver* observer =
-      new AnimationFinishedObserver(next_animation_starter);
-
-  observer->Pause();
-  animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      observer);
-  observer->Unpause();
-}
-
-void LockStateControllerImpl2::StartUnlockAnimationBeforeUIDestroyed(
-    base::Closure& callback) {
-  animator_->StartAnimationWithCallback(
-      internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_LIFT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      callback);
-}
-
-void LockStateControllerImpl2::StartUnlockAnimationAfterUIDestroyed() {
-  base::Closure next_animation_starter =
-      base::Bind(
-          &LockStateControllerImpl2::
-              UnlockAnimationAfterUIDestroyedFinished,
-          base::Unretained(this));
-
-  AnimationFinishedObserver* observer =
-      new AnimationFinishedObserver(next_animation_starter);
-
-  observer->Pause();
-
-  animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_DROP,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      observer);
-  animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LAUNCHER,
-      internal::SessionStateAnimator::ANIMATION_FADE_IN,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      observer);
-  AnimateBackgroundHidingIfNecessary(
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      observer);
-  observer->Unpause();
-}
-
-void LockStateControllerImpl2::StoreUnlockedProperties() {
-  if (!unlocked_properties_) {
-    unlocked_properties_.reset(new UnlockedStateProperties());
-    unlocked_properties_->background_is_hidden = IsBackgroundHidden();
-  }
-  if (unlocked_properties_->background_is_hidden) {
-    // Hide background so that it can be animated later.
-    animator_->StartAnimation(
-        internal::SessionStateAnimator::DESKTOP_BACKGROUND,
-        internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
-        internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
-    ShowBackground();
-  }
-}
-
-void LockStateControllerImpl2::RestoreUnlockedProperties() {
-  if (!unlocked_properties_)
-    return;
-  if (unlocked_properties_->background_is_hidden) {
-    HideBackground();
-    // Restore background visibility.
-    animator_->StartAnimation(
-        internal::SessionStateAnimator::DESKTOP_BACKGROUND,
-        internal::SessionStateAnimator::ANIMATION_FADE_IN,
-        internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
-  }
-  unlocked_properties_.reset();
-}
-
-void LockStateControllerImpl2::AnimateBackgroundAppearanceIfNecessary(
-    internal::SessionStateAnimator::AnimationSpeed speed,
-    ui::LayerAnimationObserver* observer) {
-  if (unlocked_properties_.get() &&
-      unlocked_properties_->background_is_hidden) {
-    animator_->StartAnimationWithObserver(
-        internal::SessionStateAnimator::DESKTOP_BACKGROUND,
-        internal::SessionStateAnimator::ANIMATION_FADE_IN,
-        speed,
-        observer);
-  }
-}
-
-void LockStateControllerImpl2::AnimateBackgroundHidingIfNecessary(
-    internal::SessionStateAnimator::AnimationSpeed speed,
-    ui::LayerAnimationObserver* observer) {
-  if (unlocked_properties_.get() &&
-      unlocked_properties_->background_is_hidden) {
-    animator_->StartAnimationWithObserver(
-        internal::SessionStateAnimator::DESKTOP_BACKGROUND,
-        internal::SessionStateAnimator::ANIMATION_FADE_OUT,
-        speed,
-        observer);
-  }
-}
-
-}  // namespace ash