wm: Make _NET_ACTIVE_WINDOW contain transient windows.

src/platform/window_manager/layout_manager_test.cc

 // Copyright (c) 2009 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 <gflags/gflags.h>
 #include <gtest/gtest.h>
 
 #include "base/scoped_ptr.h"
 #include "base/logging.h"
 #include "window_manager/clutter_interface.h"
@@ skipping 112 matching lines @@
   EXPECT_EQ(None, xconn_->focused_xid());
   EXPECT_TRUE(lm_->active_toplevel_ == NULL);
 
   // The layout manager should activate and focus the window when it gets
   // mapped.
   MockXConnection::InitMapEvent(&event, xid);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   EXPECT_EQ(xid, xconn_->focused_xid());
   ASSERT_TRUE(lm_->active_toplevel_ != NULL);
   EXPECT_EQ(xid, lm_->active_toplevel_->win()->xid());
-  EXPECT_EQ(None, wm_->active_window_xid());
+  EXPECT_EQ(None, GetActiveWindowProperty());
   EXPECT_TRUE(info->all_buttons_grabbed);
 
   // We shouldn't actually update _NET_ACTIVE_WINDOW and remove the passive
   // button grab until we get the FocusIn event.
   SendFocusEvents(xconn_->GetRootWindow(), xid);
-  EXPECT_EQ(xid, wm_->active_window_xid());
+  EXPECT_EQ(xid, GetActiveWindowProperty());
   EXPECT_FALSE(info->all_buttons_grabbed);
 
   // Now create a second window.
   XWindow xid2 = CreateSimpleWindow();
   MockXConnection::WindowInfo* info2 = xconn_->GetWindowInfoOrDie(xid2);
 
   // When the second window is created, the first should still be active.
   MockXConnection::InitCreateWindowEvent(&event, *info2);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   EXPECT_EQ(xid, xconn_->focused_xid());
   ASSERT_TRUE(lm_->active_toplevel_ != NULL);
   EXPECT_EQ(xid, lm_->active_toplevel_->win()->xid());
 
   // When the second window is mapped, it should become the active window.
   MockXConnection::InitMapEvent(&event, xid2);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   EXPECT_EQ(xid2, xconn_->focused_xid());
   ASSERT_TRUE(lm_->active_toplevel_ != NULL);
   EXPECT_EQ(xid2, lm_->active_toplevel_->win()->xid());
   EXPECT_FALSE(info->all_buttons_grabbed);
   EXPECT_TRUE(info2->all_buttons_grabbed);
 
   // Now send the appropriate FocusOut and FocusIn events.
   SendFocusEvents(xid, xid2);
-  EXPECT_EQ(xid2, wm_->active_window_xid());
+  EXPECT_EQ(xid2, GetActiveWindowProperty());
   EXPECT_TRUE(info->all_buttons_grabbed);
   EXPECT_FALSE(info2->all_buttons_grabbed);
 
   // Now send a _NET_ACTIVE_WINDOW message asking the window manager to
   // focus the first window.
   MockXConnection::InitClientMessageEvent(
       &event,
       xid,   // window to focus
       wm_->GetXAtom(ATOM_NET_ACTIVE_WINDOW),
       1,     // source indication: client app
       CurrentTime,
       xid2,  // currently-active window
       None);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   EXPECT_EQ(xid, xconn_->focused_xid());
   ASSERT_TRUE(lm_->active_toplevel_ != NULL);
   EXPECT_EQ(xid, lm_->active_toplevel_->win()->xid());
 
   // Send the appropriate FocusOut and FocusIn events.
   SendFocusEvents(xid2, xid);
-  EXPECT_EQ(xid, wm_->active_window_xid());
+  EXPECT_EQ(xid, GetActiveWindowProperty());
   EXPECT_FALSE(info->all_buttons_grabbed);
   EXPECT_TRUE(info2->all_buttons_grabbed);
 
   // Unmap the first window and check that the second window gets focused.
   MockXConnection::InitUnmapEvent(&event, xid);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   EXPECT_EQ(xid2, xconn_->focused_xid());
   ASSERT_TRUE(lm_->active_toplevel_ != NULL);
   EXPECT_EQ(xid2, lm_->active_toplevel_->win()->xid());
 
   SendFocusEvents(None, xid2);
