wm: Update a lot of code to use structs from geometry.h.

test_lib.cc

 // Copyright (c) 2011 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/test_lib.h"
 
 #include <vector>
 
 extern "C" {
 #include <X11/XF86keysym.h>
@@ skipping 149 matching lines @@
                               compositor_.get(),
                               dbus_.get()));
 }
 
 void BasicWindowManagerTest::CreateAndInitNewWm() {
   CreateNewWm();
   ASSERT_TRUE(wm_->Init());
 }
 
 XWindow BasicWindowManagerTest::CreateSimpleWindow() {
-  return CreateBasicWindow(0, 0, 640, 480);
+  return CreateBasicWindow(Rect(0, 0, 640, 480));
 }
 
-XWindow BasicWindowManagerTest::CreateBasicWindow(int x, int y,
-                                                  int width, int height) {
+XWindow BasicWindowManagerTest::CreateBasicWindow(const Rect& bounds) {
   return xconn_->CreateWindow(
       xconn_->GetRootWindow(),
-      Rect(x, y, width, height),
+      bounds,
       false,  // override redirect
       false,  // input only
       0, 0);  // event mask, visual
 }
 
 XWindow BasicWindowManagerTest::CreateToplevelWindow(int tab_count,
                                                      int selected_tab,
-                                                     int x, int y,
-                                                     int width, int height) {
-  XWindow xid = CreateBasicWindow(x, y, width, height);
+                                                     const Rect& bounds) {
+  XWindow xid = CreateBasicWindow(bounds);
   ChangeTabInfo(xid, tab_count, selected_tab, wm_->GetCurrentTimeFromServer());
   return xid;
 }
 
 void BasicWindowManagerTest::ChangeTabInfo(XWindow toplevel_xid,
                                            int tab_count,
                                            int selected_tab,
                                            uint32_t timestamp) {
   std::vector<int> params;
   params.push_back(tab_count);
   params.push_back(selected_tab);
   params.push_back(timestamp);
   wm_->wm_ipc()->SetWindowType(
       toplevel_xid, chromeos::WM_IPC_WINDOW_CHROME_TOPLEVEL, &params);
 }
 
 XWindow BasicWindowManagerTest::CreateFavIconWindow(XWindow snapshot_xid,
-                                                    int width, int height) {
+                                                    const Size& size) {
   return CreateDecorationWindow(snapshot_xid,
                                 chromeos::WM_IPC_WINDOW_CHROME_TAB_FAV_ICON,
-                                width, height);
+                                size);
 }
 
 XWindow BasicWindowManagerTest::CreateTitleWindow(XWindow snapshot_xid,
-                                                  int width, int height) {
+                                                  const Size& size) {
   return CreateDecorationWindow(snapshot_xid,
                                 chromeos::WM_IPC_WINDOW_CHROME_TAB_TITLE,
-                                width, height);
+                                size);
 }
 
 XWindow BasicWindowManagerTest::CreateDecorationWindow(
     XWindow snapshot_xid,
     chromeos::WmIpcWindowType type,
-    int width, int height) {
-  XWindow xid = CreateBasicWindow(0, 0, width, height);
+    const Size& size) {
+  XWindow xid = CreateBasicWindow(Rect(Point(0, 0), size));
   std::vector<int> params;
   params.push_back(snapshot_xid);
   wm_->wm_ipc()->SetWindowType(xid, type, &params);
 
   return xid;
 }
 
 XWindow BasicWindowManagerTest::CreateSnapshotWindow(XWindow parent_xid,
                                                      int index,
-                                                     int x, int y,
-                                                     int width, int height) {
-  XWindow xid = CreateBasicWindow(x, y, width, height);
+                                                     const Rect& bounds) {
+  XWindow xid = CreateBasicWindow(bounds);
   std::vector<int> params;
   params.push_back(parent_xid);
   params.push_back(index);
   wm_->wm_ipc()->SetWindowType(
       xid, chromeos::WM_IPC_WINDOW_CHROME_TAB_SNAPSHOT, &params);
 
   return xid;
 }
 
 XWindow BasicWindowManagerTest::CreateSimpleSnapshotWindow(XWindow parent_xid,
                                                            int index) {
-  return CreateSnapshotWindow(parent_xid, index, 0, 0, 320, 240);
+  return CreateSnapshotWindow(parent_xid, index, Rect(0, 0, 320, 240));
 }
 
