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

window_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 <cstdarg>
 #include <set>
 #include <tr1/memory>
 #include <vector>
 
@@ skipping 380 matching lines @@
   reparent_event->window = xid;
   reparent_event->parent = 324324;  // arbitrary number
   wm_->HandleEvent(&event);
 
   // After the window gets reparented away from the root, WindowManager
   // should've unredirected it and should no longer be tracking it.
   EXPECT_TRUE(wm_->GetWindow(xid) == NULL);
   EXPECT_FALSE(info->redirected);
 }
 
-TEST_F(WindowManagerTest, RestackOverrideRedirectWindows) {
+TEST_F(WindowManagerTest, OverrideRedirectConfigureNotify) {
   MockCompositor::StageActor* stage = compositor_->GetDefaultStage();
   XEvent event;
 
   // Use the _NET_WM_WINDOW_TYPE_MENU hint to make the windows have shadows.
   const XAtom win_type_xatom = xconn_->GetAtomOrDie("_NET_WM_WINDOW_TYPE");
   const XAtom atom_xatom = xconn_->GetAtomOrDie("ATOM");
   const XAtom menu_xatom = xconn_->GetAtomOrDie("_NET_WM_WINDOW_TYPE_MENU");
 
   // Create two override-redirect windows and map them both.
   XWindow xid = xconn_->CreateWindow(
@@ skipping 34 matching lines @@
   xconn_->InitConfigureNotifyEvent(&event, xid);
   event.xconfigure.above = xid2;
   wm_->HandleEvent(&event);
 
   EXPECT_LT(stage->GetStackingIndex(win->actor()),
             stage->GetStackingIndex(win->shadow()->group()));
   EXPECT_LT(stage->GetStackingIndex(win->shadow()->group()),
             stage->GetStackingIndex(win2->actor()));
   EXPECT_LT(stage->GetStackingIndex(win2->actor()),
             stage->GetStackingIndex(win2->shadow()->group()));
+
+  // Move and resize the first window and check that its actor is updated
+  // correspondingly.
+  const Rect kNewBounds(300, 400, 60, 70);
+  xconn_->ConfigureWindow(xid, kNewBounds);
+  xconn_->InitConfigureNotifyEvent(&event, xid);
+  wm_->HandleEvent(&event);
+  EXPECT_EQ(kNewBounds, win->actor()->GetBounds());
 }
 
 TEST_F(WindowManagerTest, StackOverrideRedirectWindowsAboveLayers) {
   MockCompositor::StageActor* stage = compositor_->GetDefaultStage();
   XEvent event;
 
   // Create a normal, non-override-redirect window.
   XWindow normal_xid = CreateSimpleWindow();
   SendInitialEventsForWindow(normal_xid);
   Window* normal_win = wm_->GetWindowOrDie(normal_xid);
@@ skipping 577 matching lines @@
   XAtom popup_xatom = xconn_->GetAtomOrDie("_NET_WM_WINDOW_TYPE_POPUP_MENU");
 
   // An override-redirect window with no _NET_WM_WINDOW_TYPE property
   // shouldn't get a shadow.
   const XWindow root = xconn_->GetRootWindow();
   XWindow xid1 =
       xconn_->CreateWindow(root, Rect(0, 0, 10, 10), true, false, 0, 0);
   ASSERT_TRUE(xconn_->MapWindow(xid1));
   SendInitialEventsForWindow(xid1);
   Window* win1 = wm_->GetWindowOrDie(xid1);
-  EXPECT_TRUE(win1->composited_shown());
   EXPECT_TRUE(win1->shadow() == NULL);
 
   // _NET_WM_WINDOW_TYPE_MENU (or several other menu-related types) should
   // result in a shadow getting shown.
   XWindow xid2 =
       xconn_->CreateWindow(root, Rect(0, 0, 10, 10), true, false, 0, 0);
   xconn_->SetIntProperty(xid2, win_type_xatom, atom_xatom, menu_xatom);
   ASSERT_TRUE(xconn_->MapWindow(xid2));
   SendInitialEventsForWindow(xid2);
   ASSERT_TRUE(wm_->GetWindowOrDie(xid2)->shadow() != NULL);
@@ skipping 23 matching lines @@
   EXPECT_TRUE(wm_->GetWindowOrDie(xid4)->shadow()->is_shown());
 
   // We should avoid showing shadows behind RGBA menus.
   XWindow rgba_xid =
       xconn_->CreateWindow(root, Rect(0, 0, 10, 10), true, false, 0, 0);
   xconn_->GetWindowInfoOrDie(rgba_xid)->depth = 32;
   xconn_->SetIntProperty(rgba_xid, win_type_xatom, atom_xatom, menu_xatom);
   ASSERT_TRUE(xconn_->MapWindow(rgba_xid));
   SendInitialEventsForWindow(rgba_xid);
   Window* rgba_win = wm_->GetWindowOrDie(rgba_xid);
-  EXPECT_TRUE(rgba_win->composited_shown());
   EXPECT_TRUE(rgba_win->shadow() == NULL);
 }
 
 // Check that we try to guess when is a video is playing by looking at the
 // rate and size of damage events, and that we set the _CHROME_VIDEO_TIME
 // property on the root window accordingly.
 TEST_F(WindowManagerTest, VideoTimeProperty) {
   SetMonotonicTimeForTest(CreateTimeTicksFromMs(2000000));
   const time_t start_time = 1000;
   SetCurrentTimeForTest(start_time, 0);
@@ skipping 137 matching lines @@
   XEvent event;
   xconn_->InitConfigureNotifyEvent(&event, xwin1);
   wm_->HandleEvent(&event);
   xconn_->InitConfigureNotifyEvent(&event, xwin2);
   wm_->HandleEvent(&event);
 
   // Set up overlay regions for comparison.
   MockXConnection::WindowInfo* overlay_info =
     xconn_->GetWindowInfoOrDie(wm_->overlay_xid_);
   scoped_ptr<ByteMap> expected_overlay(
-      new ByteMap(overlay_info->bounds.width, overlay_info->bounds.height));
+      new ByteMap(overlay_info->bounds.size()));
   scoped_ptr<ByteMap> actual_overlay(
-      new ByteMap(overlay_info->bounds.width, overlay_info->bounds.height));
+      new ByteMap(overlay_info->bounds.size()));
 
   // Make sure no window is unredirected.
   FLAGS_unredirect_fullscreen_window = true;
   EXPECT_EQ(static_cast<XWindow>(0), wm_->unredirected_fullscreen_xid_);
   EXPECT_TRUE(info1->redirected);
   EXPECT_TRUE(info2->redirected);
   expected_overlay->Clear(0xff);
   xconn_->GetWindowBoundingRegion(wm_->overlay_xid_, actual_overlay.get());
   EXPECT_TRUE(*expected_overlay.get() == *actual_overlay.get());
 
@@ skipping 106 matching lines @@
 
   // Notify the window manager that the pixmap has been painted.
   // has_initial_pixmap() should return true now, and our event consumer
   // should be notified that the pixmap was received.
   SendSyncRequestProtocolAlarm(sync_xid);
   EXPECT_TRUE(sync_win->has_initial_pixmap());
   EXPECT_EQ(1, ec.num_fetched_pixmaps());
 
   // Resize the window and mimic the client syncing with the window manager
   // again, and check that we notify the event consumer about the new pixmap.
-  sync_win->ResizeClient(600, 500, GRAVITY_NORTHWEST);
+  sync_win->Resize(Size(600, 500), GRAVITY_NORTHWEST);
   SendSyncRequestProtocolAlarm(sync_xid);
   EXPECT_TRUE(sync_win->has_initial_pixmap());
   EXPECT_EQ(2, ec.num_fetched_pixmaps());
 }
 
 // Test that we make a second attempt at loading the sync request counter
 // ID if it only gets set after WM_PROTOCOLS has already told us that the
 // protocol is supported.  See comment #3 at http://crosbug.com/5846.
 TEST_F(WindowManagerTest, HandleLateSyncRequestCounter) {
   XWindow xid = CreateSimpleWindow();
@@ skipping 60 matching lines @@
 TEST_F(WindowManagerTest, ForceCompositing) {
   // Create a window.
   XWindow xid = CreateSimpleWindow();
   ConfigureWindowForSyncRequestProtocol(xid);
   SendInitialEventsForWindow(xid);
   SendSyncRequestProtocolAlarm(xid);
   Window* win = wm_->GetWindowOrDie(xid);
   MockCompositor::TexturePixmapActor* actor = GetMockActorForWindow(win);
 
   // Resize it to cover the whole screen.
-  win->ResizeClient(wm_->width(), wm_->height(), GRAVITY_NORTHWEST);
+  win->Resize(wm_->root_size(), GRAVITY_NORTHWEST);
   SendSyncRequestProtocolAlarm(xid);
 
   // Tell the WM that the window is covering the screen and check that we
   // disable compositing.
   wm_->HandleTopFullscreenActorChange(actor);
   EXPECT_EQ(xid, wm_->unredirected_fullscreen_xid_);
   EXPECT_TRUE(wm_->disable_compositing_task_is_pending_);
   wm_->DisableCompositing();
   EXPECT_FALSE(compositor_->should_draw_frame());
 
   // Now force compositing back on and check that we redraw the scene.
   const int kPrevForcedDraws = compositor_->num_forced_draws();
   wm_->IncrementCompositingRequests();
   EXPECT_EQ(kPrevForcedDraws + 1, compositor_->num_forced_draws());
   wm_->HandleTopFullscreenActorChange(actor);
   EXPECT_EQ(static_cast<XWindow>(0), wm_->unredirected_fullscreen_xid_);
   EXPECT_TRUE(compositor_->should_draw_frame());
   EXPECT_FALSE(wm_->disable_compositing_task_is_pending_);
 
   // Resize the window and remove the compositing request.  Since we're waiting
   // for the window to be repainted after the resize, we should continue
   // compositing.
-  win->ResizeClient(wm_->width() / 2, wm_->height() / 2, GRAVITY_NORTHWEST);
+  win->Resize(Size(wm_->width() / 2, wm_->height() / 2), GRAVITY_NORTHWEST);
   wm_->DecrementCompositingRequests();
   wm_->HandleTopFullscreenActorChange(actor);
   EXPECT_EQ(static_cast<XWindow>(0), wm_->unredirected_fullscreen_xid_);
   EXPECT_TRUE(compositor_->should_draw_frame());
   EXPECT_FALSE(wm_->disable_compositing_task_is_pending_);
 
   // After the window is repainted, we should still be compositing since the
   // window is no longer covering the entire screen.
   SendSyncRequestProtocolAlarm(xid);
   wm_->HandleTopFullscreenActorChange(NULL);
   EXPECT_EQ(static_cast<XWindow>(0), wm_->unredirected_fullscreen_xid_);
   EXPECT_TRUE(compositor_->should_draw_frame());
   EXPECT_FALSE(wm_->disable_compositing_task_is_pending_);
 }
 
 }  // namespace window_manager
 
 int main(int argc, char** argv) {
   return window_manager::InitAndRunTests(&argc, argv, &FLAGS_logtostderr);
 }