wm: Fade screen on signout.

screen_locker_handler_test.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 <cmath>
 #include <vector>
 
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
 
@@ skipping 49 matching lines @@
     EXPECT_EQ(0, actor->y());
     EXPECT_FLOAT_EQ(1.0, actor->scale_x());
     EXPECT_FLOAT_EQ(1.0, actor->scale_y());
     EXPECT_FLOAT_EQ(1.0, actor->opacity());
   }
 
   void TestActorConfiguredForFastClose(
       MockCompositor::TexturePixmapActor* actor) {
     CHECK(actor);
     EXPECT_TRUE(actor->is_shown());
-    EXPECT_FLOAT_EQ(round(0.5 * wm_->width()), actor->x());
-    EXPECT_FLOAT_EQ(round(0.5 * wm_->height()), actor->y());
+    EXPECT_EQ(static_cast<int>(round(0.5 * wm_->width())), actor->x());
+    EXPECT_EQ(static_cast<int>(round(0.5 * wm_->height())), actor->y());
     EXPECT_FLOAT_EQ(0.0, actor->scale_x());
     EXPECT_FLOAT_EQ(0.0, actor->scale_y());
     EXPECT_FLOAT_EQ(0.0, actor->opacity());
   }
 
+  void TestActorConfiguredForFadeout(
+      MockCompositor::TexturePixmapActor* actor) {
+    CHECK(actor);
+    EXPECT_TRUE(actor->is_shown());
+    EXPECT_EQ(0, actor->x());
+    EXPECT_EQ(0, actor->y());
+    EXPECT_FLOAT_EQ(1.0, actor->scale_x());
+    EXPECT_FLOAT_EQ(1.0, actor->scale_y());
+    EXPECT_FLOAT_EQ(0.0, actor->opacity());
+  }
+
   bool IsOnlyActiveVisibilityGroup(int group) {
     if (compositor_->active_visibility_groups().size() !=
         static_cast<size_t>(1)) {
       return false;
     }
     return (*(compositor_->active_visibility_groups().begin()) == group);
   }
 
   ScreenLockerHandler* handler_;
 };
@@ skipping 101 matching lines @@
   MockCompositor::TexturePixmapActor* actor = GetSnapshotActor();
   ASSERT_TRUE(actor != NULL);
   TestActorConfiguredForSlowClose(actor);
   EXPECT_NE(-1, handler_->destroy_snapshot_timeout_id_);
 
   // The snapshot should be the only actor currently visible.
   EXPECT_EQ(static_cast<size_t>(2), actor->visibility_groups().size());
   EXPECT_TRUE(actor->visibility_groups().count(
                   WindowManager::VISIBILITY_GROUP_SCREEN_LOCKER) != 0);
   EXPECT_TRUE(actor->visibility_groups().count(
-                  WindowManager::VISIBILITY_GROUP_SHUTDOWN) != 0);
+                  WindowManager::VISIBILITY_GROUP_SESSION_ENDING) != 0);
   EXPECT_TRUE(IsOnlyActiveVisibilityGroup(
                   WindowManager::VISIBILITY_GROUP_SCREEN_LOCKER));
 
   // Now tell the WM that the button was released before being held long
   // enough to lock.
   msg.set_param(0, chromeos::WM_IPC_POWER_BUTTON_ABORTED_LOCK);
   SendWmIpcMessage(msg);
 
   // Check that we're still showing the same actor, and that it's being
   // scaled back to its natural size.
@@ skipping 58 matching lines @@
   SendWmIpcMessage(msg);
 
   // We should have taken a snapshot of the screen.
   MockCompositor::TexturePixmapActor* actor = GetSnapshotActor();
   ASSERT_TRUE(actor != NULL);
   TestActorConfiguredForSlowClose(actor);
   EXPECT_NE(-1, handler_->destroy_snapshot_timeout_id_);
 
   // The snapshot should be the only actor currently visible.
   EXPECT_TRUE(actor->visibility_groups().count(
-                  WindowManager::VISIBILITY_GROUP_SHUTDOWN) != 0);
+                  WindowManager::VISIBILITY_GROUP_SESSION_ENDING) != 0);
   EXPECT_TRUE(IsOnlyActiveVisibilityGroup(
-                  WindowManager::VISIBILITY_GROUP_SHUTDOWN));
+                  WindowManager::VISIBILITY_GROUP_SESSION_ENDING));
 
   // Now tell the WM that the button was released before being held long
   // enough to shut down.
   msg.set_param(0, chromeos::WM_IPC_POWER_BUTTON_ABORTED_SHUTDOWN);
   SendWmIpcMessage(msg);
 
   // Check that we're still showing the same actor, and that it's being
   // scaled back to its natural size.
   ASSERT_EQ(actor, GetSnapshotActor());
   TestActorConfiguredForUndoSlowClose(actor);
