wm: Fix override-redirect window stacking bug.

src/platform/window_manager/window_manager_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 <algorithm>
 #include <cstdarg>
 #include <vector>
 
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
@@ skipping 416 matching lines @@
   reparent_event->parent = 324324;  // arbitrary number
   wm_->HandleEvent(&event);
 
   // After the window gets reparented away from the root, WindowManager
   // should've unredirected it and should no longer be tracking it.
   EXPECT_TRUE(wm_->GetWindow(xid) == NULL);
   EXPECT_FALSE(info->redirected);
 }
 
 TEST_F(WindowManagerTest, RestackOverrideRedirectWindows) {
+  MockCompositor::StageActor* stage = compositor_->GetDefaultStage();
   XEvent event;
 
   // Create two override-redirect windows and map them both.
   XWindow xid = xconn_->CreateWindow(
       xconn_->GetRootWindow(),
       10, 20,  // x, y
       30, 40,  // width, height
       true,    // override redirect
       false,   // input only
       0);      // event mask
-  xconn_->InitCreateWindowEvent(&event, xid);
-  wm_->HandleEvent(&event);
   xconn_->MapWindow(xid);
-  xconn_->InitMapEvent(&event, xid);
-  wm_->HandleEvent(&event);
+  SendInitialEventsForWindow(xid);
   Window* win = wm_->GetWindowOrDie(xid);
 
   XWindow xid2 = xconn_->CreateWindow(
       xconn_->GetRootWindow(),
       10, 20,  // x, y
       30, 40,  // width, height
       true,    // override redirect
       false,   // input only
       0);      // event mask
-  xconn_->InitCreateWindowEvent(&event, xid2);
-  wm_->HandleEvent(&event);
   xconn_->MapWindow(xid2);
-  xconn_->InitMapEvent(&event, xid2);
-  wm_->HandleEvent(&event);
+  SendInitialEventsForWindow(xid2);
   Window* win2 = wm_->GetWindowOrDie(xid2);
 
-  // Send a ConfigureNotify saying that the second window has been stacked
-  // on top of the first and then make sure that the compositing actors are
-  // stacked in the same manner.
-  xconn_->InitConfigureNotifyEvent(&event, xid2);
-  event.xconfigure.above = xid;
-  wm_->HandleEvent(&event);
-  MockCompositor::StageActor* stage = compositor_->GetDefaultStage();
+  // The second window should initially be stacked above the first.
   EXPECT_LT(stage->GetStackingIndex(win2->actor()),
             stage->GetStackingIndex(win->actor()));
 
-  // Now send a message saying that the first window is on top of the second.
+  // Send a message saying that the first window is on top of the second.
+  xconn_->StackWindow(xid, xid2, true);
   xconn_->InitConfigureNotifyEvent(&event, xid);
   event.xconfigure.above = xid2;
   wm_->HandleEvent(&event);
   EXPECT_LT(stage->GetStackingIndex(win->actor()),
             stage->GetStackingIndex(win2->actor()));
 }
 
+TEST_F(WindowManagerTest, StackOverrideRedirectWindowsAboveLayers) {
+  MockCompositor::StageActor* stage = compositor_->GetDefaultStage();
+  XEvent event;
+
+  // Create a normal, non-override-redirect window.
+  XWindow normal_xid = CreateSimpleWindow();
+  SendInitialEventsForWindow(normal_xid);
+  Window* normal_win = wm_->GetWindowOrDie(normal_xid);
+
+  // Create an override-redirect window and map it.
+  XWindow xid = xconn_->CreateWindow(
+      xconn_->GetRootWindow(),
+      10, 20,  // x, y
+      30, 40,  // width, height
+      true,    // override redirect
+      false,   // input only
+      0);      // event mask
+  xconn_->MapWindow(xid);
+  SendInitialEventsForWindow(xid);
+  Window* win = wm_->GetWindowOrDie(xid);
+
+  // The override-redirect window's actor should initially be stacked above
+  // the actor for the top stacking layer (and the normal window's actor,
+  // of course).
+  Compositor::Actor* debugging_layer_actor =
+      wm_->stacking_manager()->layer_to_actor_[
+          StackingManager::LAYER_DEBUGGING].get();
+  ASSERT_TRUE(debugging_layer_actor != NULL);
+  EXPECT_LT(stage->GetStackingIndex(win->actor()),
+            stage->GetStackingIndex(debugging_layer_actor));
+  EXPECT_LT(stage->GetStackingIndex(win->actor()),
+            stage->GetStackingIndex(normal_win->actor()));
+
+  // Stack the override-redirect window slightly lower, but still above the
+  // normal window.
+  XWindow fullscreen_layer_xid =
+      wm_->stacking_manager()->layer_to_xid_[
+          StackingManager::LAYER_FULLSCREEN_PANEL];
+  xconn_->StackWindow(xid, fullscreen_layer_xid, true);
+  xconn_->InitConfigureNotifyEvent(&event, xid);
+  event.xconfigure.above = fullscreen_layer_xid;
+  wm_->HandleEvent(&event);
+
+  // Create a second normal window and check that the override-redirect
+  // window is above it.  This protects against a regression of the issue
+  // described at http://crosbug.com/3451.
+  XWindow normal_xid2 = CreateSimpleWindow();
+  SendInitialEventsForWindow(normal_xid2);
+  Window* normal_win2 = wm_->GetWindowOrDie(normal_xid2);
+  EXPECT_LT(stage->GetStackingIndex(win->actor()),
+            stage->GetStackingIndex(normal_win->actor()));
+  EXPECT_LT(stage->GetStackingIndex(win->actor()),
+            stage->GetStackingIndex(normal_win2->actor()));
+}
+
 // Test that we honor ConfigureRequest events that change an unmapped
 // window's size, and that we ignore fields that are unset in its
 // 'value_mask' field.
 TEST_F(WindowManagerTest, ConfigureRequestResize) {
   XWindow xid = CreateSimpleWindow();
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
   const int orig_width = info->width;
   const int orig_height = info->height;
 
   XEvent event;
@@ skipping 443 matching lines @@
   xconn_->InitUnmapEvent(&event, xid);
   wm_->HandleEvent(&event);
   EXPECT_EQ(initial_pixmap_discards + 2, actor->num_pixmap_discards());
 }
 
 }  // namespace window_manager
 
 int main(int argc, char** argv) {
   return window_manager::InitAndRunTests(&argc, argv, &FLAGS_logtostderr);
 }