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);

[Chris Masone, 2010/12/29 23:06:55]

Seems like either you should assume Move and Scale will happen in here, or
assume they won't.  You seem to consistently follow up SetUsSnapshot with these
two calls when you use it below.

[Daniel Erat, 2010/12/29 23:20:24]

You're right; StartFastCloseAnimation()'s snapshot_actor_->Move(0, 0, 0) and
snapshot_actor_->Scale(1.0, 1.0, 0) are no-ops, since the actor is already being
configured identically.  I've deleted those.  I've also moved the calls in
StartSlowCloseAnimation() and StartFadeoutAnimation() into else blocks.

+  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);
-  }
+  if (!snapshot_actor_.get())
+    SetUpSnapshot();
 
   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);
@@ skipping 23 matching lines @@
       wm_->event_loop()->AddTimeout(
           NewPermanentCallback(
               this,
               &ScreenLockerHandler::HandleDestroySnapshotTimeout),
           kUndoSlowCloseAnimMs,
           0);  // recurring timeout
 }
 
 void ScreenLockerHandler::StartFastCloseAnimation(
     bool destroy_snapshot_when_done) {
-  if (!snapshot_actor_.get())
-    StartSlowCloseAnimation();
+  if (!snapshot_actor_.get()) {
+    SetUpSnapshot();

[Chris Masone, 2010/12/29 23:06:55]

It seems like you used to DO a slow animation and then do the fast animation
after, and now you don't.  Is that not so?  Or, is that now desired?

[Daniel Erat, 2010/12/29 23:20:24]

I was just doing the slow animation to take the snapshot, since that's where the
code lived -- the faster animation added later in this method would replace the
slow one.  This change cleans things up by moving the snapshot-taking code into
a separate method.

+    snapshot_actor_->Move(0, 0, 0);
+    snapshot_actor_->Scale(1.0, 1.0, 0);
+  }
 
-  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();
+  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