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

login/login_controller_test.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 <vector>
 
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
 
 #include "base/scoped_ptr.h"
@@ skipping 67 matching lines @@
   }
 
   // Create the set of windows expected by LoginController.
   void CreateLoginWindows(int num_entries,
                           bool background_is_ready,
                           bool entry_pixmaps_are_ready,
                           bool create_wizard_window) {
     CHECK(num_entries == 0 || num_entries >= 2);
 
     if (!background_xid_) {
-      background_xid_ = CreateBasicWindow(0, 0, wm_->width(), wm_->height());
+      background_xid_ = CreateBasicWindow(wm_->root_bounds());
       vector<int> background_params;
       background_params.push_back(background_is_ready ? 1 : 0);
       wm_->wm_ipc()->SetWindowType(background_xid_,
                                    chromeos::WM_IPC_WINDOW_LOGIN_BACKGROUND,
                                    &background_params);
       SendInitialEventsForWindow(background_xid_);
     }
 
     for (int i = 0; i < num_entries; ++i) {
       entries_.push_back(CreateLoginEntry(num_entries, i));
     }
 
     // The wizard window needs to be mapped after the entries.  Otherwise, when
     // LoginController sees the wizard window get mapped, it won't know whether
     // it should display it immediately or wait for entries to show up.
     if (create_wizard_window) {
-      wizard_xid_ = CreateBasicWindow(0, 0,
-                                      wm_->width() / 2, wm_->height() / 2);
+      wizard_xid_ =
+          CreateBasicWindow(Rect(0, 0, wm_->width() / 2, wm_->height() / 2));
       wm_->wm_ipc()->SetWindowType(wizard_xid_,
                                    chromeos::WM_IPC_WINDOW_LOGIN_GUEST,
                                    NULL);
       SendInitialEventsForWindow(wizard_xid_);
     }
 
     if (entry_pixmaps_are_ready) {
       for (int i = 0; i < num_entries; ++i)
         SendInitialPixmapEventForEntry(i);
       // LoginController registers a timeout to call this, so we need to call
       // it manually.
       // TODO: It'd be better to make it so that tests can manually run
       // timeouts that have been posted to EventLoop.
       if (num_entries > 0)
         login_controller_->InitialShow();
     }
   }
 
   EntryWindows CreateLoginEntry(int num_entries, int i) {
     EntryWindows entry;
-    entry.border_xid = CreateBasicWindow(0, 0,
-        kImageSize + 2 * kGapBetweenImageAndControls,
-        kImageSize + kControlsSize + 3 * kGapBetweenImageAndControls);
-    entry.image_xid = CreateBasicWindow(0, 0, kImageSize, kImageSize);
-    entry.controls_xid = CreateBasicWindow(0, 0, kImageSize, kControlsSize);
-    entry.label_xid = CreateBasicWindow(0, 0, kImageSize, kControlsSize);
-    entry.unselected_label_xid = CreateBasicWindow(0, 0, kImageSize,
-                                                   kControlsSize);
+    entry.border_xid =
+        CreateBasicWindow(
+            Rect(0, 0,
+                 kImageSize + 2 * kGapBetweenImageAndControls,
+                 kImageSize + kControlsSize + 3 * kGapBetweenImageAndControls));
+    entry.image_xid =
+        CreateBasicWindow(Rect(0, 0, kImageSize, kImageSize));
+    entry.controls_xid =
+        CreateBasicWindow(Rect(0, 0, kImageSize, kControlsSize));
+    entry.label_xid =
+        CreateBasicWindow(Rect(0, 0, kImageSize, kControlsSize));
+    entry.unselected_label_xid =
+        CreateBasicWindow(Rect(0, 0, kImageSize, kControlsSize));
 
     vector<int> params;
     params.push_back(i);  // entry index
     wm_->wm_ipc()->SetWindowType(
         entry.image_xid,
         chromeos::WM_IPC_WINDOW_LOGIN_IMAGE,
         &params);
     wm_->wm_ipc()->SetWindowType(
         entry.controls_xid,
         chromeos::WM_IPC_WINDOW_LOGIN_CONTROLS,
@@ skipping 190 matching lines @@
   EXPECT_TRUE(wm_->GetWindowOrDie(background_xid_)->shadow() == NULL);
 }
 
 // Check that LoginController does some half-baked handling of transient
 // windows that get mapped before Chrome is in a logged-in state.
 TEST_F(LoginControllerTest, OtherWindows) {
   CreateLoginWindows(2, true, true, true);
 
   const int initial_width = 300;
   const int initial_height = 200;
-  const XWindow xid = CreateBasicWindow(0, 0, initial_width, initial_height);
+  const XWindow xid =
+      CreateBasicWindow(Rect(0, 0, initial_width, initial_height));
   MockXConnection::WindowInfo* info = xconn_->GetWindowInfoOrDie(xid);
   info->transient_for = background_xid_;
   ASSERT_FALSE(info->mapped);
 
   XEvent event;
   xconn_->InitCreateWindowEvent(&event, xid);
   wm_->HandleEvent(&event);
   Window* win = wm_->GetWindowOrDie(xid);
   MockCompositor::Actor* actor = GetMockActorForWindow(win);
 
@@ skipping 253 matching lines @@
 TEST_F(LoginControllerTest, HideAfterLogin) {
   // We should show the windows after they're mapped.
   CreateLoginWindows(2, true, true, false);
   EXPECT_FALSE(WindowIsOffscreen(background_xid_));
 
   // They should still be shown even after the user logs in.
   SetLoggedInState(true);
   EXPECT_FALSE(WindowIsOffscreen(background_xid_));
 
   // But we should hide them after the first Chrome window is created.
-  XWindow xid = CreateToplevelWindow(1, 0,  // tab_count, selected_tab
-                                     0, 0, 200, 200);  // position and size
+  XWindow xid = CreateToplevelWindow(1, 0, Rect(0, 0, 200, 200));
   SendInitialEventsForWindow(xid);
   EXPECT_TRUE(WindowIsOffscreen(background_xid_));
 }
 
 TEST_F(LoginControllerTest, ShowDestroyedWindows) {
   // Create some login windows and then tell the window manager that the
   // user has logged in.
   CreateLoginWindows(2, true, true, false);
   MockCompositor::TexturePixmapActor* background_actor =
       GetMockActorForWindow(wm_->GetWindowOrDie(background_xid_));
@@ skipping 10 matching lines @@
   xconn_->InitDestroyWindowEvent(&event, background_xid_);
   wm_->HandleEvent(&event);
 
   // Even though the background window has been destroyed, its actor should
   // still be displayed.
   EXPECT_TRUE(wm_->GetWindow(background_xid_) == NULL);
   EXPECT_TRUE(stage->stacked_children()->Contains(background_actor));
 
   // After the initial browser window gets mapped (but not yet painted), we
   // should still show the background.
-  XWindow xid = CreateToplevelWindow(1, 0,  // tab_count, selected_tab
-                                     0, 0, 200, 200);  // position and size
+  XWindow xid = CreateToplevelWindow(1, 0, Rect(0, 0, 200, 200));
   ConfigureWindowForSyncRequestProtocol(xid);
   SendInitialEventsForWindow(xid);
   EXPECT_TRUE(stage->stacked_children()->Contains(background_actor));
 
   // After it's painted, the login actors should be destroyed.
   SendSyncRequestProtocolAlarm(xid);
   EXPECT_FALSE(stage->stacked_children()->Contains(background_actor));
 }
 
 TEST_F(LoginControllerTest, SelectGuest) {
@@ skipping 19 matching lines @@
   EXPECT_EQ(entries_[0].controls_xid, GetActiveWindowProperty());
 
   // Click on the entry for the guest window again.
   SelectEntry(1);
 
   // The guest entry should be focused.
   EXPECT_EQ(entries_[1].controls_xid, xconn_->focused_xid());
   EXPECT_EQ(entries_[1].controls_xid, GetActiveWindowProperty());
 
   // Create wizard window.
-  wizard_xid_ = CreateBasicWindow(0, 0, wm_->width() / 2, wm_->height() / 2);
+  wizard_xid_ =
+      CreateBasicWindow(Rect(0, 0, wm_->width() / 2, wm_->height() / 2));
   wm_->wm_ipc()->SetWindowType(wizard_xid_,
                                chromeos::WM_IPC_WINDOW_LOGIN_GUEST,
                                NULL);
   SendInitialEventsForWindow(wizard_xid_);
 
   // The wizard window should be focused.
   EXPECT_EQ(wizard_xid_, xconn_->focused_xid());
   EXPECT_EQ(wizard_xid_, GetActiveWindowProperty());
 }
 
 TEST_F(LoginControllerTest, RemoveUser) {
   // Create 3 entries for new Chrome.
   CreateLoginWindows(3, true, true, false);
   SelectEntry(1);
   EXPECT_EQ(entries_[1].controls_xid, xconn_->focused_xid());
   EXPECT_EQ(entries_[1].controls_xid, GetActiveWindowProperty());
 
   UnmapLoginEntry(1);
   // Entry 1 was removed from the vector. Focus moved to 0 because 1 is Guest.
   EXPECT_EQ(entries_[0].controls_xid, xconn_->focused_xid());
   EXPECT_EQ(entries_[0].controls_xid, GetActiveWindowProperty());
 
   UnmapLoginEntry(0);
   EXPECT_EQ(entries_[0].controls_xid, xconn_->focused_xid());
   EXPECT_EQ(entries_[0].controls_xid, GetActiveWindowProperty());
 
   // Create wizard window.
-  wizard_xid_ = CreateBasicWindow(0, 0, wm_->width() / 2, wm_->height() / 2);
+  wizard_xid_ =
+      CreateBasicWindow(Rect(0, 0, wm_->width() / 2, wm_->height() / 2));
   wm_->wm_ipc()->SetWindowType(wizard_xid_,
                                chromeos::WM_IPC_WINDOW_LOGIN_GUEST,
                                NULL);
   SendInitialEventsForWindow(wizard_xid_);
   UnmapLoginEntry(0);
 
   // The wizard window should be focused.
   EXPECT_EQ(wizard_xid_, xconn_->focused_xid());
   EXPECT_EQ(wizard_xid_, GetActiveWindowProperty());
 }
@@ skipping 119 matching lines @@
 
   EXPECT_TRUE(WindowIsOffscreen(entries_[0].border_xid));
   EXPECT_FALSE(WindowIsOffscreen(entries_[0].image_xid));
   EXPECT_TRUE(WindowIsOffscreen(entries_[0].controls_xid));
   EXPECT_TRUE(WindowIsOffscreen(entries_[0].label_xid));
   EXPECT_FALSE(WindowIsOffscreen(entries_[0].unselected_label_xid));
 
   // Now check that for both entries windows are hidden when login succeeded
   // and the first Chrome window is shown.
   SetLoggedInState(true);
-  XWindow xid = CreateToplevelWindow(1, 0,  // tab_count, selected_tab
-                                     0, 0, 200, 200);  // position and size
+  XWindow xid = CreateToplevelWindow(1, 0, Rect(0, 0, 200, 200));
   SendInitialEventsForWindow(xid);
 
   EXPECT_TRUE(WindowIsOffscreen(entries_[0].border_xid));
   EXPECT_TRUE(WindowIsOffscreen(entries_[0].image_xid));
   EXPECT_TRUE(WindowIsOffscreen(entries_[0].controls_xid));
   EXPECT_TRUE(WindowIsOffscreen(entries_[0].label_xid));
   EXPECT_TRUE(WindowIsOffscreen(entries_[0].unselected_label_xid));
 
   EXPECT_TRUE(WindowIsOffscreen(entries_[1].border_xid));
   EXPECT_TRUE(WindowIsOffscreen(entries_[1].image_xid));
@@ skipping 341 matching lines @@
 
 }
 
 // Test that we focus the first controls window as soon as we map it.
 TEST_F(LoginControllerTest, FocusFirstControlsWindowImmediately) {
   // Create just a background window.
   CreateLoginWindows(0, true, false, false);
 
   // Create a border window for the first entry.
   XWindow border_xid =
-      CreateBasicWindow(0, 0,
-      kImageSize + 2 * kGapBetweenImageAndControls,
-      kImageSize + kControlsSize + 3 * kGapBetweenImageAndControls);
+      CreateBasicWindow(
+          Rect(0, 0,
+               kImageSize + 2 * kGapBetweenImageAndControls,
+               kImageSize + kControlsSize + 3 * kGapBetweenImageAndControls));
   vector<int> params;
   params.push_back(0);  // entry index
   params.push_back(1);  // num entries
   params.push_back(kUnselectedImageSize);
   params.push_back(kGapBetweenImageAndControls);
   wm_->wm_ipc()->SetWindowType(
       border_xid,
       chromeos::WM_IPC_WINDOW_LOGIN_BORDER,
       &params);
   SendInitialEventsForWindow(border_xid);
 
   // Now create a controls window for the entry.  Don't map it yet.
-  XWindow controls_xid = CreateBasicWindow(0, 0, kImageSize, kControlsSize);
+  XWindow controls_xid =
+      CreateBasicWindow(Rect(0, 0, kImageSize, kControlsSize));
   ConfigureWindowForSyncRequestProtocol(controls_xid);
   params.clear();
   params.push_back(0);  // entry index
   wm_->wm_ipc()->SetWindowType(
       controls_xid,
       chromeos::WM_IPC_WINDOW_LOGIN_CONTROLS,
       &params);
   XEvent event;
   xconn_->InitCreateWindowEvent(&event, controls_xid);
   wm_->HandleEvent(&event);
 
   // As soon as we send a map request, the controls window should be focused.
   EXPECT_EQ(0, xconn_->focused_xid());
   xconn_->InitMapRequestEvent(&event, controls_xid);
   wm_->HandleEvent(&event);
   EXPECT_EQ(controls_xid, xconn_->focused_xid());
   EXPECT_EQ(controls_xid, GetActiveWindowProperty());
 }
 
 #ifndef TOUCH_UI
 TEST_F(LoginControllerTest, UnhideCursorOnLeave) {
   // At startup, we should hide the cursor and map a fullscreen input window.
   EXPECT_FALSE(xconn_->cursor_shown());
   XWindow hide_mouse_cursor_xid = login_controller_->hide_mouse_cursor_xid_;
   ASSERT_TRUE(hide_mouse_cursor_xid != 0);
   MockXConnection::WindowInfo* info =
       xconn_->GetWindowInfoOrDie(hide_mouse_cursor_xid);
-  EXPECT_EQ(wm_->bounds(), info->bounds);
+  EXPECT_EQ(wm_->root_bounds(), info->bounds);
   EXPECT_TRUE(info->input_only);
   EXPECT_TRUE(info->mapped);
 
   // The window should be destroyed and the cursor shown as soon as the mouse
   // moves.
   XEvent event;
   xconn_->InitMotionNotifyEvent(&event, hide_mouse_cursor_xid, Point(0, 0));
   wm_->HandleEvent(&event);
   EXPECT_TRUE(xconn_->cursor_shown());
   EXPECT_TRUE(xconn_->GetWindowInfo(hide_mouse_cursor_xid) == NULL);
@@ skipping 11 matching lines @@
   EXPECT_FALSE(xconn_->cursor_shown());
   EXPECT_TRUE(xconn_->GetWindowInfo(hide_mouse_cursor_xid) != NULL);
 
   // ... and after the user logs in...
   SetLoggedInState(true);
   EXPECT_FALSE(xconn_->cursor_shown());
   EXPECT_TRUE(xconn_->GetWindowInfo(hide_mouse_cursor_xid) != NULL);
 
   // ... and after the first browser window is mapped.
   XWindow browser_xid =
-      CreateToplevelWindow(1, 0,  // tab_count, selected_tab
-                           0, 0, 200, 200);  // position and size
+      CreateToplevelWindow(1, 0, Rect(0, 0, 200, 200));
   ConfigureWindowForSyncRequestProtocol(browser_xid);
   SendInitialEventsForWindow(browser_xid);
   EXPECT_FALSE(xconn_->cursor_shown());
   EXPECT_TRUE(xconn_->GetWindowInfo(hide_mouse_cursor_xid) != NULL);
 
   // Once the browser window is visible, it should be destroyed.
   SendSyncRequestProtocolAlarm(browser_xid);
   EXPECT_TRUE(xconn_->cursor_shown());
   EXPECT_TRUE(xconn_->GetWindowInfo(hide_mouse_cursor_xid) == NULL);
 }
@@ skipping 12 matching lines @@
 
   xconn_->InitMapRequestEvent(&event, wizard_xid_);
   wm_->HandleEvent(&event);
 }
 
 }  // namespace window_manager
 
 int main(int argc, char** argv) {
   return window_manager::InitAndRunTests(&argc, argv, &FLAGS_logtostderr);
 }