chrome/browser/ui/ash/window_positioner_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 "ash/wm/window_positioner.h"
   6
   7 #include "ash/shell.h"
   8 #include "ash/test/ash_test_base.h"
   9 #include "ash/test/test_shell_delegate.h"
  10 #include "ash/wm/window_resizer.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/logging.h"
  13 #include "chrome/browser/ui/browser.h"
  14 #include "chrome/browser/ui/host_desktop.h"
  15 #include "chrome/test/base/test_browser_window_aura.h"
  16 #include "chrome/test/base/testing_profile.h"
  17 #include "content/public/test/render_view_test.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "ui/aura/env.h"
  20 #include "ui/aura/test/test_windows.h"
  21 #include "ui/aura/window_event_dispatcher.h"
  22 #include "ui/gfx/screen.h"
  23
  24 namespace ash {
  25 namespace test {
  26
  27 // A test class for preparing window positioner tests - it creates a testing
  28 // base by adding a window and a popup which can be independently
  29 // positioned to see where the positioner will place the window.
  30 class WindowPositionerTest : public AshTestBase {
  31  public:
  32   WindowPositionerTest();
  33
  34   void SetUp() override;
  35   void TearDown() override;
  36
  37  protected:
  38   aura::Window* window() { return browser_->window()->GetNativeWindow(); }
  39   aura::Window* popup() { return browser_popup_->window()->GetNativeWindow(); }
  40
  41   WindowPositioner* window_positioner() { return window_positioner_.get(); }
  42
  43   // The positioner & desktop's used grid alignment size.
  44   const int grid_size_;
  45
  46  private:
  47   scoped_ptr<WindowPositioner> window_positioner_;
  48
  49   TestingProfile profile_;
  50
  51   scoped_ptr<Browser> browser_;
  52   scoped_ptr<Browser> browser_popup_;
  53
  54   DISALLOW_COPY_AND_ASSIGN(WindowPositionerTest);
  55 };
  56
  57 WindowPositionerTest::WindowPositionerTest()
  58     : grid_size_(WindowPositioner::kMinimumWindowOffset) {}
  59
  60 void WindowPositionerTest::SetUp() {
  61   AshTestBase::SetUp();
  62   // Create some default dummy windows.
  63   scoped_ptr<aura::Window> dummy_window(CreateTestWindowInShellWithId(0));
  64   dummy_window->SetBounds(gfx::Rect(16, 32, 640, 320));
  65   scoped_ptr<aura::Window> dummy_popup(CreateTestWindowInShellWithId(1));
  66   dummy_popup->SetBounds(gfx::Rect(16, 32, 128, 256));
  67
  68   // Create a browser for the window.
  69   Browser::CreateParams window_params(&profile_,
  70                                       chrome::HOST_DESKTOP_TYPE_ASH);
  71   browser_ = chrome::CreateBrowserWithAuraTestWindowForParams(
  72       dummy_window.Pass(), &window_params);
  73
  74   // Creating a browser for the popup.
  75   Browser::CreateParams popup_params(Browser::TYPE_POPUP, &profile_,
  76                                      chrome::HOST_DESKTOP_TYPE_ASH);
  77   browser_popup_ = chrome::CreateBrowserWithAuraTestWindowForParams(
  78       dummy_popup.Pass(), &popup_params);
  79
  80   // We hide all windows upon start - each user is required to set it up
  81   // as he needs it.
  82   window()->Hide();
  83   popup()->Hide();
  84   window_positioner_.reset(new WindowPositioner());
  85 }
  86
  87 void WindowPositionerTest::TearDown() {
  88   // Since the AuraTestBase is needed to create our assets, we have to
  89   // also delete them before we tear it down.
  90   browser_.reset();
  91   browser_popup_.reset();
  92   window_positioner_.reset();
  93   AshTestBase::TearDown();
  94 }
  95
  96 int AlignToGridRoundDown(int location, int grid_size) {
  97   if (grid_size <= 1 || location % grid_size == 0)
  98     return location;
  99   return location / grid_size * grid_size;
 100 }
 101
 102 TEST_F(WindowPositionerTest, cascading) {
 103   const gfx::Rect work_area =
 104       Shell::GetScreen()->GetPrimaryDisplay().work_area();
 105
 106   // First see that the window will cascade down when there is no space.
 107   window()->SetBounds(work_area);
 108   window()->Show();
 109
 110   gfx::Rect popup_position(0, 0, 200, 200);
 111   // Check that it gets cascaded.
 112   gfx::Rect cascade_1 = window_positioner()->GetPopupPosition(popup_position);
 113   EXPECT_EQ(gfx::Rect(work_area.x() + grid_size_, work_area.y() + grid_size_,
 114                       popup_position.width(), popup_position.height()),
 115                       cascade_1);
 116
 117   gfx::Rect cascade_2 = window_positioner()->GetPopupPosition(popup_position);
 118   EXPECT_EQ(gfx::Rect(work_area.x() + 2 * grid_size_,
 119                       work_area.y() + 2 * grid_size_,
 120                       popup_position.width(), popup_position.height()),
 121                       cascade_2);
 122
 123   // Check that if there is even only a pixel missing it will cascade.
 124   window()->SetBounds(gfx::Rect(work_area.x() + popup_position.width() - 1,
 125                                 work_area.y() + popup_position.height() - 1,
 126                                 work_area.width() -
 127                                     2 * (popup_position.width() - 1),
 128                                 work_area.height() -
 129                                     2 * (popup_position.height() - 1)));
 130
 131   gfx::Rect cascade_3 = window_positioner()->GetPopupPosition(popup_position);
 132   EXPECT_EQ(gfx::Rect(work_area.x() + 3 * grid_size_,
 133                       work_area.y() + 3 * grid_size_,
 134                       popup_position.width(), popup_position.height()),
 135                       cascade_3);
 136
 137   // Check that we overflow into the next line when we do not fit anymore in Y.
 138   gfx::Rect popup_position_4(0, 0, 200,
 139                              work_area.height() -
 140                                  (cascade_3.y() - work_area.y()));
 141   gfx::Rect cascade_4 =
 142       window_positioner()->GetPopupPosition(popup_position_4);
 143   EXPECT_EQ(gfx::Rect(work_area.x() + 2 * grid_size_,
 144                       work_area.y() + grid_size_,
 145                       popup_position_4.width(), popup_position_4.height()),
 146                       cascade_4);
 147
 148   // Check that we overflow back to the first possible location if we overflow
 149   // to the end.
 150   gfx::Rect popup_position_5(0, 0,
 151                             work_area.width() + 1 -
 152                                 (cascade_4.x() - work_area.x()),
 153                             work_area.height() -
 154                                 (2 * grid_size_ - work_area.y()));
 155   gfx::Rect cascade_5 =
 156       window_positioner()->GetPopupPosition(popup_position_5);
 157   EXPECT_EQ(gfx::Rect(work_area.x() + grid_size_,
 158                       work_area.y() + grid_size_,
 159                       popup_position_5.width(), popup_position_5.height()),
 160                       cascade_5);
 161 }
 162
 163 TEST_F(WindowPositionerTest, filling) {
 164   const gfx::Rect work_area =
 165       Shell::GetScreen()->GetPrimaryDisplay().work_area();
 166   gfx::Rect popup_position(0, 0, 256, 128);
 167   // Leave space on the left and the right and see if we fill top to bottom.
 168   window()->SetBounds(gfx::Rect(work_area.x() + popup_position.width(),
 169                                 work_area.y(),
 170                                 work_area.width() - 2 * popup_position.width(),
 171                                 work_area.height()));
 172   window()->Show();
 173   // Check that we are positioned in the top left corner.
 174   gfx::Rect top_left = window_positioner()->GetPopupPosition(popup_position);
 175   EXPECT_EQ(gfx::Rect(work_area.x(), work_area.y(),
 176                       popup_position.width(), popup_position.height()),
 177                       top_left);
 178
 179   // Now block the found location.
 180   popup()->SetBounds(top_left);
 181   popup()->Show();
 182   gfx::Rect mid_left = window_positioner()->GetPopupPosition(popup_position);
 183   EXPECT_EQ(gfx::Rect(work_area.x(),
 184                       AlignToGridRoundDown(
 185                           work_area.y() + top_left.height(), grid_size_),
 186                           popup_position.width(), popup_position.height()),
 187                       mid_left);
 188
 189   // Block now everything so that we can only put the popup on the bottom
 190   // of the left side.
 191   // Note: We need to keep one "grid spacing free" if the window does not
 192   // fit into the grid (which is true for 200 height).`
 193   popup()->SetBounds(gfx::Rect(work_area.x(), work_area.y(),
 194                                popup_position.width(),
 195                                work_area.height() - popup_position.height() -
 196                                    grid_size_ + 1));
 197   gfx::Rect bottom_left = window_positioner()->GetPopupPosition(
 198                               popup_position);
 199   EXPECT_EQ(gfx::Rect(work_area.x(),
 200                       work_area.bottom() - popup_position.height(),
 201                       popup_position.width(), popup_position.height()),
 202                       bottom_left);
 203
 204   // Block now enough to force the right side.
 205   popup()->SetBounds(gfx::Rect(work_area.x(), work_area.y(),
 206                                popup_position.width(),
 207                                work_area.height() - popup_position.height() +
 208                                1));
 209   gfx::Rect top_right = window_positioner()->GetPopupPosition(
 210                             popup_position);
 211   EXPECT_EQ(gfx::Rect(AlignToGridRoundDown(work_area.right() -
 212                                            popup_position.width(), grid_size_),
 213                       work_area.y(),
 214                       popup_position.width(), popup_position.height()),
 215                       top_right);
 216 }
 217
 218 TEST_F(WindowPositionerTest, biggerThenBorder) {
 219   const gfx::Rect work_area =
 220       Shell::GetScreen()->GetPrimaryDisplay().work_area();
 221
 222   gfx::Rect pop_position(0, 0, work_area.width(), work_area.height());
 223
 224   // Check that the popup is placed full screen.
 225   gfx::Rect full = window_positioner()->GetPopupPosition(pop_position);
 226   EXPECT_EQ(gfx::Rect(work_area.x(), work_area.y(),
 227                       pop_position.width(), pop_position.height()),
 228                       full);
 229 }
 230
 231 }  // namespace test
 232 }  // namespace ash