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

window_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 <map>
 #include <string>
 #include <vector>
 
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
@@ skipping 59 matching lines @@
   EXPECT_TRUE(win.FetchAndApplyWindowType());
   EXPECT_EQ(chromeos::WM_IPC_WINDOW_CHROME_TOPLEVEL, win.type());
 
   ASSERT_TRUE(wm_->wm_ipc()->SetWindowType(
                   xid, chromeos::WM_IPC_WINDOW_CHROME_INFO_BUBBLE, NULL));
   EXPECT_TRUE(win.FetchAndApplyWindowType());
   EXPECT_EQ(chromeos::WM_IPC_WINDOW_CHROME_INFO_BUBBLE, win.type());
 }
 
 TEST_F(WindowTest, ChangeClient) {
-  XWindow xid = CreateBasicWindow(10, 20, 30, 40);
+  XWindow xid = CreateBasicWindow(Rect(10, 20, 30, 40));
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
   XConnection::WindowGeometry geometry;
   ASSERT_TRUE(xconn_->GetWindowGeometry(xid, &geometry));
   Window window(wm_.get(), xid, false, geometry);
 
   // Make sure that the window's initial attributes are loaded correctly.
   EXPECT_EQ(xid, window.xid());
   EXPECT_EQ(10, window.client_x());
   EXPECT_EQ(20, window.client_y());
   EXPECT_EQ(30, window.client_width());
   EXPECT_EQ(40, window.client_height());
   EXPECT_EQ(false, window.mapped());
 
   EXPECT_TRUE(window.MapClient());
   EXPECT_TRUE(info->mapped);
 
   // Move the window.
   EXPECT_TRUE(window.MoveClient(100, 200));
   EXPECT_EQ(100, info->bounds.x);
   EXPECT_EQ(200, info->bounds.y);
   EXPECT_EQ(100, window.client_x());
   EXPECT_EQ(200, window.client_y());
 
   // Resize the window.
-  EXPECT_TRUE(window.ResizeClient(300, 400, GRAVITY_NORTHWEST));
+  EXPECT_TRUE(window.Resize(Size(300, 400), GRAVITY_NORTHWEST));
   EXPECT_EQ(300, info->bounds.width);
   EXPECT_EQ(400, info->bounds.height);
   EXPECT_EQ(300, window.client_width());
   EXPECT_EQ(400, window.client_height());
-
-  // We need to be able to update windows' local geometry variables in
-  // response to ConfigureNotify events to be able to handle
-  // override-redirect windows, so make sure that that works correctly.
-  window.SaveClientPosition(50, 60);
-  window.SaveClientSize(70, 80);
-  EXPECT_EQ(50, window.client_x());
-  EXPECT_EQ(60, window.client_y());
-  EXPECT_EQ(70, window.client_width());
-  EXPECT_EQ(80, window.client_height());
 }
 
 TEST_F(WindowTest, ChangeComposited) {
-  XWindow xid = CreateBasicWindow(10, 20, 30, 40);
+  XWindow xid = CreateBasicWindow(Rect(10, 20, 30, 40));
   XConnection::WindowGeometry geometry;
   ASSERT_TRUE(xconn_->GetWindowGeometry(xid, &geometry));
   Window window(wm_.get(), xid, false, geometry);
   xconn_->MapWindow(xid);
   window.HandleMapNotify();
 
   MockCompositor::TexturePixmapActor* actor = GetMockActorForWindow(&window);
 
   // Initially, we should place the composited window at the same location
   // as the client window.
@@ skipping 33 matching lines @@
   Window win(wm_.get(), xid, false, geometry);
   EXPECT_EQ(owner_xid, win.transient_for_xid());
 
   XWindow new_owner_xid = 5678;
   info->transient_for = new_owner_xid;
   EXPECT_TRUE(win.FetchAndApplyTransientHint());
   EXPECT_EQ(new_owner_xid, win.transient_for_xid());
 }
 
 TEST_F(WindowTest, GetMaxSize) {
-  XWindow xid = CreateBasicWindow(10, 20, 30, 40);
+  XWindow xid = CreateBasicWindow(Rect(10, 20, 30, 40));
 
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
   info->size_hints.min_size.reset(400, 300);
   info->size_hints.max_size.reset(800, 600);
   info->size_hints.size_increment.reset(10, 5);
   info->size_hints.base_size.reset(40, 30);
 
   XConnection::WindowGeometry geometry;
   ASSERT_TRUE(xconn_->GetWindowGeometry(xid, &geometry));
   Window win(wm_.get(), xid, false, geometry);
   ASSERT_TRUE(win.FetchAndApplySizeHints());
-  int width = 0, height = 0;
+  Size size;
 
   // We should get the minimum size if we request a size smaller than it.
-  win.GetMaxSize(300, 200, &width, &height);
-  EXPECT_EQ(400, width);
-  EXPECT_EQ(300, height);
+  win.GetMaxSize(Size(300, 200), &size);
+  EXPECT_EQ(Size(400, 300), size);
 
   // And the maximum size if we request one larger than it.
-  win.GetMaxSize(1000, 800, &width, &height);
-  EXPECT_EQ(800, width);
-  EXPECT_EQ(600, height);
+  win.GetMaxSize(Size(1000, 800), &size);
+  EXPECT_EQ(Size(800, 600), size);
 
   // Test that the size increment hints are honored when we request a size
   // that's not equal to the base size plus some multiple of the size
   // increments.
-  win.GetMaxSize(609, 409, &width, &height);
-  EXPECT_EQ(600, width);
-  EXPECT_EQ(405, height);
+  win.GetMaxSize(Size(609, 409), &size);
+  EXPECT_EQ(Size(600, 405), size);
 }
 
 // Test WM_DELETE_WINDOW and WM_TAKE_FOCUS from ICCCM's WM_PROTOCOLS.
 TEST_F(WindowTest, WmProtocols) {
   // Create a window.
   XWindow xid = CreateSimpleWindow();
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
 
   // Set its WM_PROTOCOLS property to indicate that it supports both
   // message types.
@@ skipping 206 matching lines @@
 TEST_F(WindowTest, Shape) {
   // Loading windows' regions is turned off by default, since it can cause
   // a pretty big memory allocation for new windows and the compositor
   // doesn't currently even support using these regions as masks, but we
   // need to enable it to test this code.
   AutoReset<bool> flag_resetter(&FLAGS_load_window_shapes, true);
 
   // Create a shaped window.
   int width = 10;
   int height = 5;
-  XWindow xid = CreateBasicWindow(10, 20, width, height);
+  XWindow xid = CreateBasicWindow(Rect(10, 20, width, height));
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
-  info->shape.reset(new ByteMap(width, height));
+  info->shape.reset(new ByteMap(Size(width, height)));
   info->shape->Clear(0xff);
-  info->shape->SetRectangle(0, 0, 3, 3, 0x0);
+  info->shape->SetRectangle(Rect(0, 0, 3, 3), 0x0);
 
   XConnection::WindowGeometry geometry;
   ASSERT_TRUE(xconn_->GetWindowGeometry(xid, &geometry));
   Window win(wm_.get(), xid, false, geometry);
   win.SetShadowType(Shadow::TYPE_RECTANGULAR);
   EXPECT_TRUE(info->shape_events_selected);
   EXPECT_TRUE(win.shaped());
   win.HandleMapNotify();
   win.ShowComposited();
 
@@ skipping 10 matching lines @@
   // Check that the shape mask got applied to the compositing actor.
   MockCompositor::TexturePixmapActor* mock_actor = GetMockActorForWindow(&win);
   ASSERT_TRUE(mock_actor->alpha_mask_bytes() != NULL);
   EXPECT_PRED_FORMAT3(BytesAreEqual,
                       info->shape->bytes(),
                       mock_actor->alpha_mask_bytes(),
                       width * height);
 
   // Change the shape and check that the window updates its actor.
   info->shape->Clear(0xff);
-  info->shape->SetRectangle(width - 3, height - 3, 3, 3, 0x0);
+  info->shape->SetRectangle(Rect(width - 3, height - 3, 3, 3), 0x0);
   win.FetchAndApplyShape();
   EXPECT_TRUE(win.shaped());
   EXPECT_FALSE(win.shadow()->is_shown());
   ASSERT_TRUE(mock_actor->alpha_mask_bytes() != NULL);
   EXPECT_PRED_FORMAT3(BytesAreEqual,
                       info->shape->bytes(),
                       mock_actor->alpha_mask_bytes(),
                       width * height);
 
   // Now clear the shape and make sure that the mask is removed from the
@@ skipping 31 matching lines @@
   ASSERT_TRUE(xconn_->GetWindowGeometry(xid, &geometry));
   Window win(wm_.get(), xid, false, geometry);
   EXPECT_EQ(0, info->border_width);
 }
 
 // Test that we don't resize the composited window until we receive
 // notification that the client window has been resized.  Otherwise, we can
 // end up with the previous contents being scaled to fit the new size --
 // see http://crosbug.com/1279.
 TEST_F(WindowTest, DeferResizingActor) {
-  const int orig_width = 300, orig_height = 200;
-  XWindow xid = CreateToplevelWindow(2, 0, 0, 0, orig_width, orig_height);
+  const Rect kOrigBounds(0, 0, 300, 200);
+  XWindow xid = CreateToplevelWindow(2, 0, kOrigBounds);
   XConnection::WindowGeometry geometry;
   ASSERT_TRUE(xconn_->GetWindowGeometry(xid, &geometry));
   Window win(wm_.get(), xid, false, geometry);
   xconn_->MapWindow(xid);
   win.HandleMapNotify();
 
   // Check that the actor's initial dimensions match that of the client window.
-  EXPECT_EQ(orig_width, win.actor()->GetWidth());
-  EXPECT_EQ(orig_height, win.actor()->GetHeight());
+  EXPECT_EQ(kOrigBounds.size(), win.actor()->GetBounds().size());
 
   // After resizing the client window, the actor should still still be
   // using the original dimensions.
-  const int new_width = 600, new_height = 400;
-  win.ResizeClient(new_width, new_height, GRAVITY_NORTHWEST);
-  EXPECT_EQ(orig_width, win.actor()->GetWidth());
-  EXPECT_EQ(orig_height, win.actor()->GetHeight());
+  const Rect kNewBounds(0, 0, 600, 400);
+  win.Resize(kNewBounds.size(), GRAVITY_NORTHWEST);
+  EXPECT_EQ(kOrigBounds.size(), win.actor()->GetBounds().size());
 
   // Now let the window know that we've seen a ConfigureNotify event with
   // the new dimensions and check that the actor is resized.
-  win.HandleConfigureNotify(new_width, new_height);
-  EXPECT_EQ(new_width, win.actor()->GetWidth());
-  EXPECT_EQ(new_height, win.actor()->GetHeight());
+  win.HandleConfigureNotify(kNewBounds, 0);
+  EXPECT_EQ(kNewBounds.size(), win.actor()->GetBounds().size());
 }
 
 // Test that pixmap actor and shadow sizes get updated correctly in
 // response to ConfigureNotify events.
 TEST_F(WindowTest, UpdatePixmapAndShadowSizes) {
   const int orig_width = 300, orig_height = 200;
-  XWindow xid = CreateToplevelWindow(2, 0, 0, 0, orig_width, orig_height);
+  XWindow xid = CreateToplevelWindow(2, 0, Rect(0, 0, orig_width, orig_height));
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
   XConnection::WindowGeometry geometry;
   ASSERT_TRUE(xconn_->GetWindowGeometry(xid, &geometry));
   Window win(wm_.get(), xid, false, geometry);
   win.SetShadowType(Shadow::TYPE_RECTANGULAR);
 
   // Resize the window once before it gets mapped, to make sure that we get
   // the updated size later after the window is mapped.
   const int second_width = orig_width + 10, second_height = orig_height + 10;
   ASSERT_TRUE(xconn_->ResizeWindow(xid, Size(second_width, second_height)));
-  win.HandleConfigureNotify(info->bounds.width, info->bounds.height);
+  win.HandleConfigureNotify(info->bounds, 0);
 
   // Now map the window and check that everything starts out at the right size.
   ASSERT_TRUE(xconn_->MapWindow(xid));
   win.HandleMapNotify();
   MockCompositor::TexturePixmapActor* actor = GetMockActorForWindow(&win);
   EXPECT_EQ(second_width, actor->GetWidth());
   EXPECT_EQ(second_height, actor->GetHeight());
   EXPECT_EQ(second_width, win.shadow()->width());
   EXPECT_EQ(second_height, win.shadow()->height());
 
   // We shouldn't reload the pixmap in response to a non-resize
   // ConfigureNotify event (like what we'll receive whenever the window
   // gets moved).
   XID prev_pixmap = actor->pixmap();
-  win.HandleConfigureNotify(info->bounds.width, info->bounds.height);
+  win.HandleConfigureNotify(info->bounds, 0);
   EXPECT_EQ(prev_pixmap, actor->pixmap());
 
   // Now act as if the window gets resized two more times, but the second
   // resize has already happened in the X server by the time that the
   // window manager receives the ConfigureNotify for the first resize.
   const int third_width = second_width + 10, third_height = second_height + 10;
   const int fourth_width = third_width + 10, fourth_height = third_height + 10;
   xconn_->ResizeWindow(xid, Size(fourth_width, fourth_height));
-  win.HandleConfigureNotify(third_width, third_height);
+  win.HandleConfigureNotify(
+      Rect(info->bounds.x, info->bounds.y, third_width, third_height), 0);
 
   // We should load the pixmap now and resize the shadow to the dimensions
   // from the final pixmap instead of the ones supplied in the event.
   EXPECT_EQ(fourth_width, actor->GetWidth());
   EXPECT_EQ(fourth_height, actor->GetHeight());
   EXPECT_EQ(fourth_width, win.shadow()->width());
   EXPECT_EQ(fourth_height, win.shadow()->height());
 
   // Nothing should change after we get the second ConfigureNotify.
-  win.HandleConfigureNotify(fourth_width, fourth_height);
+  win.HandleConfigureNotify(info->bounds, 0);
   EXPECT_EQ(fourth_width, actor->GetWidth());
   EXPECT_EQ(fourth_height, actor->GetHeight());
   EXPECT_EQ(fourth_width, win.shadow()->width());
   EXPECT_EQ(fourth_height, win.shadow()->height());
 }
 
 // Test that we show and hide shadows under the proper conditions (note
 // that a portion of this is covered by the Shape test).
 TEST_F(WindowTest, ShadowVisibility) {
   XWindow xid = CreateSimpleWindow();
@@ skipping 32 matching lines @@
   XWindow xid = CreateSimpleWindow();
   XConnection::WindowGeometry geometry;
   ASSERT_TRUE(xconn_->GetWindowGeometry(xid, &geometry));
   Window win(wm_.get(), xid, false, geometry);
   xconn_->MapWindow(xid);
   win.HandleMapRequested();
   win.HandleMapNotify();
   MockCompositor::TexturePixmapActor* actor = GetMockActorForWindow(&win);
 
   EXPECT_TRUE(win.client_has_redrawn_after_last_resize_);
-  EXPECT_EQ(geometry.bounds.width, actor->GetWidth());
-  EXPECT_EQ(geometry.bounds.height, actor->GetHeight());
+  EXPECT_EQ(geometry.bounds.size(), actor->GetBounds().size());
 
   // If the client doesn't support the sync request protocol, we should
   // just pretend like it's always redrawn the window immediately after a
   // resize.
-  win.ResizeClient(500, 500, GRAVITY_NORTHWEST);
+  Size kFirstSize(500, 500);
+  win.Resize(kFirstSize, GRAVITY_NORTHWEST);
   EXPECT_TRUE(win.client_has_redrawn_after_last_resize_);
-  win.HandleConfigureNotify(500, 500);
-  EXPECT_EQ(500, actor->GetWidth());
-  EXPECT_EQ(500, actor->GetHeight());
+  win.HandleConfigureNotify(Rect(geometry.bounds.position(), kFirstSize), 0);
+  EXPECT_EQ(kFirstSize, actor->GetBounds().size());
 
   // Add the hint saying that the window supports the sync request
   // protocol, but don't actually set the property saying which counter
   // it's using.  The hint should be ignored.
   ASSERT_TRUE(
       xconn_->SetIntProperty(
           xid,
           xconn_->GetAtomOrDie("WM_PROTOCOLS"),  // atom
           xconn_->GetAtomOrDie("ATOM"),          // type
           xconn_->GetAtomOrDie("_NET_WM_SYNC_REQUEST")));
@@ skipping 18 matching lines @@
   // alarm's trigger at the next-greatest value.
   int64_t initial_counter_value = xconn_->GetSyncCounterValueOrDie(counter_xid);
   EXPECT_NE(static_cast<int64_t>(0), initial_counter_value);
   int64_t next_counter_value = initial_counter_value + 1;
   EXPECT_EQ(next_counter_value, alarm_info->initial_trigger_value);
 
   // When we resize the window, we should consider the window as needing to
   // be redrawn.
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
   info->client_messages.clear();
-  win.ResizeClient(600, 600, GRAVITY_NORTHWEST);
+  Size kSecondSize(600, 600);
+  win.Resize(kSecondSize, GRAVITY_NORTHWEST);
   EXPECT_FALSE(win.client_has_redrawn_after_last_resize_);
 
   // We should also abstain from getting a new pixmap in response to
   // ConfigureNotify events...
-  win.HandleConfigureNotify(600, 600);
-  EXPECT_EQ(500, actor->GetWidth());
-  EXPECT_EQ(500, actor->GetHeight());
+  win.HandleConfigureNotify(Rect(info->bounds.position(), kSecondSize), 0);
+  EXPECT_EQ(kFirstSize, actor->GetBounds().size());
 
   // ... and we should send the client a message telling it to increment the
   // counter when it's done redrawing.
   ASSERT_EQ(1, info->client_messages.size());
   const XClientMessageEvent& msg = info->client_messages[0];
   EXPECT_EQ(xconn_->GetAtomOrDie("WM_PROTOCOLS"), msg.message_type);
   EXPECT_EQ(XConnection::kLongFormat, msg.format);
   EXPECT_EQ(xconn_->GetAtomOrDie("_NET_WM_SYNC_REQUEST"), msg.data.l[0]);
   // TODO: Check timestamp in l[1]?
   EXPECT_EQ(static_cast<uint32_t>(next_counter_value & 0xffffffff),
             msg.data.l[2]);
   EXPECT_EQ(static_cast<uint32_t>((next_counter_value >> 32) & 0xffffffff),
             msg.data.l[3]);
 
   // If we get notified that the counter is at the previous value, we
   // should ignore it.
   win.HandleSyncAlarmNotify(win.wm_sync_request_alarm_, initial_counter_value);
   EXPECT_FALSE(win.client_has_redrawn_after_last_resize_);
 
   // Ditto if we get notified about some alarm that we don't know about
   // (this shouldn't happen in practice).
   win.HandleSyncAlarmNotify(0, next_counter_value);
   EXPECT_FALSE(win.client_has_redrawn_after_last_resize_);
 
   // When we get notified that the counter has increased to the next value,
   // we should consider the window to be redrawn and fetch an updated pixmap.
   win.HandleSyncAlarmNotify(win.wm_sync_request_alarm_, next_counter_value);
   EXPECT_TRUE(win.client_has_redrawn_after_last_resize_);
-  EXPECT_EQ(600, actor->GetWidth());
-  EXPECT_EQ(600, actor->GetHeight());
+  EXPECT_EQ(kSecondSize, actor->GetBounds().size());
 
   // If we somehow get notified that the window has been redrawn before we
   // get the ConfigureNotify, reset the pixmap immediately.
-  win.ResizeClient(700, 700, GRAVITY_NORTHWEST);
+  Size kThirdSize(700, 700);
+  win.Resize(kThirdSize, GRAVITY_NORTHWEST);
   win.HandleSyncAlarmNotify(win.wm_sync_request_alarm_,
                             win.current_wm_sync_num_);
-  EXPECT_EQ(700, actor->GetWidth());
-  EXPECT_EQ(700, actor->GetHeight());
+  EXPECT_EQ(kThirdSize, actor->GetBounds().size());
 }
 
 // Test that we wait to fetch pixmaps for newly-created windows until the
 // client tells us that they've been painted.
 TEST_F(WindowTest, DeferFetchingPixmapUntilPainted) {
   // Create a window and configure it to use _NET_WM_SYNC_REQUEST.
   XWindow xid = CreateSimpleWindow();
   ConfigureWindowForSyncRequestProtocol(xid);
   XConnection::WindowGeometry geometry;
   ASSERT_TRUE(xconn_->GetWindowGeometry(xid, &geometry));
@@ skipping 147 matching lines @@
   win.HandleMapNotify();
   EXPECT_EQ(kNewSize, win.actor()->GetBounds().size());
 
   // Turn on the shadow while we're in this brief state where we have a
   // 200x400 actor but have only heard about the 1x1 size from the X
   // server.  The shadow should take the actor's size.
   win.SetShadowType(Shadow::TYPE_RECTANGULAR);
   EXPECT_EQ(kNewSize, win.shadow()->bounds().size());
 
   // Now send the ConfigureNotify and check that nothing changes.
-  win.HandleConfigureNotify(kNewSize.width, kNewSize.height);
+  win.HandleConfigureNotify(Rect(Point(0, 0), kNewSize), 0);
   EXPECT_EQ(kNewSize, win.actor()->GetBounds().size());
 }
 
 // Test that when we ask a window to simultaneously move and resize itself (that
 // is, we request a resize with non-northwest gravity), the actor's position and
 // size are updated atomically, rather than its position getting changed
 // immediately and the resize only happening after we fetch the new pixmap.
 TEST_F(WindowTest, SimultaneousMoveAndResize) {
   // Create and map a window.
   const Rect kOrigBounds(100, 150, 300, 250);
@@ skipping 14 matching lines @@
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
   EXPECT_EQ(kOrigBounds, info->bounds);
   MockCompositor::TexturePixmapActor* actor = GetMockActorForWindow(&win);
   EXPECT_EQ(kOrigBounds, actor->GetBounds());
   EXPECT_EQ(kOrigBounds.x, win.composited_x());
   EXPECT_EQ(kOrigBounds.y, win.composited_y());
 
   // Now make the window 50 pixels wider and taller with southeast gravity.
   // In other words, its origin should also move 50 pixels up and to the left.
   const Rect kNewBounds(50, 100, 350, 300);
-  win.ResizeClient(kNewBounds.width, kNewBounds.height, GRAVITY_SOUTHEAST);
+  win.Resize(kNewBounds.size(), GRAVITY_SOUTHEAST);
 
   // A request should've been sent to the X server asking for the new bounds, so
   // the client window should be resized.  The actor should still be at the old
   // size (since we can't fetch its bitmap yet) and also at the old position (so
   // we can make the move and resize happen atomically onscreen later).
   EXPECT_EQ(kNewBounds, info->bounds);
   EXPECT_EQ(kOrigBounds, actor->GetBounds());
   EXPECT_EQ(kNewBounds.x, win.composited_x());
   EXPECT_EQ(kNewBounds.y, win.composited_y());
 
   // After we've received notification that the new pixmap is available, the
   // actor should be both resized and moved to the requested position.
-  win.HandleConfigureNotify(kNewBounds.width, kNewBounds.height);
+  win.HandleConfigureNotify(kNewBounds, 0);
   EXPECT_EQ(kNewBounds, actor->GetBounds());
   EXPECT_EQ(kNewBounds.x, win.composited_x());
   EXPECT_EQ(kNewBounds.y, win.composited_y());
 
   // Move the actor to a completely different position.
   const Point kCompositedPosition(500, 600);
   win.MoveComposited(kCompositedPosition.x, kCompositedPosition.y, 0);
   EXPECT_EQ(Rect(kCompositedPosition, kNewBounds.size()), actor->GetBounds());
   EXPECT_EQ(kCompositedPosition.x, win.composited_x());
   EXPECT_EQ(kCompositedPosition.y, win.composited_y());
 
   // Now resize the window back to its old size, again with southeast gravity.
   // The actor shouldn't move, but we should update the |composited_x| and
   // |composited_y| fields.
-  win.ResizeClient(kOrigBounds.width, kOrigBounds.height, GRAVITY_SOUTHEAST);
+  win.Resize(kOrigBounds.size(), GRAVITY_SOUTHEAST);
   EXPECT_EQ(kOrigBounds, info->bounds);
   EXPECT_EQ(Rect(kCompositedPosition, kNewBounds.size()), actor->GetBounds());
   const Point kOffsetCompositedPosition(
       kCompositedPosition.x + (kNewBounds.width - kOrigBounds.width),
       kCompositedPosition.y + (kNewBounds.height - kOrigBounds.height));
   EXPECT_EQ(kOffsetCompositedPosition.x, win.composited_x());
   EXPECT_EQ(kOffsetCompositedPosition.y, win.composited_y());
 
   // After getting notification about the pixmap, the actor should be resized
   // and moved to the new position.
-  win.HandleConfigureNotify(kOrigBounds.width, kOrigBounds.height);
+  win.HandleConfigureNotify(kOrigBounds, 0);
   EXPECT_EQ(Rect(kOffsetCompositedPosition, kOrigBounds.size()),
             actor->GetBounds());
 
   // Move the composited window back to the client window's position and scale
   // it to 50% of its original size.
   win.MoveComposited(kOrigBounds.x, kOrigBounds.y, 0);
   const double kCompositedScale = 0.5;
   win.ScaleComposited(kCompositedScale, kCompositedScale, 0);
 
   // Resize the client again.  The amount that the composited window is moved
   // should be scaled by its scaling factor.
-  win.ResizeClient(kNewBounds.width, kNewBounds.height, GRAVITY_SOUTHEAST);
+  win.Resize(kNewBounds.size(), GRAVITY_SOUTHEAST);
   const Point kScaledCompositedPosition(
       kOrigBounds.x + kCompositedScale * (kNewBounds.x - kOrigBounds.x),
       kOrigBounds.y + kCompositedScale * (kNewBounds.y - kOrigBounds.y));
   EXPECT_EQ(kScaledCompositedPosition.x, win.composited_x());
   EXPECT_EQ(kScaledCompositedPosition.y, win.composited_y());
 
-  win.HandleConfigureNotify(kNewBounds.width, kNewBounds.height);
+  win.HandleConfigureNotify(kNewBounds, 0);
   EXPECT_EQ(Rect(kScaledCompositedPosition, kNewBounds.size()),
             actor->GetBounds());
 }
 
 // Exercises the new interface for managing both X and composited windows
 // simultaneously (SetVisibility() and Move()).
 TEST_F(WindowTest, SetVisibility) {
   // Create and map a window.
   const Rect kOrigBounds(100, 150, 300, 250);
   XWindow xid = xconn_->CreateWindow(xconn_->GetRootWindow(),
@@ skipping 169 matching lines @@
   win2.HandleFreezeUpdatesPropertyChange(false);
   EXPECT_NE(0, win2.pixmap_);
   EXPECT_TRUE(win2.has_initial_pixmap());
 }
 
 }  // namespace window_manager
 
 int main(int argc, char** argv) {
   return window_manager::InitAndRunTests(&argc, argv, &FLAGS_logtostderr);
 }