-XWindow BasicWindowManagerTest::CreatePanelTitlebarWindow(
-    int width, int height) {
-  XWindow xid = CreateBasicWindow(0, 0, width, height);
+XWindow BasicWindowManagerTest::CreatePanelTitlebarWindow(const Size& size) {
+  XWindow xid = CreateBasicWindow(Rect(Point(0, 0), size));
   wm_->wm_ipc()->SetWindowType(
       xid, chromeos::WM_IPC_WINDOW_CHROME_PANEL_TITLEBAR, NULL);
   return xid;
 }
 
-XWindow BasicWindowManagerTest::CreatePanelContentWindow(
-    int width, int height, XWindow titlebar_xid) {
-  XWindow xid = CreateBasicWindow(0, 0, width, height);
+XWindow BasicWindowManagerTest::CreatePanelContentWindow(const Size& size,
+                                                         XWindow titlebar_xid) {
+  XWindow xid = CreateBasicWindow(Rect(Point(0, 0), size));
   std::vector<int> params;
   params.push_back(titlebar_xid);
   params.push_back(new_panels_should_be_expanded_ ? 1 : 0);
   params.push_back(new_panels_should_take_focus_ ? 1 : 0);
   params.push_back(creator_content_xid_for_new_panels_);
   params.push_back(resize_type_for_new_panels_);
   wm_->wm_ipc()->SetWindowType(
       xid, chromeos::WM_IPC_WINDOW_CHROME_PANEL_CONTENT, &params);
   return xid;
 }
 
 Panel* BasicWindowManagerTest::CreatePanel(
     int width, int titlebar_height, int content_height) {
-  XWindow titlebar_xid = CreatePanelTitlebarWindow(width, titlebar_height);
+  XWindow titlebar_xid =
+      CreatePanelTitlebarWindow(Size(width, titlebar_height));
   SendInitialEventsForWindow(titlebar_xid);
-  XWindow content_xid = CreatePanelContentWindow(
-      width, content_height, titlebar_xid);
+  XWindow content_xid =
+      CreatePanelContentWindow(Size(width, content_height), titlebar_xid);
   SendInitialEventsForWindow(content_xid);
   Panel* panel = wm_->panel_manager_->panel_bar_->GetPanelByWindow(
       *(wm_->GetWindow(content_xid)));
   CHECK(panel);
   return panel;
 }
 
 void BasicWindowManagerTest::SendInitialEventsForWindow(XWindow xid) {
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
   XEvent event;
 
   // Send a CreateWindowEvent, a MapRequest event (if this is a
   // non-override-redirect window), and a MapNotify event (if the window
   // got mapped).  After each event, send a ConfigureNotify if the window
   // was configured by the window manager.
   xconn_->InitCreateWindowEvent(&event, xid);
   int initial_num_configures = info->num_configures;
   wm_->HandleEvent(&event);
   if (info->num_configures != initial_num_configures) {
-    xconn_->InitConfigureNotifyEvent(&event, xid);
-    wm_->HandleEvent(&event);
+    SendConfigureNotifyEvent(xid);
     initial_num_configures = info->num_configures;
   }
 
   if (!info->override_redirect) {
     xconn_->InitMapRequestEvent(&event, xid);
     wm_->HandleEvent(&event);
     EXPECT_TRUE(info->mapped);
 
     if (info->num_configures != initial_num_configures) {
-      xconn_->InitConfigureNotifyEvent(&event, xid);
-      wm_->HandleEvent(&event);
+      SendConfigureNotifyEvent(xid);
       initial_num_configures = info->num_configures;
     }
   }
 
   if (info->mapped) {
     xconn_->InitMapEvent(&event, xid);
     wm_->HandleEvent(&event);
     if (info->num_configures != initial_num_configures) {
-      xconn_->InitConfigureNotifyEvent(&event, xid);
-      wm_->HandleEvent(&event);
+      SendConfigureNotifyEvent(xid);
       initial_num_configures = info->num_configures;
     }
   }
 }
 
 void BasicWindowManagerTest::SendUnmapAndDestroyEventsForWindow(XWindow xid) {
   XEvent event;
   xconn_->InitUnmapEvent(&event, xid);
   wm_->HandleEvent(&event);
   xconn_->InitDestroyWindowEvent(&event, xid);
@@ skipping 71 matching lines @@
   XEvent event;
   xconn_->InitClientMessageEvent(
       &event, xid, xconn_->GetAtomOrDie("_NET_ACTIVE_WINDOW"),
       1,      // source indication (1 is from application)
       0,      // timestamp
       0,      // requestor's currently-active window
       0, 0);  // unused
   wm_->HandleEvent(&event);
 }
 
-void BasicWindowManagerTest::NotifyWindowAboutSize(Window* win) {
-  win->HandleConfigureNotify(win->client_width(), win->client_height());
+void BasicWindowManagerTest::SendConfigureNotifyEvent(XWindow xid) {
+  XEvent event;
+  xconn_->InitConfigureNotifyEvent(&event, xid);
+  if (xconn_->stacked_xids().Contains(xid)) {
+    const XWindow* above_xid = xconn_->stacked_xids().GetUnder(xid);
+    event.xconfigure.above = above_xid ? *above_xid : 0;
+  }
+  wm_->HandleEvent(&event);
 }
 
 void BasicWindowManagerTest::SetLoggedInState(bool logged_in) {
   XAtom logged_in_xatom = xconn_->GetAtomOrDie("_CHROME_LOGGED_IN");
   xconn_->SetIntProperty(xconn_->GetRootWindow(),
                          logged_in_xatom,
                          logged_in_xatom,  // type; arbitrary
                          logged_in ? 1 : 0);
 
   if (wm_.get()) {
@@ skipping 254 matching lines @@
   stage_->AddActor(group1_.get());
   stage_->AddActor(group3_.get());
   group1_->AddActor(group2_.get());
   group2_->AddActor(rect1_.get());
   group3_->AddActor(group4_.get());
   group4_->AddActor(rect2_.get());
   group4_->AddActor(rect3_.get());
 }
 
 }  // namespace window_manager