@@ skipping 21 matching lines @@
   ASSERT_TRUE(IsOnlyActiveVisibilityGroup(
                   WindowManager::VISIBILITY_GROUP_SCREEN_LOCKER));
 
   // Enter the pre-shutdown state as before.
   msg.set_param(0, chromeos::WM_IPC_POWER_BUTTON_PRE_SHUTDOWN);
   SendWmIpcMessage(msg);
   actor = GetSnapshotActor();
   ASSERT_TRUE(actor != NULL);
   TestActorConfiguredForSlowClose(actor);
   EXPECT_TRUE(IsOnlyActiveVisibilityGroup(
-                  WindowManager::VISIBILITY_GROUP_SHUTDOWN));
+                  WindowManager::VISIBILITY_GROUP_SESSION_ENDING));
 
   // After aborting, we should be showing just the screen locker window.
   msg.set_param(0, chromeos::WM_IPC_POWER_BUTTON_ABORTED_SHUTDOWN);
   SendWmIpcMessage(msg);
   ASSERT_NE(-1, handler_->destroy_snapshot_timeout_id_);
   wm_->event_loop()->RunTimeoutForTesting(
       handler_->destroy_snapshot_timeout_id_);
   EXPECT_EQ(-1, handler_->destroy_snapshot_timeout_id_);
   EXPECT_TRUE(IsOnlyActiveVisibilityGroup(
                   WindowManager::VISIBILITY_GROUP_SCREEN_LOCKER));
 }
 
 // Test that we do stuff in response to notification that the system is
 // shutting down.
 TEST_F(ScreenLockerHandlerTest, HandleShutdown) {
   // Go into the pre-shutdown state first.
   WmIpc::Message msg(chromeos::WM_IPC_MESSAGE_WM_NOTIFY_POWER_BUTTON_STATE);
   msg.set_param(0, chromeos::WM_IPC_POWER_BUTTON_PRE_SHUTDOWN);
   SendWmIpcMessage(msg);
 
   // Check that we've started the slow-close animation.
   MockCompositor::TexturePixmapActor* actor = GetSnapshotActor();
   ASSERT_TRUE(actor != NULL);
   TestActorConfiguredForSlowClose(actor);
   EXPECT_NE(-1, handler_->destroy_snapshot_timeout_id_);
   EXPECT_TRUE(IsOnlyActiveVisibilityGroup(
-                  WindowManager::VISIBILITY_GROUP_SHUTDOWN));
+                  WindowManager::VISIBILITY_GROUP_SESSION_ENDING));
 
   // Notify the window manager that the system is being shut down.
   msg.set_type(chromeos::WM_IPC_MESSAGE_WM_NOTIFY_SHUTTING_DOWN);
   msg.set_param(0, 0);
   SendWmIpcMessage(msg);
 
   // Check that we grabbed the pointer and keyboard and assigned a transparent
   // cursor to the root window.
   XWindow root = xconn_->GetRootWindow();
   EXPECT_EQ(root, xconn_->pointer_grab_xid());
   EXPECT_EQ(root, xconn_->keyboard_grab_xid());
   EXPECT_EQ(MockXConnection::kTransparentCursor,
             xconn_->GetWindowInfoOrDie(root)->cursor);
 
   // We should be using the same snapshot that we already grabbed, and we
   // should be displaying the fast-close animation.
   ASSERT_EQ(actor, GetSnapshotActor());
   TestActorConfiguredForFastClose(actor);
   EXPECT_TRUE(IsOnlyActiveVisibilityGroup(
-                  WindowManager::VISIBILITY_GROUP_SHUTDOWN));
+                  WindowManager::VISIBILITY_GROUP_SESSION_ENDING));
 
   // There's no need to destroy the snapshot after we're done with the
   // animation; we're not going to be showing anything else onscreen.
   EXPECT_EQ(-1, handler_->destroy_snapshot_timeout_id_);
 }
 
 // Test that we don't consider the screen to be locked until the screen
 // locker window is actually visible.
 TEST_F(ScreenLockerHandlerTest, DeferLockUntilWindowIsVisible) {
   // Enable the sync request protocol on a screen locker window before
@@ skipping 40 matching lines @@
 
   // The actor should be removed from the visibility group when the window is
   // unmapped.
   XEvent event;
   xconn_->InitUnmapEvent(&event, info_bubble_xid);
   wm_->HandleEvent(&event);
   EXPECT_FALSE(info_bubble_actor->visibility_groups().count(
                  WindowManager::VISIBILITY_GROUP_SCREEN_LOCKER));
 }
 
+// Test that we handle messages from Chrome notifying us that the user is
+// signing out.
+TEST_F(ScreenLockerHandlerTest, SigningOut) {
+  WmIpc::Message msg(chromeos::WM_IPC_MESSAGE_WM_NOTIFY_SIGNING_OUT);
+  SendWmIpcMessage(msg);
+
+  // We should grab the pointer and keyboard, assign a transparent cursor to the
+  // root window, and fade out a snapshot of the screen.
+  XWindow root = xconn_->GetRootWindow();
+  EXPECT_EQ(root, xconn_->pointer_grab_xid());
+  EXPECT_EQ(root, xconn_->keyboard_grab_xid());
+  EXPECT_EQ(MockXConnection::kTransparentCursor,
+            xconn_->GetWindowInfoOrDie(root)->cursor);
+  TestActorConfiguredForFadeout(GetSnapshotActor());
+  EXPECT_TRUE(IsOnlyActiveVisibilityGroup(
+                  WindowManager::VISIBILITY_GROUP_SESSION_ENDING));
+}
+
 }  // namespace window_manager
 
 int main(int argc, char** argv) {
   return window_manager::InitAndRunTests(&argc, argv, &FLAGS_logtostderr);
 }