wm: Fade screen on signout.

screen_locker_handler.cc

 // 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.
 
 #include "window_manager/screen_locker_handler.h"
 
 #include <cmath>
 #include <tr1/unordered_set>
 
 #include "base/logging.h"
@@ skipping 30 matching lines @@
 // How long should we take to fade the screen locker window in in the
 // background once the screen has been locked?
 static const int kScreenLockerFadeInMs = 50;
 
 // How long we'll wait for another message after we enter the pre-lock or
 // pre-shutdown state before giving up and reverting back to the previous
 // state.  This is just here as backup so we don't get stuck showing the
 // snapshot onscreen forever if the power manager dies or something.
 static const int kAbortAnimationMs = 2000;
 
+// How long should we take to fade the screen to black when the user signs out?
+static const int kSignoutAnimMs = 100;
+
 const float ScreenLockerHandler::kSlowCloseSizeRatio = 0.95;
 
 ScreenLockerHandler::ScreenLockerHandler(WindowManager* wm)
     : wm_(wm),
       registrar_(new EventConsumerRegistrar(wm_, this)),
       snapshot_pixmap_(0),
       destroy_snapshot_timeout_id_(-1),
       is_locked_(false),
-      shutting_down_(false) {
+      session_ending_(false) {
   registrar_->RegisterForChromeMessages(
       chromeos::WM_IPC_MESSAGE_WM_NOTIFY_POWER_BUTTON_STATE);
   registrar_->RegisterForChromeMessages(
       chromeos::WM_IPC_MESSAGE_WM_NOTIFY_SHUTTING_DOWN);
+  registrar_->RegisterForChromeMessages(
+      chromeos::WM_IPC_MESSAGE_WM_NOTIFY_SIGNING_OUT);
 }
 
 ScreenLockerHandler::~ScreenLockerHandler() {
   if (is_locked_)
     wm_->compositor()->ResetActiveVisibilityGroups();
 
   wm_->event_loop()->RemoveTimeoutIfSet(&destroy_snapshot_timeout_id_);
   if (snapshot_pixmap_)
     wm_->xconn()->FreePixmap(snapshot_pixmap_);
 }
@@ skipping 95 matching lines @@
         HandlePreShutdown();
         break;
       case chromeos::WM_IPC_POWER_BUTTON_ABORTED_SHUTDOWN:
         HandleAbortedShutdown();
         break;
       default:
         LOG(ERROR) << "Unexpected state in power button state message: "
                    << state;
     }
   } else if (msg.type() == chromeos::WM_IPC_MESSAGE_WM_NOTIFY_SHUTTING_DOWN) {
-    HandleShuttingDown();
+    HandleSessionEnding(true);   // shutting_down=true
+  } else if (msg.type() == chromeos::WM_IPC_MESSAGE_WM_NOTIFY_SIGNING_OUT) {
+    HandleSessionEnding(false);  // shutting_down=false
   } else {
     NOTREACHED() << "Received unwanted Chrome message "
                  << chromeos::WmIpcMessageTypeToString(msg.type());
   }
 }
 
 bool ScreenLockerHandler::HasWindowWithInitialPixmap() const {
   for (set<XWindow>::const_iterator it = screen_locker_xids_.begin();
        it != screen_locker_xids_.end(); ++it) {
     if (wm_->GetWindowOrDie(*it)->has_initial_pixmap())
@@ skipping 54 matching lines @@
   WmIpc::Message msg(
       chromeos::WM_IPC_MESSAGE_CHROME_NOTIFY_SCREEN_REDRAWN_FOR_LOCK);
   wm_->wm_ipc()->SendMessage(chrome_win->xid(), msg);
 }
 
 void ScreenLockerHandler::HandleUnlocked() {
   DCHECK(is_locked_);
   DCHECK(!HasWindowWithInitialPixmap());
   is_locked_ = false;
 
-  if (shutting_down_)
+  if (session_ending_)
     return;
 
   DLOG(INFO) << "Last screen locker window unmapped; unhiding other windows";
   wm_->event_loop()->RemoveTimeoutIfSet(&destroy_snapshot_timeout_id_);
 
   // This is arguably incorrect if the user types their password on the lock
   // screen, starts holding the power button, and then hits Enter to unlock the
   // screen: we'll abort the pre-shutdown animation here.  It's not an issue in
   // practice, though: if they release the power button before we'd shut down,
   // the snapshot is already gone and the aborted-shutdown message is a no-op;
   // if they hold the power button and we start shutting down, we'll grab a new
   // snapshot for the fast-close animation.
   DestroySnapshotAndUpdateVisibilityGroup();
 }
 
 void ScreenLockerHandler::HandlePreShutdown() {
   DLOG(INFO) << "Starting pre-shutdown animation";
   if (snapshot_actor_.get()) {
     // Make sure that we'll use a new snapshot.  If the power button was
     // held since before the screen was locked, we don't want to reuse the
     // snapshot taken while the screen was unlocked.
     DestroySnapshotAndUpdateVisibilityGroup();
     wm_->compositor()->Draw();
   }
   StartSlowCloseAnimation();
   wm_->compositor()->SetActiveVisibilityGroup(
-      WindowManager::VISIBILITY_GROUP_SHUTDOWN);
+      WindowManager::VISIBILITY_GROUP_SESSION_ENDING);
 }
 
 void ScreenLockerHandler::HandleAbortedShutdown() {
   DLOG(INFO) << "Shutdown aborted";
   StartUndoSlowCloseAnimation();
 }
 
