wm: Fade screen on signout.

screen_locker_handler.h

 // Copyright (c) 2010 The Chromium OS 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 WINDOW_MANAGER_SCREEN_LOCKER_HANDLER_H_
 #define WINDOW_MANAGER_SCREEN_LOCKER_HANDLER_H_
 
 #include <set>
 
 #include <gtest/gtest_prod.h>  // for FRIEND_TEST() macro
 
 #include "base/scoped_ptr.h"
 #include "window_manager/compositor.h"
 #include "window_manager/event_consumer.h"
 #include "window_manager/x_types.h"
 
 namespace window_manager {
 
 class EventConsumerRegistrar;
 class WindowManager;
 class Window;
 
 // ScreenLockerHandler is an event consumer that hides all other actors
 // when a screen locker window gets mapped and unhides them when the locker
-// window is unmapped.  It also handles messages sent by the power manager
-// when the power button is pressed or unpressed.
+// window is unmapped.  It also handles messages sent by the power manager when
+// the power button is pressed or unpressed or the system is shutting down, and
+// messages sent by Chrome when the user is signing out.
 class ScreenLockerHandler : public EventConsumer {
  public:
   explicit ScreenLockerHandler(WindowManager* wm);
   ~ScreenLockerHandler();
 
-  bool shutting_down() const { return shutting_down_; }
+  bool session_ending() const { return session_ending_; }
 
   // Begin EventConsumer implementation.
   virtual bool IsInputWindow(XWindow xid) { return false; }
   virtual void HandleScreenResize();
   virtual void HandleLoggedInStateChange() {}
   virtual bool HandleWindowMapRequest(Window* win);
   virtual void HandleWindowMap(Window* win);
   virtual void HandleWindowUnmap(Window* win);
   virtual void HandleWindowInitialPixmap(Window* win);
   virtual void HandleWindowConfigureRequest(Window* win,
@@ skipping 72 matching lines @@
   // locked state, or while not logged in.  We take a snapshot of the
   // screen, display only it, and make it slowly zoom away from the user.
   void HandlePreShutdown();
 
   // Handle the power button having been released while in the pre-shutdown
   // state.  We animate the snapshot scaling back to its normal size and
   // set a timer to destroy it and switch back to displaying the screen
   // locker window (if locked) or all actors (if unlocked).
   void HandleAbortedShutdown();
 
-  // Handle notification that the system is shutting down.  We make the
-  // snapshot from the pre-shutdown state zoom quickly down to the center
-  // of the screen, set pointer to use a transparent cursor, and grab the
-  // keyboard and pointer.
-  void HandleShuttingDown();
+  // Handle notification that the current session is ending (either due to
+  // shutdown if 'shutting_down' is true or due to signout otherwise).  We set
+  // the pointer to use a transparent cursor, grab the keyboard and pointer, and
+  // display an animation.
+  void HandleSessionEnding(bool shutting_down);
 
-  // Take a snapshot of the screen if we don't already have one and animate
-  // it slowly scaling down to kSlowCloseSizeRatio.
+  // If 'snapshot_actor_' is unset, grab and display a snapshot of the current
+  // contents of the screen.
+  void SetUpSnapshot();
+
+  // Animate a snapshot of the screen slowly scaling down to
+  // kSlowCloseSizeRatio.
   void StartSlowCloseAnimation();
 
   // Start an animation undoing the scaling from StartSlowCloseAnimation()
   // and register a timeout to call
   // DestroySnapshotAndUpdateVisibilityGroup() when it's done.
   void StartUndoSlowCloseAnimation();
 
-  // Take a snapshot of the screen if we don't already have one and make it
-  // quickly get scaled down to the center of the screen.  If
-  // 'destroy_snapshot_when_done' is true, also register a timeout to call
-  // DestroySnapshotAndUpdateVisibilityGroup() when it's done.
+  // Animate a snapshot of the screen quickly getting scaled down to the center
+  // of the screen.  If 'destroy_snapshot_when_done' is true, also register a
+  // timeout to call DestroySnapshotAndUpdateVisibilityGroup() when it's done.
+  // If there's an existing snapshot (from an in-progress slow-close animation),
+  // we use it.
   void StartFastCloseAnimation(bool destroy_snapshot_when_done);
 
+  // Animate a snapshot of the screen quickly fading out to black.
+  void StartFadeoutAnimation();
+
   // Destroy 'snapshot_actor_' and 'snapshot_pixmap_'.
   void DestroySnapshot();
 
   // Call DestroySnapshot() and also reset the active visibility groups to
   // show all actors (if the screen is unlocked) or just the screen locker
   // window (if the screen is locked).
   void DestroySnapshotAndUpdateVisibilityGroup();
 
   // Reset 'destroy_snapshot_timeout_id_' to -1 and call
   // DestroySnapshotAndUpdateVisibilityGroup().
@@ skipping 16 matching lines @@
 
   // Timeout for calling DestroySnapshotAndUpdateVisibilityGroup(), or -1
   // if unset.
   int destroy_snapshot_timeout_id_;
 
   // Is the screen currently locked?  We only consider the screen to be
   // locked if a screen locker window has been mapped and we've loaded a
   // pixmap for it.
   bool is_locked_;
 
-  // Is the system shutting down?  Set to true in response to a
+  // Is the current X session ending?  Set to true in response to a
+  // WM_IPC_MESSAGE_WM_NOTIFY_SIGNING_OUT or
   // WM_IPC_MESSAGE_WM_NOTIFY_SHUTTING_DOWN message and never unset.
-  bool shutting_down_;
+  bool session_ending_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockerHandler);
 };
 
 }  // namespace window_manager
 
 #endif  // WINDOW_MANAGER_SCREEN_LOCKER_HANDLER_H_