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

panels/panel_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 <gflags/gflags.h>
 #include <gtest/gtest.h>
 
 #include "base/scoped_ptr.h"
@@ skipping 258 matching lines @@
 
   // Ask the window manager to make the second (middle) panel fullscreen.
   XEvent fullscreen_event;
   xconn_->InitClientMessageEvent(
       &fullscreen_event,
       panel2->content_xid(),
       wm_state_atom,
       1,  // add
       fullscreen_atom, 0, 0, 0);
   wm_->HandleEvent(&fullscreen_event);
-  NotifyWindowAboutSize(panel2->content_win());
+  SendConfigureNotifyEvent(panel2->content_xid());
 
   // Check that the second panel is focused automatically, covering the
   // whole screen, and stacked above the other panels.
   EXPECT_TRUE(panel2->is_fullscreen());
   EXPECT_EQ(panel2->content_xid(), xconn_->focused_xid());
   TestPanelContentBounds(panel2, 0, 0, wm_->width(), wm_->height());
   EXPECT_TRUE(WindowIsInLayer(panel2->content_win(),
                               StackingManager::LAYER_FULLSCREEN_WINDOW));
   TestIntArrayProperty(
       panel2->content_xid(), wm_state_atom, 1, fullscreen_atom);
 
   // Now send a message making the third (leftmost) panel fullscreen.  The
   // second panel should be made non-fullscreen.
   fullscreen_event.xclient.window = panel3->content_xid();
   wm_->HandleEvent(&fullscreen_event);
-  NotifyWindowAboutSize(panel2->content_win());
-  NotifyWindowAboutSize(panel3->content_win());
+  SendConfigureNotifyEvent(panel2->content_xid());
+  SendConfigureNotifyEvent(panel3->content_xid());
 
   EXPECT_TRUE(panel3->is_fullscreen());
   EXPECT_EQ(panel3->content_xid(), xconn_->focused_xid());
   TestPanelContentBounds(panel3, 0, 0, wm_->width(), wm_->height());
   EXPECT_TRUE(WindowIsInLayer(panel3->content_win(),
                               StackingManager::LAYER_FULLSCREEN_WINDOW));
   TestIntArrayProperty(
       panel3->content_xid(), wm_state_atom, 1, fullscreen_atom);
 
   EXPECT_FALSE(panel2->is_fullscreen());
@@ skipping 17 matching lines @@
   EXPECT_TRUE(WindowIsInLayer(panel3->content_win(),
                               StackingManager::LAYER_FULLSCREEN_WINDOW));
   EXPECT_EQ(rightmost_panel_right, panel2->right());
   EXPECT_EQ(middle_panel_right, panel3->right());
 
   // Now send a message asking to unfullscreen the third panel and check
   // that it gets restored to its regular middle position.  It should still
   // keep the focus.
   fullscreen_event.xclient.data.l[0] = 0;  // remove
   wm_->HandleEvent(&fullscreen_event);
-  NotifyWindowAboutSize(panel3->content_win());
+  SendConfigureNotifyEvent(panel3->content_xid());
   EXPECT_FALSE(panel3->is_fullscreen());
   EXPECT_EQ(panel3->content_xid(), xconn_->focused_xid());
   TestPanelContentBounds(panel3,
                          middle_panel_right - content_width,  // x
                          wm_->height() - content_height,      // y
                          content_width, content_height);
   EXPECT_TRUE(WindowIsInLayer(panel3->content_win(),
                               StackingManager::LAYER_PACKED_PANEL_IN_BAR));
   TestIntArrayProperty(panel3->content_xid(), wm_state_atom, 0);
 
@@ skipping 141 matching lines @@
   ASSERT_TRUE(
       xconn_->GetWindowGeometry(xconn_->GetRootWindow(), &root_geometry));
 
   Panel* panel = CreatePanel(200, 400, 20);
   ASSERT_EQ(panel->content_xid(), xconn_->focused_xid());
   ASSERT_EQ(panel->content_xid(), GetActiveWindowProperty());
 
   // Create a transient window owned by the panel.
   const int transient_x = 30, transient_y = 40;
   const int transient_width = 300, transient_height = 200;
-  XWindow transient_xid = CreateBasicWindow(transient_x, transient_y,
-                                            transient_width, transient_height);
+  XWindow transient_xid =
+      CreateBasicWindow(
+          Rect(transient_x, transient_y, transient_width, transient_height));
   // Say that we support the WM_DELETE_WINDOW protocol so that the window
   // manager will try to close us when needed.
   AppendAtomToProperty(transient_xid,
                        xconn_->GetAtomOrDie("WM_PROTOCOLS"),
                        xconn_->GetAtomOrDie("WM_DELETE_WINDOW"));
   MockXConnection::WindowInfo* transient_info =
       xconn_->GetWindowInfoOrDie(transient_xid);
   transient_info->transient_for = panel->content_xid();
   SendInitialEventsForWindow(transient_xid);
   Window* transient_win = wm_->GetWindowOrDie(transient_xid);
@@ skipping 43 matching lines @@
   EXPECT_GT(GetNumDeleteWindowMessagesForWindow(transient_xid),
             initial_num_delete_messages);
 
   // Unmap the transient window.
   xconn_->UnmapWindow(transient_xid);
   XEvent event;
   xconn_->InitUnmapEvent(&event, transient_xid);
   wm_->HandleEvent(&event);
 
   // Now create a toplevel window, which should get focused.
-  XWindow toplevel_xid = CreateToplevelWindow(1, 0, 0, 0, 1024, 768);
+  XWindow toplevel_xid = CreateToplevelWindow(1, 0, Rect(0, 0, 1024, 768));
   SendInitialEventsForWindow(toplevel_xid);
   ASSERT_EQ(toplevel_xid, xconn_->focused_xid());
   ASSERT_EQ(toplevel_xid, GetActiveWindowProperty());
 
   // Create another transient with the CHROME_INFO_BUBBLE type, which
   // should allow us to place it wherever we want.
   const int infobubble_x = 40, infobubble_y = 50;
   const int infobubble_width = 200, infobubble_height = 20;
   XWindow infobubble_xid = CreateBasicWindow(
-      infobubble_x, infobubble_y, infobubble_width, infobubble_height);
+      Rect(infobubble_x, infobubble_y, infobubble_width, infobubble_height));
   MockXConnection::WindowInfo* infobubble_info =
       xconn_->GetWindowInfoOrDie(infobubble_xid);
   wm_->wm_ipc()->SetWindowType(
       infobubble_xid, chromeos::WM_IPC_WINDOW_CHROME_INFO_BUBBLE, NULL);
   infobubble_info->transient_for = panel->content_xid();
   SendInitialEventsForWindow(infobubble_xid);
 
   EXPECT_EQ(infobubble_x, infobubble_info->bounds.x);
   EXPECT_EQ(infobubble_y, infobubble_info->bounds.y);
   EXPECT_EQ(infobubble_width, infobubble_info->bounds.width);
@@ skipping 112 matching lines @@
   EXPECT_EQ(kNewTitlebarBounds, titlebar_info->bounds);
   EXPECT_EQ(kNewContentBounds, content_actor->GetBounds());
   EXPECT_EQ(kNewContentBounds, content_info->bounds);
 }
 
 }  // namespace window_manager
 
 int main(int argc, char** argv) {
   return window_manager::InitAndRunTests(&argc, argv, &FLAGS_logtostderr);
 }