-void ScreenLockerHandler::HandleShuttingDown() {
-  LOG(INFO) << "System is shutting down";
-  if (shutting_down_)
+void ScreenLockerHandler::HandleSessionEnding(bool shutting_down) {
+  if (shutting_down)
+    LOG(INFO) << "System is shutting down";
+  else
+    LOG(INFO) << "User is signing out";
+
+  if (session_ending_)
     return;
-  shutting_down_ = true;
+  session_ending_ = true;
 
   XID cursor = wm_->xconn()->CreateTransparentCursor();
   wm_->xconn()->SetWindowCursor(wm_->root(), cursor);
   wm_->xconn()->GrabPointer(wm_->root(), 0, 0, cursor);
   if (cursor)
     wm_->xconn()->FreeCursor(cursor);
   wm_->xconn()->GrabKeyboard(wm_->root(), 0);
 
-  StartFastCloseAnimation(false);
+  if (shutting_down)
+    StartFastCloseAnimation(false);
+  else
+    StartFadeoutAnimation();
   wm_->compositor()->SetActiveVisibilityGroup(
-      WindowManager::VISIBILITY_GROUP_SHUTDOWN);
+      WindowManager::VISIBILITY_GROUP_SESSION_ENDING);
+}
+
+void ScreenLockerHandler::SetUpSnapshot() {
+  if (snapshot_actor_.get())
+    return;
+
+  DCHECK_EQ(snapshot_pixmap_, static_cast<XPixmap>(0));
+  snapshot_pixmap_ = wm_->xconn()->CreatePixmap(
+      wm_->root(), Size(wm_->width(), wm_->height()), wm_->root_depth());
+  wm_->xconn()->CopyArea(wm_->root(),       // src
+                         snapshot_pixmap_,  // dest
+                         Point(0, 0),       // src_pos
+                         Point(0, 0),       // dest_pos
+                         Size(wm_->width(), wm_->height()));
+  snapshot_actor_.reset(wm_->compositor()->CreateTexturePixmap());
+  snapshot_actor_->SetPixmap(snapshot_pixmap_);
+  wm_->stage()->AddActor(snapshot_actor_.get());
+  wm_->stacking_manager()->StackActorAtTopOfLayer(
+      snapshot_actor_.get(), StackingManager::LAYER_SCREEN_LOCKER_SNAPSHOT);
+  snapshot_actor_->AddToVisibilityGroup(
+      WindowManager::VISIBILITY_GROUP_SCREEN_LOCKER);
+  snapshot_actor_->AddToVisibilityGroup(
+      WindowManager::VISIBILITY_GROUP_SESSION_ENDING);
+  snapshot_actor_->Move(0, 0, 0);
+  snapshot_actor_->Scale(1.0, 1.0, 0);
 }
 
 void ScreenLockerHandler::StartSlowCloseAnimation() {
   if (!snapshot_actor_.get()) {
-    DCHECK_EQ(snapshot_pixmap_, static_cast<XPixmap>(0));
-    snapshot_pixmap_ = wm_->xconn()->CreatePixmap(
-        wm_->root(), Size(wm_->width(), wm_->height()), wm_->root_depth());
-    wm_->xconn()->CopyArea(wm_->root(),       // src
-                           snapshot_pixmap_,  // dest
-                           Point(0, 0),       // src_pos
-                           Point(0, 0),       // dest_pos
-                           Size(wm_->width(), wm_->height()));
-    snapshot_actor_.reset(wm_->compositor()->CreateTexturePixmap());
-    snapshot_actor_->SetPixmap(snapshot_pixmap_);
-    wm_->stage()->AddActor(snapshot_actor_.get());
-    wm_->stacking_manager()->StackActorAtTopOfLayer(
-        snapshot_actor_.get(), StackingManager::LAYER_SCREEN_LOCKER_SNAPSHOT);
-    snapshot_actor_->AddToVisibilityGroup(
-        WindowManager::VISIBILITY_GROUP_SCREEN_LOCKER);
-    snapshot_actor_->AddToVisibilityGroup(
-        WindowManager::VISIBILITY_GROUP_SHUTDOWN);
+    SetUpSnapshot();
+  } else {
+    snapshot_actor_->Move(0, 0, 0);
+    snapshot_actor_->Scale(1.0, 1.0, 0);
   }
 
-  snapshot_actor_->Move(0, 0, 0);
-  snapshot_actor_->Scale(1.0, 1.0, 0);
-
   snapshot_actor_->Move(
       round(0.5 * (1.0 - kSlowCloseSizeRatio) * wm_->width()),
       round(0.5 * (1.0 - kSlowCloseSizeRatio) * wm_->height()),
       kSlowCloseAnimMs);
   snapshot_actor_->Scale(
       kSlowCloseSizeRatio, kSlowCloseSizeRatio, kSlowCloseAnimMs);
 
   wm_->event_loop()->RemoveTimeoutIfSet(&destroy_snapshot_timeout_id_);
   destroy_snapshot_timeout_id_ =
       wm_->event_loop()->AddTimeout(
@@ skipping 20 matching lines @@
           NewPermanentCallback(
               this,
               &ScreenLockerHandler::HandleDestroySnapshotTimeout),
           kUndoSlowCloseAnimMs,
           0);  // recurring timeout
 }
 
 void ScreenLockerHandler::StartFastCloseAnimation(
     bool destroy_snapshot_when_done) {
   if (!snapshot_actor_.get())
-    StartSlowCloseAnimation();
+    SetUpSnapshot();
 
-  DCHECK(snapshot_actor_.get());
   snapshot_actor_->Move(
       round(0.5 * wm_->width()), round(0.5 * wm_->height()), kFastCloseAnimMs);
   snapshot_actor_->Scale(0, 0, kFastCloseAnimMs);
   snapshot_actor_->SetOpacity(0, kFastCloseAnimMs);
 
   wm_->event_loop()->RemoveTimeoutIfSet(&destroy_snapshot_timeout_id_);
   if (destroy_snapshot_when_done) {
     destroy_snapshot_timeout_id_ =
         wm_->event_loop()->AddTimeout(
             NewPermanentCallback(
                 this,
                 &ScreenLockerHandler::HandleDestroySnapshotTimeout),
             kFastCloseAnimMs,
             0);  // recurring timeout
   }
 }
 
