chrome/browser/ui/window_sizer/window_sizer_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/window_sizer/window_sizer_common_unittest.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 // Test that the window is sized appropriately for the first run experience
  11 // where the default window bounds calculation is invoked.
  12 TEST(WindowSizerTest, DefaultSizeCase) {
  13   { // 4:3 monitor case, 1024x768, no taskbar
  14     gfx::Rect window_bounds;
  15     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(), gfx::Rect(),
  16                     gfx::Rect(), DEFAULT, NULL, gfx::Rect(), &window_bounds);
  17     EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
  18                         1024 - kWindowTilePixels * 2,
  19                         768 - kWindowTilePixels * 2),
  20               window_bounds);
  21   }
  22
  23   { // 4:3 monitor case, 1024x768, taskbar on bottom
  24     gfx::Rect window_bounds;
  25     GetWindowBounds(p1024x768, taskbar_bottom_work_area, gfx::Rect(),
  26                     gfx::Rect(), gfx::Rect(), DEFAULT, NULL, gfx::Rect(),
  27                     &window_bounds);
  28     EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
  29                         1024 - kWindowTilePixels * 2,
  30                         (taskbar_bottom_work_area.height() -
  31                          kWindowTilePixels * 2)),
  32               window_bounds);
  33   }
  34
  35   { // 4:3 monitor case, 1024x768, taskbar on right
  36     gfx::Rect window_bounds;
  37     GetWindowBounds(p1024x768, taskbar_right_work_area, gfx::Rect(),
  38                     gfx::Rect(), gfx::Rect(), DEFAULT, NULL, gfx::Rect(),
  39                     &window_bounds);
  40     EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
  41                         taskbar_right_work_area.width() - kWindowTilePixels*2,
  42                         768 - kWindowTilePixels * 2),
  43               window_bounds);
  44   }
  45
  46   { // 4:3 monitor case, 1024x768, taskbar on left
  47     gfx::Rect window_bounds;
  48     GetWindowBounds(p1024x768, taskbar_left_work_area, gfx::Rect(),
  49                     gfx::Rect(), gfx::Rect(), DEFAULT, NULL, gfx::Rect(),
  50                     &window_bounds);
  51     EXPECT_EQ(gfx::Rect(taskbar_left_work_area.x() + kWindowTilePixels,
  52                         kWindowTilePixels,
  53                         taskbar_left_work_area.width() - kWindowTilePixels * 2,
  54                         (taskbar_left_work_area.height() -
  55                          kWindowTilePixels * 2)),
  56               window_bounds);
  57   }
  58
  59   { // 4:3 monitor case, 1024x768, taskbar on top
  60     gfx::Rect window_bounds;
  61     GetWindowBounds(p1024x768, taskbar_top_work_area, gfx::Rect(),
  62                     gfx::Rect(), gfx::Rect(), DEFAULT, NULL, gfx::Rect(),
  63                     &window_bounds);
  64     EXPECT_EQ(gfx::Rect(kWindowTilePixels,
  65                         taskbar_top_work_area.y() + kWindowTilePixels,
  66                         1024 - kWindowTilePixels * 2,
  67                         taskbar_top_work_area.height() - kWindowTilePixels * 2),
  68               window_bounds);
  69   }
  70
  71   { // 4:3 monitor case, 1280x1024
  72     gfx::Rect window_bounds;
  73     GetWindowBounds(p1280x1024, p1280x1024, gfx::Rect(), gfx::Rect(),
  74                     gfx::Rect(), DEFAULT, NULL, gfx::Rect(), &window_bounds);
  75     EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
  76                         1050,
  77                         1024 - kWindowTilePixels * 2),
  78               window_bounds);
  79   }
  80
  81   { // 4:3 monitor case, 1600x1200
  82     gfx::Rect window_bounds;
  83     GetWindowBounds(p1600x1200, p1600x1200, gfx::Rect(), gfx::Rect(),
  84                     gfx::Rect(), DEFAULT, NULL, gfx::Rect(), &window_bounds);
  85     EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
  86                         1050,
  87                         1200 - kWindowTilePixels * 2),
  88               window_bounds);
  89   }
  90
  91   { // 16:10 monitor case, 1680x1050
  92     gfx::Rect window_bounds;
  93     GetWindowBounds(p1680x1050, p1680x1050, gfx::Rect(), gfx::Rect(),
  94                     gfx::Rect(), DEFAULT, NULL, gfx::Rect(), &window_bounds);
  95     EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
  96                         840 - static_cast<int>(kWindowTilePixels * 1.5),
  97                         1050 - kWindowTilePixels * 2),
  98               window_bounds);
  99   }
 100
 101   { // 16:10 monitor case, 1920x1200
 102     gfx::Rect window_bounds;
 103     GetWindowBounds(p1920x1200, p1920x1200, gfx::Rect(), gfx::Rect(),
 104                     gfx::Rect(), DEFAULT, NULL, gfx::Rect(), &window_bounds);
 105     EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
 106                         960 - static_cast<int>(kWindowTilePixels * 1.5),
 107                         1200 - kWindowTilePixels * 2),
 108               window_bounds);
 109   }
 110 }
 111
 112 // Test that the next opened window is positioned appropriately given the
 113 // bounds of an existing window of the same type.
 114 TEST(WindowSizerTest, LastWindowBoundsCase) {
 115   { // normal, in the middle of the screen somewhere.
 116     gfx::Rect window_bounds;
 117     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 118                     gfx::Rect(kWindowTilePixels, kWindowTilePixels, 500, 400),
 119                     gfx::Rect(), LAST_ACTIVE, NULL, gfx::Rect(),
 120                     &window_bounds);
 121     EXPECT_EQ(gfx::Rect(kWindowTilePixels * 2,
 122                         kWindowTilePixels * 2, 500, 400), window_bounds);
 123   }
 124
 125   { // taskbar on top.
 126     gfx::Rect window_bounds;
 127     GetWindowBounds(p1024x768, taskbar_top_work_area, gfx::Rect(),
 128                     gfx::Rect(kWindowTilePixels, kWindowTilePixels, 500, 400),
 129                     gfx::Rect(), LAST_ACTIVE, NULL, gfx::Rect(),
 130                     &window_bounds);
 131     EXPECT_EQ(gfx::Rect(kWindowTilePixels * 2,
 132                         std::max(kWindowTilePixels * 2,
 133                                  34 /* toolbar height */),
 134                         500, 400), window_bounds);
 135   }
 136
 137   { // Too small to satisify the minimum visibility condition.
 138     gfx::Rect window_bounds;
 139     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 140                     gfx::Rect(kWindowTilePixels, kWindowTilePixels, 29, 29),
 141                     gfx::Rect(), LAST_ACTIVE, NULL, gfx::Rect(),
 142                     &window_bounds);
 143     EXPECT_EQ(gfx::Rect(kWindowTilePixels * 2,
 144                         kWindowTilePixels * 2,
 145                         30 /* not 29 */,
 146                         30 /* not 29 */),
 147               window_bounds);
 148   }
 149
 150
 151   { // Normal.
 152     gfx::Rect window_bounds;
 153     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 154                     gfx::Rect(kWindowTilePixels, kWindowTilePixels, 500, 400),
 155                     gfx::Rect(), LAST_ACTIVE, NULL, gfx::Rect(),
 156                     &window_bounds);
 157     EXPECT_EQ(gfx::Rect(kWindowTilePixels * 2,
 158                         kWindowTilePixels * 2, 500, 400), window_bounds);
 159   }
 160 }
 161
 162 // Test that the window opened is sized appropriately given persisted sizes.
 163 TEST(WindowSizerTest, PersistedBoundsCase) {
 164   { // normal, in the middle of the screen somewhere.
 165     gfx::Rect initial_bounds(kWindowTilePixels, kWindowTilePixels, 500, 400);
 166
 167     gfx::Rect window_bounds;
 168     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(), initial_bounds,
 169                     gfx::Rect(), PERSISTED, NULL, gfx::Rect(), &window_bounds);
 170     EXPECT_EQ(initial_bounds.ToString(), window_bounds.ToString());
 171   }
 172
 173   { // Normal.
 174     gfx::Rect initial_bounds(0, 0, 1024, 768);
 175
 176     gfx::Rect window_bounds;
 177     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(), initial_bounds,
 178                     gfx::Rect(), PERSISTED, NULL, gfx::Rect(), &window_bounds);
 179     EXPECT_EQ(initial_bounds.ToString(), window_bounds.ToString());
 180   }
 181
 182   { // normal, on non-primary monitor in negative coords.
 183     gfx::Rect initial_bounds(-600, 10, 500, 400);
 184
 185     gfx::Rect window_bounds;
 186     GetWindowBounds(p1024x768, p1024x768, left_s1024x768,
 187                     initial_bounds, gfx::Rect(), PERSISTED, NULL, gfx::Rect(),
 188                     &window_bounds);
 189     EXPECT_EQ(initial_bounds.ToString(), window_bounds.ToString());
 190   }
 191
 192   { // normal, on non-primary monitor in negative coords.
 193     gfx::Rect initial_bounds(-1024, 0, 1024, 768);
 194
 195     gfx::Rect window_bounds;
 196     GetWindowBounds(p1024x768, p1024x768, left_s1024x768,
 197                     initial_bounds, gfx::Rect(), PERSISTED, NULL, gfx::Rect(),
 198                     &window_bounds);
 199     EXPECT_EQ(initial_bounds.ToString(), window_bounds.ToString());
 200   }
 201
 202   { // Non-primary monitor resoultion has changed, but the monitor still
 203     // completely contains the window.
 204
 205     gfx::Rect initial_bounds(1074, 50, 600, 500);
 206
 207     gfx::Rect window_bounds;
 208     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(1024, 0, 800, 600),
 209                     initial_bounds, right_s1024x768, PERSISTED, NULL,
 210                     gfx::Rect(), &window_bounds);
 211     EXPECT_EQ(initial_bounds.ToString(), window_bounds.ToString());
 212   }
 213
 214   { // Non-primary monitor resoultion has changed, and the window is partially
 215     // off-screen.
 216
 217     gfx::Rect initial_bounds(1274, 50, 600, 500);
 218
 219     gfx::Rect window_bounds;
 220     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(1024, 0, 800, 600),
 221                     initial_bounds, right_s1024x768, PERSISTED,
 222                     NULL, gfx::Rect(), &window_bounds);
 223     EXPECT_EQ("1224,50 600x500", window_bounds.ToString());
 224   }
 225
 226   { // Non-primary monitor resoultion has changed, and the window is now too
 227     // large for the monitor.
 228
 229     gfx::Rect initial_bounds(1274, 50, 900, 700);
 230
 231     gfx::Rect window_bounds;
 232     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(1024, 0, 800, 600),
 233                     initial_bounds, right_s1024x768, PERSISTED,
 234                     NULL, gfx::Rect(), &window_bounds);
 235     EXPECT_EQ("1024,0 800x600", window_bounds.ToString());
 236   }
 237
 238   { // width and height too small
 239     gfx::Rect window_bounds;
 240     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 241                     gfx::Rect(kWindowTilePixels, kWindowTilePixels, 29, 29),
 242                     gfx::Rect(), PERSISTED, NULL, gfx::Rect(), &window_bounds);
 243     EXPECT_EQ(gfx::Rect(kWindowTilePixels, kWindowTilePixels,
 244                         30 /* not 29 */, 30 /* not 29 */),
 245               window_bounds);
 246   }
 247
 248 #if defined(OS_MACOSX)
 249   { // Saved state is too tall to possibly be resized.  Mac resizers
 250     // are at the bottom of the window, and no piece of a window can
 251     // be moved higher than the menubar.  (Perhaps the user changed
 252     // resolution to something smaller before relaunching Chrome?)
 253     gfx::Rect window_bounds;
 254     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 255                     gfx::Rect(kWindowTilePixels, kWindowTilePixels, 30, 5000),
 256                     gfx::Rect(), PERSISTED, NULL, gfx::Rect(), &window_bounds);
 257     EXPECT_EQ(p1024x768.height(), window_bounds.height());
 258   }
 259 #endif  // defined(OS_MACOSX)
 260 }
 261
 262 //////////////////////////////////////////////////////////////////////////////
 263 // The following unittests have different results on Mac/non-Mac because we
 264 // reposition windows aggressively on Mac.  The *WithAggressiveReposition tests
 265 // are run on Mac, and the *WithNonAggressiveRepositioning tests are run on
 266 // other platforms.
 267
 268 #if defined(OS_MACOSX)
 269 TEST(WindowSizerTest, LastWindowOffscreenWithAggressiveRepositioning) {
 270   { // taskbar on left.  The new window overlaps slightly with the taskbar, so
 271     // it is moved to be flush with the left edge of the work area.
 272     gfx::Rect window_bounds;
 273     GetWindowBounds(p1024x768, taskbar_left_work_area, gfx::Rect(),
 274                     gfx::Rect(kWindowTilePixels, kWindowTilePixels, 500, 400),
 275                     gfx::Rect(), LAST_ACTIVE, NULL, gfx::Rect(),
 276                     &window_bounds);
 277     EXPECT_EQ(gfx::Rect(taskbar_left_work_area.x(),
 278                         kWindowTilePixels * 2, 500, 400), window_bounds);
 279   }
 280
 281   { // offset would put the new window offscreen at the bottom
 282     gfx::Rect window_bounds;
 283     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 284                     gfx::Rect(10, 729, 500, 400), gfx::Rect(), LAST_ACTIVE,
 285                     NULL, gfx::Rect(), &window_bounds);
 286     EXPECT_EQ(gfx::Rect(10 + kWindowTilePixels,
 287                         0 /* not 729 + kWindowTilePixels */,
 288                         500, 400),
 289               window_bounds);
 290   }
 291
 292   { // offset would put the new window offscreen at the right
 293     gfx::Rect window_bounds;
 294     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 295                     gfx::Rect(985, 10, 500, 400), gfx::Rect(), LAST_ACTIVE,
 296                     NULL, gfx::Rect(), &window_bounds);
 297     EXPECT_EQ(gfx::Rect(0 /* not 985 + kWindowTilePixels*/,
 298                         10 + kWindowTilePixels,
 299                         500, 400),
 300               window_bounds);
 301   }
 302
 303   { // offset would put the new window offscreen at the bottom right
 304     gfx::Rect window_bounds;
 305     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 306                     gfx::Rect(985, 729, 500, 400), gfx::Rect(), LAST_ACTIVE,
 307                     NULL, gfx::Rect(), &window_bounds);
 308     EXPECT_EQ(gfx::Rect(0 /* not 985 + kWindowTilePixels*/,
 309                         0 /* not 729 + kWindowTilePixels*/,
 310                         500, 400),
 311               window_bounds);
 312   }
 313 }
 314
 315 TEST(WindowSizerTest, PersistedWindowOffscreenWithAggressiveRepositioning) {
 316   { // off the left
 317     gfx::Rect window_bounds;
 318     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 319                     gfx::Rect(-471, 50, 500, 400), gfx::Rect(), PERSISTED,
 320                     NULL, gfx::Rect(), &window_bounds);
 321     EXPECT_EQ(gfx::Rect(0 /* not -471 */, 50, 500, 400), window_bounds);
 322   }
 323
 324   { // off the top
 325     gfx::Rect window_bounds;
 326     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 327                     gfx::Rect(50, -370, 500, 400), gfx::Rect(), PERSISTED,
 328                     NULL, gfx::Rect(), &window_bounds);
 329     EXPECT_EQ(gfx::Rect(50, 0, 500, 400), window_bounds);
 330   }
 331
 332   { // off the right
 333     gfx::Rect window_bounds;
 334     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 335                     gfx::Rect(995, 50, 500, 400), gfx::Rect(), PERSISTED,
 336                     NULL, gfx::Rect(), &window_bounds);
 337     EXPECT_EQ(gfx::Rect(0 /* not 995 */, 50, 500, 400), window_bounds);
 338   }
 339
 340   { // off the bottom
 341     gfx::Rect window_bounds;
 342     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 343                     gfx::Rect(50, 739, 500, 400), gfx::Rect(), PERSISTED,
 344                     NULL, gfx::Rect(), &window_bounds);
 345     EXPECT_EQ(gfx::Rect(50, 0 /* not 739 */, 500, 400), window_bounds);
 346   }
 347
 348   { // off the topleft
 349     gfx::Rect window_bounds;
 350     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 351                     gfx::Rect(-471, -371, 500, 400), gfx::Rect(), PERSISTED,
 352                     NULL, gfx::Rect(), &window_bounds);
 353     EXPECT_EQ(gfx::Rect(0 /* not -471 */, 0 /* not -371 */, 500, 400),
 354               window_bounds);
 355   }
 356
 357   { // off the topright
 358     gfx::Rect window_bounds;
 359     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 360                     gfx::Rect(995, -371, 500, 400), gfx::Rect(), PERSISTED,
 361                     NULL, gfx::Rect(), &window_bounds);
 362     EXPECT_EQ(gfx::Rect(0 /* not 995 */, 0 /* not -371 */, 500, 400),
 363                         window_bounds);
 364   }
 365
 366   { // off the bottomleft
 367     gfx::Rect window_bounds;
 368     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 369                     gfx::Rect(-471, 739, 500, 400), gfx::Rect(), PERSISTED,
 370                     NULL, gfx::Rect(), &window_bounds);
 371     EXPECT_EQ(gfx::Rect(0 /* not -471 */, 0 /* not 739 */, 500, 400),
 372                         window_bounds);
 373   }
 374
 375   { // off the bottomright
 376     gfx::Rect window_bounds;
 377     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 378                     gfx::Rect(995, 739, 500, 400), gfx::Rect(), PERSISTED,
 379                     NULL, gfx::Rect(), &window_bounds);
 380     EXPECT_EQ(gfx::Rect(0 /* not 995 */, 0 /* not 739 */, 500, 400),
 381                         window_bounds);
 382   }
 383
 384   { // entirely off left
 385     gfx::Rect window_bounds;
 386     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 387                     gfx::Rect(-700, 50, 500, 400), gfx::Rect(), PERSISTED,
 388                     NULL, gfx::Rect(), &window_bounds);
 389     EXPECT_EQ(gfx::Rect(0 /* not -700 */, 50, 500, 400), window_bounds);
 390   }
 391
 392   { // entirely off left (monitor was detached since last run)
 393     gfx::Rect window_bounds;
 394     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 395                     gfx::Rect(-700, 50, 500, 400), left_s1024x768,
 396                     PERSISTED, NULL, gfx::Rect(), &window_bounds);
 397     EXPECT_EQ(gfx::Rect(0, 50, 500, 400), window_bounds);
 398   }
 399
 400   { // entirely off top
 401     gfx::Rect window_bounds;
 402     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 403                     gfx::Rect(50, -500, 500, 400), gfx::Rect(), PERSISTED,
 404                     NULL, gfx::Rect(), &window_bounds);
 405     EXPECT_EQ(gfx::Rect(50, 0, 500, 400), window_bounds);
 406   }
 407
 408   { // entirely off top (monitor was detached since last run)
 409     gfx::Rect window_bounds;
 410     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 411                     gfx::Rect(50, -500, 500, 400), top_s1024x768, PERSISTED,
 412                     NULL, gfx::Rect(), &window_bounds);
 413     EXPECT_EQ(gfx::Rect(50, 0, 500, 400), window_bounds);
 414   }
 415
 416   { // entirely off right
 417     gfx::Rect window_bounds;
 418     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 419                     gfx::Rect(1200, 50, 500, 400), gfx::Rect(), PERSISTED,
 420                     NULL, gfx::Rect(), &window_bounds);
 421     EXPECT_EQ(gfx::Rect(0 /* not 1200 */, 50, 500, 400), window_bounds);
 422   }
 423
 424   { // entirely off right (monitor was detached since last run)
 425     gfx::Rect window_bounds;
 426     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 427                     gfx::Rect(1200, 50, 500, 400), right_s1024x768, PERSISTED,
 428                     NULL, gfx::Rect(), &window_bounds);
 429     EXPECT_EQ(gfx::Rect(524 /* not 1200 */, 50, 500, 400), window_bounds);
 430   }
 431
 432   { // entirely off bottom
 433     gfx::Rect window_bounds;
 434     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 435                     gfx::Rect(50, 800, 500, 400), gfx::Rect(), PERSISTED,
 436                     NULL, gfx::Rect(), &window_bounds);
 437     EXPECT_EQ(gfx::Rect(50, 0 /* not 800 */, 500, 400), window_bounds);
 438   }
 439
 440   { // entirely off bottom (monitor was detached since last run)
 441     gfx::Rect window_bounds;
 442     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 443                     gfx::Rect(50, 800, 500, 400), bottom_s1024x768,
 444                     PERSISTED, NULL, gfx::Rect(), &window_bounds);
 445     EXPECT_EQ(gfx::Rect(50, 368 /* not 800 */, 500, 400), window_bounds);
 446   }
 447
 448   { // wider than the screen. off both the left and right
 449     gfx::Rect window_bounds;
 450     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 451                     gfx::Rect(-100, 50, 2000, 400), gfx::Rect(), PERSISTED,
 452                     NULL, gfx::Rect(), &window_bounds);
 453     EXPECT_EQ(gfx::Rect(0 /* not -100 */, 50, 2000, 400), window_bounds);
 454   }
 455 }
 456 #else
 457 TEST(WindowSizerTest, LastWindowOffscreenWithNonAggressiveRepositioning) {
 458   { // taskbar on left.
 459     gfx::Rect window_bounds;
 460     GetWindowBounds(p1024x768, taskbar_left_work_area, gfx::Rect(),
 461                     gfx::Rect(kWindowTilePixels, kWindowTilePixels, 500, 400),
 462                     gfx::Rect(), LAST_ACTIVE, NULL, gfx::Rect(),
 463                     &window_bounds);
 464     EXPECT_EQ(gfx::Rect(kWindowTilePixels * 2,
 465                         kWindowTilePixels * 2, 500, 400), window_bounds);
 466   }
 467
 468   // Linux does not tile windows, so tile adjustment tests don't make sense.
 469 #if !defined(OS_POSIX) || defined(OS_MACOSX)
 470   { // offset would put the new window offscreen at the bottom but the minimum
 471     // visibility condition is barely satisfied without relocation.
 472     gfx::Rect window_bounds;
 473     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 474                     gfx::Rect(10, 728, 500, 400), gfx::Rect(), LAST_ACTIVE,
 475                     NULL, gfx::Rect(), &window_bounds);
 476     EXPECT_EQ(gfx::Rect(10 + kWindowTilePixels, 738,
 477                         500, 400), window_bounds);
 478   }
 479
 480   { // offset would put the new window offscreen at the bottom and the minimum
 481     // visibility condition is satisified by relocation.
 482     gfx::Rect window_bounds;
 483     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 484                     gfx::Rect(10, 729, 500, 400), gfx::Rect(), LAST_ACTIVE,
 485                     NULL, gfx::Rect(), &window_bounds);
 486     EXPECT_EQ(gfx::Rect(10 + kWindowTilePixels, 738 /* not 739 */, 500, 400),
 487               window_bounds);
 488   }
 489
 490   { // offset would put the new window offscreen at the right but the minimum
 491     // visibility condition is barely satisfied without relocation.
 492     gfx::Rect window_bounds;
 493     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 494                     gfx::Rect(984, 10, 500, 400), gfx::Rect(), LAST_ACTIVE,
 495                     NULL, gfx::Rect(), &window_bounds);
 496     EXPECT_EQ(gfx::Rect(994, 10 + kWindowTilePixels, 500, 400), window_bounds);
 497   }
 498
 499   { // offset would put the new window offscreen at the right and the minimum
 500     // visibility condition is satisified by relocation.
 501     gfx::Rect window_bounds;
 502     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 503                     gfx::Rect(985, 10, 500, 400), gfx::Rect(), LAST_ACTIVE,
 504                     NULL, gfx::Rect(), &window_bounds);
 505     EXPECT_EQ(gfx::Rect(994 /* not 995 */, 10 + kWindowTilePixels,
 506                         500, 400), window_bounds);
 507   }
 508
 509   { // offset would put the new window offscreen at the bottom right and the
 510     // minimum visibility condition is satisified by relocation.
 511     gfx::Rect window_bounds;
 512     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
 513                     gfx::Rect(985, 729, 500, 400), gfx::Rect(), LAST_ACTIVE,
 514                     NULL, gfx::Rect(), &window_bounds);
 515     EXPECT_EQ(gfx::Rect(994 /* not 995 */, 738 /* not 739 */, 500, 400),
 516               window_bounds);
 517   }
 518 #endif  // !defined(OS_POSIX) || defined(OS_MACOSX)
 519 }
 520
 521 #endif  //defined(OS_MACOSX)