Added quick lock mechanism while in Touchview

ash/wm/lock_state_controller.h

 // 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.
 
 #ifndef ASH_WM_LOCK_STATE_CONTROLLER_H_
 #define ASH_WM_LOCK_STATE_CONTROLLER_H_
 
 #include "ash/ash_export.h"
 #include "ash/shell_observer.h"
 #include "ash/wm/lock_state_observer.h"
@@ skipping 34 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(LockStateControllerDelegate);
 };
 
 // Displays onscreen animations and locks or suspends the system in response to
 // the power button being pressed or released.
 // Lock workflow:
 // Entry points:
 //  * StartLockAnimation (bool shutdown after lock) - starts lock that can be
 //    cancelled.
-//  * StartLockAnimationAndLockImmediately - starts uninterruptible lock
-//    animation.
+//  * StartLockAnimationAndLockImmediately (bool shutdown after lock) - starts
+//    uninterruptible lock animation.
 // This leads to call of either StartImmediatePreLockAnimation or
 // StartCancellablePreLockAnimation. Once they complete
 // PreLockAnimationFinished is called, and system lock is requested.
 // Once system locks and lock UI is created, OnLockStateChanged is called, and
 // StartPostLockAnimation is called. In PostLockAnimationFinished two
 // things happen : EVENT_LOCK_ANIMATION_FINISHED notification is sent (it
 // triggers third part of animation within lock UI), and check for continuing to
 // shutdown is made.
 //
 // Unlock workflow:
@@ skipping 61 matching lines @@
       controller_->lock_to_shutdown_timer_.Stop();
     }
     void trigger_shutdown_timeout() {
       controller_->OnPreShutdownAnimationTimeout();
       controller_->pre_shutdown_timer_.Stop();
     }
     void trigger_real_shutdown_timeout() {
       controller_->OnRealShutdownTimeout();
       controller_->real_shutdown_timer_.Stop();
     }
+
    private:
     LockStateController* controller_;  // not owned
 
     DISALLOW_COPY_AND_ASSIGN(TestApi);
   };
 
   LockStateController();
   virtual ~LockStateController();
 
-  // Takes ownership of |delegate|.
-  void SetDelegate(LockStateControllerDelegate* delegate);
+  void SetDelegate(scoped_ptr<LockStateControllerDelegate> delegate);
 
   void AddObserver(LockStateObserver* observer);
   void RemoveObserver(LockStateObserver* observer);
   bool HasObserver(LockStateObserver* observer);
 
   // Starts locking (with slow animation) that can be cancelled.
   // After locking and |kLockToShutdownTimeoutMs| StartShutdownAnimation()
   // will be called unless CancelShutdownAnimation() is called, if
   // |shutdown_after_lock| is true.
   void StartLockAnimation(bool shutdown_after_lock);
 
   // Starts shutting down (with slow animation) that can be cancelled.
   void StartShutdownAnimation();
 
-  // Starts usual lock animation, but locks immediately.
-  // Unlike StartLockAnimation it does no lead to StartShutdownAnimation.
-  void StartLockAnimationAndLockImmediately();
+  // Starts usual lock animation, but locks immediately.  After locking and
+  // |kLockToShutdownTimeoutMs| StartShutdownAnimation() will be called unless
+  // CancelShutdownAnimation() is called, if  |shutdown_after_lock| is true.
+  void StartLockAnimationAndLockImmediately(bool shutdown_after_lock);
 
   // Returns true if we have requested system to lock, but haven't received
   // confirmation yet.
   bool LockRequested();
 
   // Returns true if we are shutting down.
   bool ShutdownRequested();
 
   // Returns true if we are within cancellable lock timeframe.
   bool CanCancelLockAnimation();
@@ skipping 23 matching lines @@
   void SetLockScreenDisplayedCallback(const base::Closure& callback);
 
   // aura::WindowTreeHostObserver override:
   virtual void OnHostCloseRequested(const aura::WindowTreeHost* host) OVERRIDE;
 
   // ShellObserver overrides:
   virtual void OnLoginStateChanged(user::LoginStatus status) OVERRIDE;
   virtual void OnAppTerminating() OVERRIDE;
   virtual void OnLockStateChanged(bool locked) OVERRIDE;
 
+  void set_animator_for_test(SessionStateAnimator* animator) {
+    animator_.reset(animator);
+  }
+
  private:
   friend class test::PowerButtonControllerTest;
   friend class test::LockStateControllerTest;
 
   struct UnlockedStateProperties {
     bool background_is_hidden;
   };
 
   // Reverts the pre-lock animation, reports the error.
   void OnLockFailTimeout();
@@ skipping 40 matching lines @@
   void PostLockAnimationFinished();
   void UnlockAnimationAfterUIDestroyedFinished();
 
   // Stores properties of UI that have to be temporarily modified while locking.
   void StoreUnlockedProperties();
   void RestoreUnlockedProperties();
 
   // Fades in background layer with |speed| if it was hidden in unlocked state.
   void AnimateBackgroundAppearanceIfNecessary(
       ash::SessionStateAnimator::AnimationSpeed speed,
-      ui::LayerAnimationObserver* observer);
+      SessionStateAnimator::AnimationSequence* animation_sequence);
 
   // Fades out background layer with |speed| if it was hidden in unlocked state.
   void AnimateBackgroundHidingIfNecessary(
       ash::SessionStateAnimator::AnimationSpeed speed,
-      ui::LayerAnimationObserver* observer);
+      SessionStateAnimator::AnimationSequence* animation_sequence);
 
   scoped_ptr<SessionStateAnimator> animator_;
 
   scoped_ptr<LockStateControllerDelegate> delegate_;
 
   ObserverList<LockStateObserver> observers_;
 
   // The current login status, or original login status from before we locked.
   user::LoginStatus login_status_;
 
@@ skipping 36 matching lines @@
   base::Closure lock_screen_displayed_callback_;
 
   base::WeakPtrFactory<LockStateController> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LockStateController);
 };
 
 }  // namespace ash
 
 #endif  // ASH_WM_LOCK_STATE_CONTROLLER_H_