+void ScreenLockerHandler::StartFadeoutAnimation() {
+  if (!snapshot_actor_.get()) {
+    SetUpSnapshot();
+  } else {
+    snapshot_actor_->Move(0, 0, 0);
+    snapshot_actor_->Scale(1.0, 1.0, 0);
+  }
+  snapshot_actor_->SetOpacity(0, kSignoutAnimMs);
+}
+
 void ScreenLockerHandler::DestroySnapshot() {
   snapshot_actor_.reset();
   wm_->xconn()->FreePixmap(snapshot_pixmap_);
   snapshot_pixmap_ = 0;
 }
 
 void ScreenLockerHandler::DestroySnapshotAndUpdateVisibilityGroup() {
   DestroySnapshot();
 
   // Let the real windows be visible again.
   if (is_locked_) {
     wm_->compositor()->SetActiveVisibilityGroup(
         WindowManager::VISIBILITY_GROUP_SCREEN_LOCKER);
   } else {
     wm_->compositor()->ResetActiveVisibilityGroups();
   }
 }
 
 void ScreenLockerHandler::HandleDestroySnapshotTimeout() {
   destroy_snapshot_timeout_id_ = -1;
   DestroySnapshotAndUpdateVisibilityGroup();
 }
 
 }  // namespace window_manager