-  EXPECT_EQ(xid2, wm_->active_window_xid());
+  EXPECT_EQ(xid2, GetActiveWindowProperty());
   EXPECT_FALSE(info2->all_buttons_grabbed);
 }
 
 TEST_F(LayoutManagerTest, ConfigureTransient) {
   XEvent event;
 
   // Create and map a toplevel window.
   XWindow owner_xid = CreateSimpleWindow();
   MockXConnection::WindowInfo* owner_info =
       xconn_->GetWindowInfoOrDie(owner_xid);
@@ skipping 65 matching lines @@
   // Create a window.
   XWindow xid = CreateSimpleWindow();
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
 
   // Send CreateNotify, MapNotify, and FocusNotify events.
   XEvent event;
   SendInitialEventsForWindow(xid);
   EXPECT_EQ(xid, xconn_->focused_xid());
   SendFocusEvents(xconn_->GetRootWindow(), xid);
   EXPECT_FALSE(info->all_buttons_grabbed);
-  EXPECT_EQ(xid, wm_->active_window_xid());
+  EXPECT_EQ(xid, GetActiveWindowProperty());
   EXPECT_TRUE(wm_->GetWindow(xid)->focused());
 
   // Now create a transient window.
   XWindow transient_xid = CreateSimpleWindow();
   MockXConnection::WindowInfo* transient_info =
       xconn_->GetWindowInfoOrDie(transient_xid);
   transient_info->transient_for = xid;
 
   // Send CreateNotify and MapNotify events for the transient window.
   SendInitialEventsForWindow(transient_xid);
 
   // We should ask the X server to focus the transient window as soon as it
   // gets mapped.
   EXPECT_EQ(transient_xid, xconn_->focused_xid());
 
   // Send FocusOut and FocusIn events and check that we add a passive
   // button grab on the owner window and remove the grab on the transient.
   SendFocusEvents(xid, transient_xid);
   EXPECT_TRUE(info->all_buttons_grabbed);
   EXPECT_FALSE(transient_info->all_buttons_grabbed);
   EXPECT_FALSE(wm_->GetWindow(xid)->focused());
   EXPECT_TRUE(wm_->GetWindow(transient_xid)->focused());
 
-  // _NET_ACTIVE_WINDOW should still be set to the owner instead of the
-  // transient window, though.
-  EXPECT_EQ(xid, wm_->active_window_xid());
+  // _NET_ACTIVE_WINDOW should also be set to the transient window (EWMH is
+  // vague about this, but it seems to match what other WMs do).
+  EXPECT_EQ(transient_xid, GetActiveWindowProperty());
 
   // Now simulate a button press on the owner window.
   xconn_->set_pointer_grab_xid(xid);
   MockXConnection::InitButtonPressEvent(&event, xid, 0, 0, 1);  // x, y, button
   EXPECT_TRUE(wm_->HandleEvent(&event));
 
   // LayoutManager should remove the active pointer grab and try to focus
   // the owner window.
   EXPECT_EQ(None, xconn_->pointer_grab_xid());
   EXPECT_EQ(xid, xconn_->focused_xid());
 
   // After the FocusOut and FocusIn events come through, the button grabs
   // should be updated again.
   SendFocusEvents(transient_xid, xid);
   EXPECT_FALSE(info->all_buttons_grabbed);
   EXPECT_TRUE(transient_info->all_buttons_grabbed);
-  EXPECT_EQ(xid, wm_->active_window_xid());
+  EXPECT_EQ(xid, GetActiveWindowProperty());
   EXPECT_TRUE(wm_->GetWindow(xid)->focused());
   EXPECT_FALSE(wm_->GetWindow(transient_xid)->focused());
 
   // Give the focus back to the transient window.
   xconn_->set_pointer_grab_xid(transient_xid);
   MockXConnection::InitButtonPressEvent(&event, transient_xid, 0, 0, 1);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   EXPECT_EQ(transient_xid, xconn_->focused_xid());
   SendFocusEvents(xid, transient_xid);
+  EXPECT_EQ(transient_xid, GetActiveWindowProperty());
   EXPECT_FALSE(wm_->GetWindow(xid)->focused());
   EXPECT_TRUE(wm_->GetWindow(transient_xid)->focused());
 
   // Set the transient window as modal.
   MockXConnection::InitClientMessageEvent(
       &event, transient_xid, wm_->GetXAtom(ATOM_NET_WM_STATE),
       1, wm_->GetXAtom(ATOM_NET_WM_STATE_MODAL), None, None);
   EXPECT_TRUE(wm_->HandleEvent(&event));
 
   // Since it's modal, the transient window should still keep the focus
   // after a button press in the owner window.
   xconn_->set_pointer_grab_xid(xid);
   MockXConnection::InitButtonPressEvent(&event, xid, 0, 0, 1);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   EXPECT_EQ(transient_xid, xconn_->focused_xid());
+  EXPECT_EQ(transient_xid, GetActiveWindowProperty());
   EXPECT_FALSE(wm_->GetWindow(xid)->focused());
   EXPECT_TRUE(wm_->GetWindow(transient_xid)->focused());
 
-  // Now create another top-level window, which we'll switch to
+  // Now create another toplevel window, which we'll switch to
   // automatically.
   XWindow xid2 = CreateSimpleWindow();
   MockXConnection::WindowInfo* info2 = xconn_->GetWindowInfoOrDie(xid2);
   SendInitialEventsForWindow(xid2);
   EXPECT_EQ(xid2, xconn_->focused_xid());
   SendFocusEvents(transient_xid, xid2);
-  EXPECT_EQ(xid2, wm_->active_window_xid());
+  EXPECT_EQ(xid2, GetActiveWindowProperty());
   EXPECT_FALSE(wm_->GetWindow(xid)->focused());
   EXPECT_FALSE(wm_->GetWindow(transient_xid)->focused());
   EXPECT_TRUE(wm_->GetWindow(xid2)->focused());
 
   // When we cycle to the first toplevel window, its modal transient
   // window, rather than the toplevel itself, should get the focus.
   lm_->CycleActiveToplevelWindow(false);
   EXPECT_EQ(transient_xid, xconn_->focused_xid());
   SendFocusEvents(xid2, transient_xid);
-  EXPECT_EQ(xid, wm_->active_window_xid());
+  EXPECT_EQ(transient_xid, GetActiveWindowProperty());
   EXPECT_FALSE(wm_->GetWindow(xid)->focused());
   EXPECT_TRUE(wm_->GetWindow(transient_xid)->focused());
   EXPECT_FALSE(wm_->GetWindow(xid2)->focused());
 
   // Switch back to the second toplevel window.
   lm_->CycleActiveToplevelWindow(false);
   EXPECT_EQ(xid2, xconn_->focused_xid());
   SendFocusEvents(transient_xid, xid2);
-  EXPECT_EQ(xid2, wm_->active_window_xid());
+  EXPECT_EQ(xid2, GetActiveWindowProperty());
   EXPECT_FALSE(wm_->GetWindow(xid)->focused());
   EXPECT_FALSE(wm_->GetWindow(transient_xid)->focused());
   EXPECT_TRUE(wm_->GetWindow(xid2)->focused());
 
   // Make the transient window non-modal.
   MockXConnection::InitClientMessageEvent(
       &event, transient_xid, wm_->GetXAtom(ATOM_NET_WM_STATE),
       0, wm_->GetXAtom(ATOM_NET_WM_STATE_MODAL), None, None);
   EXPECT_TRUE(wm_->HandleEvent(&event));
 
   // Now send a _NET_ACTIVE_WINDOW message asking to focus the transient.
   // We should switch back to the first toplevel, and the transient should
   // get the focus.
   MockXConnection::InitClientMessageEvent(
       &event, transient_xid, wm_->GetXAtom(ATOM_NET_ACTIVE_WINDOW),
       1, 21321, 0, None);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   EXPECT_EQ(transient_xid, xconn_->focused_xid());
   MockXConnection::InitFocusOutEvent(
       &event, xid2, NotifyNormal, NotifyNonlinear);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   MockXConnection::InitFocusInEvent(
       &event, transient_xid, NotifyNormal, NotifyNonlinear);
   EXPECT_TRUE(wm_->HandleEvent(&event));
-  EXPECT_EQ(xid, wm_->active_window_xid());
+  EXPECT_EQ(transient_xid, GetActiveWindowProperty());
   EXPECT_FALSE(wm_->GetWindow(xid)->focused());
   EXPECT_TRUE(wm_->GetWindow(transient_xid)->focused());
   EXPECT_FALSE(wm_->GetWindow(xid2)->focused());
 
   // Switch to overview mode.  We should give the focus back to the root
   // window (we don't want the transient to receive keypresses at this
   // point).
   lm_->SetMode(LayoutManager::MODE_OVERVIEW);
   EXPECT_EQ(xconn_->GetRootWindow(), xconn_->focused_xid());
   MockXConnection::InitFocusOutEvent(
       &event, transient_xid, NotifyWhileGrabbed, NotifyNonlinear);
   EXPECT_TRUE(wm_->HandleEvent(&event));
   MockXConnection::InitFocusInEvent(
       &event, transient_xid, NotifyWhileGrabbed, NotifyPointer);
   EXPECT_FALSE(wm_->HandleEvent(&event));
-  EXPECT_EQ(None, wm_->active_window_xid());
+  EXPECT_EQ(None, GetActiveWindowProperty());
   EXPECT_FALSE(wm_->GetWindow(xid)->focused());
   EXPECT_FALSE(wm_->GetWindow(transient_xid)->focused());
   EXPECT_FALSE(wm_->GetWindow(xid2)->focused());
 }
 
 TEST_F(LayoutManagerTest, MultipleTransients) {
   // Create a window.
   XWindow owner_xid = CreateSimpleWindow();
   MockXConnection::WindowInfo* owner_info =
       xconn_->GetWindowInfoOrDie(owner_xid);
@@ skipping 290 matching lines @@
             stage->GetStackingIndex(win->actor()));
   EXPECT_LT(stage->GetStackingIndex(win->actor()),
             stage->GetStackingIndex(lower_stacking_actor));
 }
 
 }  // namespace chromeos
 
 int main(int argc, char **argv) {
   return chromeos::InitAndRunTests(&argc, argv, &FLAGS_logtostderr);
 }