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

layout/layout_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 <string>
 #include <tr1/memory>
 #include <vector>
 
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
@@ skipping 693 matching lines @@
   // We should've sent it a synthetic ConfigureNotify event containing its
   // current position and size.
   ASSERT_EQ(static_cast<size_t>(1), info->configure_notify_events.size());
   EXPECT_EQ(lm_->x(), info->configure_notify_events[0].x);
   EXPECT_EQ(lm_->y(), info->configure_notify_events[0].y);
   EXPECT_EQ(lm_->width(), info->configure_notify_events[0].width);
   EXPECT_EQ(lm_->height(), info->configure_notify_events[0].height);
 }
 
 TEST_F(LayoutManagerTest, ChangeCurrentSnapshot) {
-  XWindow toplevel1_xid = CreateToplevelWindow(2, 0, 0, 0, 640, 480);
+  XWindow toplevel1_xid = CreateToplevelWindow(2, 0, Rect(0, 0, 640, 480));
   SendInitialEventsForWindow(toplevel1_xid);
   MockXConnection::WindowInfo* info1 =
       xconn_->GetWindowInfoOrDie(toplevel1_xid);
-  XWindow toplevel2_xid = CreateToplevelWindow(2, 0, 0, 0, 640, 480);
+  XWindow toplevel2_xid = CreateToplevelWindow(2, 0, Rect(0, 0, 640, 480));
   SendInitialEventsForWindow(toplevel2_xid);
   MockXConnection::WindowInfo* info2 =
       xconn_->GetWindowInfoOrDie(toplevel2_xid);
 
   // Create some snapshot windows for the first toplevel.
   XWindow xid11 = CreateSimpleSnapshotWindow(toplevel1_xid, 0);
   SendInitialEventsForWindow(xid11);
   XWindow xid12 = CreateSimpleSnapshotWindow(toplevel1_xid, 1);
   SendInitialEventsForWindow(xid12);
   ChangeTabInfo(toplevel1_xid, 2, 1, wm_->GetCurrentTimeFromServer());
@@ skipping 133 matching lines @@
   EXPECT_NE(lm_->GetSnapshotWindowByXid(xid11), lm_->current_snapshot_);
   EXPECT_NE(lm_->snapshots_[0].get(), lm_->current_snapshot_);
 
   // The third snapshot (third one on first toplevel) should now be current.
   EXPECT_EQ(lm_->GetSnapshotWindowByXid(xid13), lm_->current_snapshot_);
   EXPECT_EQ(lm_->snapshots_[2].get(), lm_->current_snapshot_);
 }
 
 TEST_F(LayoutManagerTest, OverviewFocus) {
   // Create and map a toplevel window.
-  XWindow toplevel_xid = CreateToplevelWindow(2, 0, 0, 0, 640, 480);
+  XWindow toplevel_xid = CreateToplevelWindow(2, 0, Rect(0, 0, 640, 480));
   SendInitialEventsForWindow(toplevel_xid);
   MockXConnection::WindowInfo* toplevel_info =
       xconn_->GetWindowInfoOrDie(toplevel_xid);
 
   // The toplevel window should get the focus, the active window
   // property should be updated, and there shouldn't be a button grab
   // on the window.
   EXPECT_EQ(toplevel_xid, xconn_->focused_xid());
   EXPECT_EQ(toplevel_xid, GetActiveWindowProperty());
   EXPECT_FALSE(toplevel_info->button_is_grabbed(AnyButton));
@@ skipping 64 matching lines @@
 TEST_F(LayoutManagerTest, OverviewSpacing) {
   const int window_width = 640;
   const int window_height = 480;
 
   // Create a background actor.
   Compositor::ColoredBoxActor* background = compositor_->CreateColoredBox(
       window_width, window_height, Compositor::Color());
   lm_->SetBackground(background);
 
   // Create and map a toplevel window.
-  XWindow toplevel_xid = CreateToplevelWindow(2, 0, 0, 0,
-                                              window_width, window_height);
+  XWindow toplevel_xid =
+      CreateToplevelWindow(2, 0, Rect(0, 0, window_width, window_height));
   SendInitialEventsForWindow(toplevel_xid);
 
   // Create and map a second toplevel window.
-  XWindow toplevel_xid2 = CreateToplevelWindow(1, 0, 0, 0,
-                                               window_width, window_height);
+  XWindow toplevel_xid2 =
+      CreateToplevelWindow(1, 0, Rect(0, 0, window_width, window_height));
   SendInitialEventsForWindow(toplevel_xid2);
 
   // Create an associated snapshot window with some "realistic"
   // values.  (The numbers here don't represent the values that Chrome
   // is using to make the snapshots, they're just reasonable values.)
   const int snapshot_height = MockXConnection::kDisplayHeight / 2;
   const int snapshot_width = snapshot_height * 1024 / 1280;
-  XWindow snapshot = CreateSnapshotWindow(toplevel_xid, 0, 0, 0,
-                                          snapshot_width, snapshot_height);
+  XWindow snapshot =
+      CreateSnapshotWindow(
+          toplevel_xid, 0, Rect(0, 0, snapshot_width, snapshot_height));
   SendInitialEventsForWindow(snapshot);
-  XWindow snapshot_title = CreateTitleWindow(snapshot, snapshot_width, 16);
+  XWindow snapshot_title =
+      CreateTitleWindow(snapshot, Size(snapshot_width, 16));
   SendInitialEventsForWindow(snapshot_title);
-  XWindow snapshot_fav_icon = CreateFavIconWindow(snapshot, 16, 16);
+  XWindow snapshot_fav_icon = CreateFavIconWindow(snapshot, Size(16, 16));
   SendInitialEventsForWindow(snapshot_fav_icon);
 
   // This is the vertical offset to center the background.
   int centering_offset = -(MockXConnection::kDisplayHeight *
                            LayoutManager::kBackgroundExpansionFactor -
                            MockXConnection::kDisplayHeight) / 2;
 
   // The background should not be scrolled horizontally yet.
   EXPECT_EQ(0, background->GetX());
   EXPECT_EQ(centering_offset, background->GetY());
 
   // Now switch to overview mode.
   lm_->SetMode(LayoutManager::MODE_OVERVIEW);
 
   // Now create and map a second snapshot window.
-  XWindow snapshot2 = CreateSnapshotWindow(toplevel_xid, 1, 0, 0,
-                                           snapshot_width, snapshot_height);
+  XWindow snapshot2 =
+      CreateSnapshotWindow(
+          toplevel_xid, 1, Rect(0, 0, snapshot_width, snapshot_height));
   SendInitialEventsForWindow(snapshot2);
-  XWindow snapshot2_title = CreateTitleWindow(snapshot2, snapshot_width, 16);
+  XWindow snapshot2_title =
+      CreateTitleWindow(snapshot2, Size(snapshot_width, 16));
   SendInitialEventsForWindow(snapshot2_title);
-  XWindow snapshot2_fav_icon = CreateFavIconWindow(snapshot2, 16, 16);
+  XWindow snapshot2_fav_icon = CreateFavIconWindow(snapshot2, Size(16, 16));
   SendInitialEventsForWindow(snapshot2_fav_icon);
   ChangeTabInfo(toplevel_xid, 2, 1, wm_->GetCurrentTimeFromServer());
   SendWindowTypeEvent(toplevel_xid);
 
   // Now create and map a third snapshot window, with the second
   // toplevel as its parent.
-  XWindow snapshot3 = CreateSnapshotWindow(toplevel_xid2, 0, 0, 0,
-                                           snapshot_width, snapshot_height);
+  XWindow snapshot3 =
+      CreateSnapshotWindow(
+          toplevel_xid2, 0, Rect(0, 0, snapshot_width, snapshot_height));
   SendInitialEventsForWindow(snapshot3);
-  XWindow snapshot3_title = CreateTitleWindow(snapshot3, snapshot_width, 16);
+  XWindow snapshot3_title =
+      CreateTitleWindow(snapshot3, Size(snapshot_width, 16));
   SendInitialEventsForWindow(snapshot3_title);
-  XWindow snapshot3_fav_icon = CreateFavIconWindow(snapshot3, 16, 16);
+  XWindow snapshot3_fav_icon = CreateFavIconWindow(snapshot3, Size(16, 16));
   SendInitialEventsForWindow(snapshot3_fav_icon);
   ChangeTabInfo(toplevel_xid2, 1, 0, wm_->GetCurrentTimeFromServer());
   SendWindowTypeEvent(toplevel_xid2);
 
   EXPECT_EQ(-(lm_->current_snapshot_->overview_x() +
               (lm_->current_snapshot_->overview_width() -
                lm_->width_) / 2),
             lm_->overview_panning_offset_);
 
   // Make sure the fav icon and title got hooked up correctly.
@@ skipping 277 matching lines @@
   wm_->HandleEvent(&net_active_win_event);
   EXPECT_EQ(LayoutManager::MODE_ACTIVE, lm_->mode());
   EXPECT_EQ(xid, xconn_->focused_xid());
 }
 
 // Test that LayoutManager resizes non-Chrome and toplevel Chrome windows
 // to fill the screen as soon as it gets MapRequest events about them.
 TEST_F(LayoutManagerTest, ResizeWindowsBeforeMapping) {
   // Create a small non-Chrome window and check that it gets resized to the
   // layout manager's dimensions on MapRequest.
-  const XWindow nonchrome_xid = CreateBasicWindow(0, 0, 50, 40);
+  const XWindow nonchrome_xid = CreateBasicWindow(Rect(0, 0, 50, 40));
   MockXConnection::WindowInfo* nonchrome_info =
       xconn_->GetWindowInfoOrDie(nonchrome_xid);
   XEvent event;
   xconn_->InitCreateWindowEvent(&event, nonchrome_xid);
   wm_->HandleEvent(&event);
   xconn_->InitMapRequestEvent(&event, nonchrome_xid);
   wm_->HandleEvent(&event);
   EXPECT_EQ(lm_->width(), nonchrome_info->bounds.width);
   EXPECT_EQ(lm_->height(), nonchrome_info->bounds.height);
 
   // We should do the same thing with toplevel Chrome windows.
-  const XWindow toplevel_xid = CreateToplevelWindow(1, 0, 0, 0, 50, 40);
+  const XWindow toplevel_xid =
+      CreateToplevelWindow(1, 0, Rect(0, 0, 50, 40));
   MockXConnection::WindowInfo* toplevel_info =
       xconn_->GetWindowInfoOrDie(toplevel_xid);
   xconn_->InitCreateWindowEvent(&event, toplevel_xid);
   wm_->HandleEvent(&event);
   xconn_->InitMapRequestEvent(&event, toplevel_xid);
   wm_->HandleEvent(&event);
   EXPECT_EQ(lm_->width(), toplevel_info->bounds.width);
   EXPECT_EQ(lm_->height(), toplevel_info->bounds.height);
 
   // Snapshot windows should retain their original dimensions.
   const int orig_width = 50, orig_height = 40;
   const XWindow snapshot_xid =
-      CreateSnapshotWindow(toplevel_xid, 0, 0, 0, orig_width, orig_height);
+      CreateSnapshotWindow(
+          toplevel_xid, 0, Rect(0, 0, orig_width, orig_height));
   MockXConnection::WindowInfo* snapshot_info =
       xconn_->GetWindowInfoOrDie(snapshot_xid);
   xconn_->InitCreateWindowEvent(&event, snapshot_xid);
   wm_->HandleEvent(&event);
   xconn_->InitMapRequestEvent(&event, snapshot_xid);
   wm_->HandleEvent(&event);
   EXPECT_EQ(orig_width, snapshot_info->bounds.width);
   EXPECT_EQ(orig_height, snapshot_info->bounds.height);
 
   // Transient windows should, too.
   const XWindow transient_xid =
-      CreateBasicWindow(0, 0, orig_width, orig_height);
+      CreateBasicWindow(Rect(0, 0, orig_width, orig_height));
   MockXConnection::WindowInfo* transient_info =
       xconn_->GetWindowInfoOrDie(transient_xid);
   transient_info->transient_for = toplevel_xid;
   xconn_->InitCreateWindowEvent(&event, transient_xid);
   wm_->HandleEvent(&event);
   xconn_->InitMapRequestEvent(&event, transient_xid);
   wm_->HandleEvent(&event);
   EXPECT_EQ(orig_width, transient_info->bounds.width);
   EXPECT_EQ(orig_height, transient_info->bounds.height);
 }
 
 // Test that the layout manager handles windows that claim to be transient
 // for already-transient windows reasonably -- see http://crosbug.com/3316.
 TEST_F(LayoutManagerTest, NestedTransients) {
   // Create a toplevel window.
   XWindow toplevel_xid = CreateSimpleWindow();
   SendInitialEventsForWindow(toplevel_xid);
   LayoutManager::ToplevelWindow* toplevel =
       lm_->GetToplevelWindowByWindow(*(wm_->GetWindowOrDie(toplevel_xid)));
   ASSERT_TRUE(toplevel != NULL);
 
   // Create a transient window.
   const int initial_width = 300, initial_height = 200;
   XWindow transient_xid =
-      CreateBasicWindow(0, 0, initial_width, initial_height);
+      CreateBasicWindow(Rect(0, 0, initial_width, initial_height));
   MockXConnection::WindowInfo* transient_info =
       xconn_->GetWindowInfoOrDie(transient_xid);
   transient_info->transient_for = toplevel_xid;
   SendInitialEventsForWindow(transient_xid);
 
   // Check that its initial size is preserved.
   EXPECT_EQ(initial_width, transient_info->bounds.width);
   EXPECT_EQ(initial_height, transient_info->bounds.height);
   EXPECT_TRUE(lm_->GetToplevelWindowOwningTransientWindow(
       *(wm_->GetWindowOrDie(transient_xid))) == toplevel);;
 
   // Now create a second transient window that says it's transient for the
   // first transient window.
   XWindow nested_transient_xid =
-      CreateBasicWindow(0, 0, initial_width, initial_height);
+      CreateBasicWindow(Rect(0, 0, initial_width, initial_height));
   MockXConnection::WindowInfo* nested_transient_info =
       xconn_->GetWindowInfoOrDie(nested_transient_xid);
   nested_transient_info->transient_for = transient_xid;
   SendInitialEventsForWindow(nested_transient_xid);
 
   // The second transient window should be treated as a transient of the
   // toplevel instead.  We check that it keeps its initial size rather than
   // being maximized.
   EXPECT_EQ(initial_width, nested_transient_info->bounds.width);
   EXPECT_EQ(initial_height, nested_transient_info->bounds.height);
   EXPECT_TRUE(lm_->GetToplevelWindowOwningTransientWindow(
       *(wm_->GetWindowOrDie(nested_transient_xid))) == toplevel);;
 
   // For good measure, do it all again with another transient window nested
   // one level deeper.
   XWindow another_transient_xid =
-      CreateBasicWindow(0, 0, initial_width, initial_height);
+      CreateBasicWindow(Rect(0, 0, initial_width, initial_height));
   MockXConnection::WindowInfo* another_transient_info =
       xconn_->GetWindowInfoOrDie(another_transient_xid);
   another_transient_info->transient_for = nested_transient_xid;
   SendInitialEventsForWindow(another_transient_xid);
   EXPECT_EQ(initial_width, another_transient_info->bounds.width);
   EXPECT_EQ(initial_height, another_transient_info->bounds.height);
   EXPECT_TRUE(lm_->GetToplevelWindowOwningTransientWindow(
       *(wm_->GetWindowOrDie(another_transient_xid))) == toplevel);;
 }
 
 // Check that the initial Chrome window appears onscreen immediately
 // instead of sliding in from the side.
 TEST_F(LayoutManagerTest, NoSlideForInitialWindow) {
   // Create a window and check that it's in the expected location.
-  XWindow xid = CreateToplevelWindow(0, 0, 0, 0, 640, 480);
+  XWindow xid =
+      CreateToplevelWindow(0, 0, Rect(0, 0, 640, 480));
   SendInitialEventsForWindow(xid);
   Window* win = wm_->GetWindowOrDie(xid);
   EXPECT_EQ(0, win->client_x());
   EXPECT_EQ(0, win->client_y());
   EXPECT_EQ(0, win->composited_x());
   EXPECT_EQ(0, win->composited_y());
 
   // The actor should've been moved immediately to its current location
   // instead of getting animated.
   MockCompositor::Actor* actor = GetMockActorForWindow(win);
   EXPECT_FALSE(actor->position_was_animated());
 
   // Now create a second window and check that it *does* get animated.
-  XWindow xid2 = CreateToplevelWindow(0, 0, 0, 0, 640, 480);
+  XWindow xid2 =
+      CreateToplevelWindow(0, 0, Rect(0, 0, 640, 480));
   SendInitialEventsForWindow(xid2);
   Window* win2 = wm_->GetWindowOrDie(xid2);
   EXPECT_EQ(0, win2->client_x());
   EXPECT_EQ(0, win2->client_y());
   EXPECT_EQ(0, win2->composited_x());
   EXPECT_EQ(0, win2->composited_y());
   MockCompositor::Actor* actor2 = GetMockActorForWindow(win2);
   EXPECT_TRUE(actor2->position_was_animated());
 }
 
@@ skipping 59 matching lines @@
   EXPECT_FALSE(win->wm_state_fullscreen());
   EXPECT_TRUE(WindowIsInLayer(win, StackingManager::LAYER_TOPLEVEL_WINDOW));
 
   // Make the window fullscreen again and check that it stays that way if a
   // transient window is opened for it.
   wm_->HandleEvent(&fullscreen_event);
   EXPECT_EQ(xid, xconn_->focused_xid());
   EXPECT_TRUE(win->wm_state_fullscreen());
   EXPECT_TRUE(WindowIsInLayer(win, StackingManager::LAYER_FULLSCREEN_WINDOW));
 
-  XWindow transient_xid = CreateBasicWindow(0, 0, 300, 300);
+  XWindow transient_xid = CreateBasicWindow(Rect(0, 0, 300, 300));
   MockXConnection::WindowInfo* transient_info =
       xconn_->GetWindowInfoOrDie(transient_xid);
   transient_info->transient_for = xid;
   SendInitialEventsForWindow(transient_xid);
   Window* transient_win = wm_->GetWindowOrDie(transient_xid);
   EXPECT_TRUE(win->wm_state_fullscreen());
   EXPECT_TRUE(WindowIsInLayer(win, StackingManager::LAYER_FULLSCREEN_WINDOW));
   EXPECT_TRUE(WindowIsInLayer(transient_win,
                               StackingManager::LAYER_FULLSCREEN_WINDOW));
 
@@ skipping 104 matching lines @@
   lm_ = wm_->layout_manager_.get();
   ASSERT_TRUE(lm_ != NULL);
   ASSERT_TRUE(lm_->background_.get() != NULL);
   MockCompositor::Actor* cast_lm_background =
       dynamic_cast<MockCompositor::Actor*>(lm_->background_.get());
   CHECK(cast_lm_background);
   EXPECT_FALSE(cast_lm_background->is_shown());
 
   // After the first Chrome window gets mapped, we should show the layout
   // manager background.
-  XWindow toplevel_xid = CreateToplevelWindow(2, 0, 0, 0, 640, 480);
+  XWindow toplevel_xid =
+      CreateToplevelWindow(2, 0, Rect(0, 0, 640, 480));
   SendInitialEventsForWindow(toplevel_xid);
   ASSERT_TRUE(lm_->background_.get() != NULL);
   EXPECT_TRUE(cast_lm_background->is_shown());
 
   // And after the window gets closed, we should hide the layout manager
   // background.
   XEvent event;
   xconn_->InitUnmapEvent(&event, toplevel_xid);
   wm_->HandleEvent(&event);
   ASSERT_TRUE(lm_->background_.get() != NULL);
@@ skipping 10 matching lines @@
   EXPECT_TRUE(xconn_->KeyIsGrabbed(xconn_->GetKeyCodeFromKeySym(XK_F2), 0));
 
   lm_->SetMode(LayoutManager::MODE_ACTIVE);
   EXPECT_FALSE(xconn_->KeyIsGrabbed(xconn_->GetKeyCodeFromKeySym(XK_F1), 0));
   EXPECT_FALSE(xconn_->KeyIsGrabbed(xconn_->GetKeyCodeFromKeySym(XK_F2), 0));
 }
 
 // Check that shadows only get displayed for transient windows.
 TEST_F(LayoutManagerTest, Shadows) {
   // Chrome toplevel windows shouldn't have shadows.
-  XWindow toplevel_xid = CreateToplevelWindow(2, 0, 0, 0, 200, 200);
+  XWindow toplevel_xid =
+      CreateToplevelWindow(2, 0, Rect(0, 0, 200, 200));
   SendInitialEventsForWindow(toplevel_xid);
   EXPECT_TRUE(wm_->GetWindowOrDie(toplevel_xid)->shadow() == NULL);
 
   // Neither should non-Chrome toplevel windows.
   XWindow other_xid = CreateSimpleWindow();
   SendInitialEventsForWindow(other_xid);
   EXPECT_TRUE(wm_->GetWindowOrDie(other_xid)->shadow() == NULL);
 
   // Or snapshot windows, or their title and fav icons windows.
   XWindow snapshot_xid = CreateSimpleSnapshotWindow(toplevel_xid, 0);
   SendInitialEventsForWindow(snapshot_xid);
   EXPECT_TRUE(wm_->GetWindowOrDie(snapshot_xid)->shadow() == NULL);
 
-  XWindow title_xid = CreateTitleWindow(snapshot_xid, 200, 16);
+  XWindow title_xid = CreateTitleWindow(snapshot_xid, Size(200, 16));
   SendInitialEventsForWindow(title_xid);
   EXPECT_TRUE(wm_->GetWindowOrDie(title_xid)->shadow() == NULL);
 
-  XWindow fav_icon_xid = CreateFavIconWindow(snapshot_xid, 16, 16);
+  XWindow fav_icon_xid = CreateFavIconWindow(snapshot_xid, Size(16, 16));
   SendInitialEventsForWindow(fav_icon_xid);
   EXPECT_TRUE(wm_->GetWindowOrDie(fav_icon_xid)->shadow() == NULL);
 
   // Transient windows should get shadows, though...
   XWindow transient_xid = CreateSimpleWindow();
   xconn_->GetWindowInfoOrDie(transient_xid)->transient_for = toplevel_xid;
   SendInitialEventsForWindow(transient_xid);
   ASSERT_TRUE(wm_->GetWindowOrDie(transient_xid)->shadow() != NULL);
   EXPECT_TRUE(wm_->GetWindowOrDie(transient_xid)->shadow()->is_shown());
 
@@ skipping 14 matching lines @@
   rgba_info->depth = 32;
   SendInitialEventsForWindow(rgba_xid);
   EXPECT_TRUE(wm_->GetWindowOrDie(rgba_xid)->shadow() == NULL);
 }
 
 // Check that we defer animating new windows onscreen until the client says
 // that they've been painted.
 TEST_F(LayoutManagerTest, DeferAnimationsUntilPainted) {
   // Create and map two windows.  Make the second one say that it supports
   // the _NET_WM_SYNC_REQUEST protocol.
-  XWindow xid1 = CreateToplevelWindow(2, 0, 0, 0, 200, 200);
+  XWindow xid1 =
+      CreateToplevelWindow(2, 0, Rect(0, 0, 200, 200));
   SendInitialEventsForWindow(xid1);
-  XWindow xid2 = CreateToplevelWindow(2, 0, 0, 0, 200, 200);
+  XWindow xid2 =
+      CreateToplevelWindow(2, 0, Rect(0, 0, 200, 200));
   ConfigureWindowForSyncRequestProtocol(xid2);
   SendInitialEventsForWindow(xid2);
 
   // Check that the second window got the focus, but that the first still
   // has its client window onscreen (since the second window hasn't said
   // that it's been painted yet).
   EXPECT_FALSE(WindowIsOffscreen(xid1));
   EXPECT_TRUE(WindowIsOffscreen(xid2));
   EXPECT_EQ(xid2, xconn_->focused_xid());
 
   // Tell the window manager that the second window has been painted and
   // check that it moves it onscreen.
   SendSyncRequestProtocolAlarm(xid2);
   EXPECT_TRUE(WindowIsOffscreen(xid1));
   EXPECT_FALSE(WindowIsOffscreen(xid2));
   EXPECT_EQ(xid2, xconn_->focused_xid());
 }
 
 // Check that we switch toplevel windows as needed when a modal transient
 // window gets mapped, or when the modal hint is set on an existing
 // transient window.
 TEST_F(LayoutManagerTest, SwitchToToplevelWithModalTransient) {
   // Create two toplevel windows.
-  XWindow xid1 = CreateToplevelWindow(2, 0, 0, 0, 200, 200);
+  XWindow xid1 =
+      CreateToplevelWindow(2, 0, Rect(0, 0, 200, 200));
   SendInitialEventsForWindow(xid1);
-  XWindow xid2 = CreateToplevelWindow(2, 0, 0, 0, 200, 200);
+  XWindow xid2 =
+      CreateToplevelWindow(2, 0, Rect(0, 0, 200, 200));
   SendInitialEventsForWindow(xid2);
 
   // The second toplevel should be focused initially.
   EXPECT_TRUE(WindowIsOffscreen(xid1));
   EXPECT_EQ(xid2, xconn_->focused_xid());
   EXPECT_EQ(xid2, GetActiveWindowProperty());
   EXPECT_FALSE(WindowIsOffscreen(xid2));
 
   // At first, the key bindings should be enabled.
   EXPECT_TRUE(lm_->active_mode_key_bindings_group_->enabled());
@@ skipping 133 matching lines @@
   LayoutManager::ToplevelWindow* toplevel =
       lm_->GetToplevelWindowByXid(toplevel_xid);
   ASSERT_TRUE(toplevel != NULL);
   EXPECT_EQ(toplevel,
             lm_->GetToplevelWindowOwningTransientWindow(
                 *(wm_->GetWindowOrDie(transient_xid))));
 }
 
 // Test that we close transient windows when their owners are unmapped.
 TEST_F(LayoutManagerTest, CloseTransientWindowsWhenOwnerIsUnmapped) {
-  XWindow owner_xid = CreateToplevelWindow(1, 0, 0, 0, 640, 480);
+  XWindow owner_xid =
+      CreateToplevelWindow(1, 0, Rect(0, 0, 640, 480));
   SendInitialEventsForWindow(owner_xid);
 
   XWindow transient_xid = CreateSimpleWindow();
   // Say that we support the WM_DELETE_WINDOW protocol.
   AppendAtomToProperty(transient_xid,
                        xconn_->GetAtomOrDie("WM_PROTOCOLS"),
                        xconn_->GetAtomOrDie("WM_DELETE_WINDOW"));
   MockXConnection::WindowInfo* transient_info =
       xconn_->GetWindowInfoOrDie(transient_xid);
   transient_info->transient_for = owner_xid;
   SendInitialEventsForWindow(transient_xid);
 
   // After we unmap the owner, the transient should receive a delete request.
   ASSERT_EQ(0, GetNumDeleteWindowMessagesForWindow(transient_xid));
   XEvent event;
   xconn_->InitUnmapEvent(&event, owner_xid);
   wm_->HandleEvent(&event);
   ASSERT_EQ(1, GetNumDeleteWindowMessagesForWindow(transient_xid));
 }
 
 }  // namespace window_manager
 
 int main(int argc, char** argv) {
   return window_manager::InitAndRunTests(&argc, argv, &FLAGS_logtostderr);
 }