Removes the grid from ash.

chrome/browser/ui/ash/window_positioner_unittest.cc

 // Copyright (c) 2012 The Chromium 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 "chrome/browser/ui/ash/window_positioner.h"
 
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_resizer.h"
@@ skipping 58 matching lines @@
   aura::Window* popup() { return popup_.get(); }
   aura::Window* panel() { return panel_.get(); }
 
   Browser* window_browser() { return window_owning_browser_.get(); }
   Browser* popup_browser() { return popup_owning_browser_.get(); }
   Browser* panel_browser() { return panel_owning_browser_.get(); }
 
   WindowPositioner* window_positioner() { return window_positioner_; }
 
   // The positioner & desktop's used grid alignment size.
-  int grid_size_;
+  const int grid_size_;
 
  private:
   WindowPositioner* window_positioner_;
 
   // These two need to be deleted after everything else is gone.
   scoped_ptr<content::TestBrowserThread> ui_thread_;
   scoped_ptr<TestingProfile> profile_;
 
   // These get created for each session.
   scoped_ptr<aura::Window> window_;
   scoped_ptr<aura::Window> popup_;
   scoped_ptr<aura::Window> panel_;
 
   scoped_ptr<BrowserWindow> browser_window_;
   scoped_ptr<BrowserWindow> browser_popup_;
   scoped_ptr<BrowserWindow> browser_panel_;
 
   scoped_ptr<Browser> window_owning_browser_;
   scoped_ptr<Browser> popup_owning_browser_;
   scoped_ptr<Browser> panel_owning_browser_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowPositionerTest);
 };
 
 WindowPositionerTest::WindowPositionerTest()
-    : window_positioner_(NULL) {
+    : grid_size_(WindowPositioner::kMinimumWindowOffset),
+      window_positioner_(NULL) {
   // Create a message loop.
   MessageLoopForUI* ui_loop = message_loop();
   ui_thread_.reset(
       new content::TestBrowserThread(content::BrowserThread::UI, ui_loop));
 
   // Create a browser profile.
   profile_.reset(new TestingProfile());
 }
 
 WindowPositionerTest::~WindowPositionerTest() {
@@ skipping 27 matching lines @@
   browser_panel_.reset(new TestBrowserWindowAura(panel_.get()));
   Browser::CreateParams panel_params(Browser::TYPE_PANEL, profile_.get());
   panel_params.window = browser_panel_.get();
   panel_owning_browser_.reset(new Browser(panel_params));
   // We hide all windows upon start - each user is required to set it up
   // as he needs it.
   window()->Hide();
   popup()->Hide();
   panel()->Hide();
   window_positioner_ = new WindowPositioner();
-
-  // Get the alignment size.
-  grid_size_ = ash::Shell::GetInstance()->GetGridSize();
-  if (!grid_size_) {
-    grid_size_ = WindowPositioner::kMinimumWindowOffset;
-  } else {
-    while (grid_size_ < WindowPositioner::kMinimumWindowOffset)
-      grid_size_ *= 2;
-  }
 }
 
 void WindowPositionerTest::TearDown() {
   // Since the AuraTestBase is needed to create our assets, we have to
   // also delete them before we tear it down.
   window_owning_browser_.reset(NULL);
   popup_owning_browser_.reset(NULL);
   panel_owning_browser_.reset(NULL);
 
   browser_window_.reset(NULL);
   browser_popup_.reset(NULL);
   browser_panel_.reset(NULL);
 
   window_.reset(NULL);
   popup_.reset(NULL);
   panel_.reset(NULL);
 
   AshTestBase::TearDown();
   delete window_positioner_;
   window_positioner_ = NULL;
 }
 
+int AlignToGridRoundDown(int location, int grid_size) {
+  if (grid_size <= 1 || location % grid_size == 0)
+    return location;
+  return location / grid_size * grid_size;
+}
+
 TEST_F(WindowPositionerTest, cascading) {
   const gfx::Rect work_area = gfx::Screen::GetPrimaryDisplay().work_area();
 
   // First see that the window will cascade down when there is no space.
   window()->SetBounds(work_area);
   window()->Show();
 
   gfx::Rect popup_position(0, 0, 200, 200);
   // Check that it gets cascaded.
   gfx::Rect cascade_1 = window_positioner()->GetPopupPosition(popup_position);
@@ skipping 42 matching lines @@
   gfx::Rect cascade_5 =
       window_positioner()->GetPopupPosition(popup_position_5);
   EXPECT_EQ(gfx::Rect(work_area.x() + grid_size_,
                       work_area.y() + grid_size_,
                       popup_position_5.width(), popup_position_5.height()),
                       cascade_5);
 }
 
 TEST_F(WindowPositionerTest, filling) {
   const gfx::Rect work_area = gfx::Screen::GetPrimaryDisplay().work_area();
-  int grid = ash::Shell::GetInstance()->GetGridSize();
   gfx::Rect popup_position(0, 0, 256, 128);
   // Leave space on the left and the right and see if we fill top to bottom.
   window()->SetBounds(gfx::Rect(work_area.x() + popup_position.width(),
                                 work_area.y(),
                                 work_area.width() - 2 * popup_position.width(),
                                 work_area.height()));
   window()->Show();
   // Check that we are positioned in the top left corner.
   gfx::Rect top_left = window_positioner()->GetPopupPosition(popup_position);
   EXPECT_EQ(gfx::Rect(work_area.x(), work_area.y(),
                       popup_position.width(), popup_position.height()),
                       top_left);
 
   // Now block the found location.
   popup()->SetBounds(top_left);
   popup()->Show();
   gfx::Rect mid_left = window_positioner()->GetPopupPosition(popup_position);
   EXPECT_EQ(gfx::Rect(work_area.x(),
-                      ash::WindowResizer::AlignToGridRoundDown(
-                          work_area.y() + top_left.height(), grid),
+                      AlignToGridRoundDown(
+                          work_area.y() + top_left.height(), grid_size_),
                           popup_position.width(), popup_position.height()),
                       mid_left);
 
   // Block now everything so that we can only put the popup on the bottom
   // of the left side.
   // Note: We need to keep one "grid spacing free" if the window does not
   // fit into the grid (which is true for 200 height).`
   popup()->SetBounds(gfx::Rect(work_area.x(), work_area.y(),
                                popup_position.width(),
                                work_area.height() - popup_position.height() -
-                                   grid + 1));
+                                   grid_size_ + 1));
   gfx::Rect bottom_left = window_positioner()->GetPopupPosition(
                               popup_position);
   EXPECT_EQ(gfx::Rect(work_area.x(),
                       work_area.bottom() - popup_position.height(),
                       popup_position.width(), popup_position.height()),
                       bottom_left);
 
   // Block now enough to force the right side.
   popup()->SetBounds(gfx::Rect(work_area.x(), work_area.y(),
                                popup_position.width(),
                                work_area.height() - popup_position.height() +
                                1));
   gfx::Rect top_right = window_positioner()->GetPopupPosition(
                             popup_position);
-  EXPECT_EQ(gfx::Rect(ash::WindowResizer::AlignToGridRoundDown(
-                         work_area.right() - popup_position.width(), grid),
+  EXPECT_EQ(gfx::Rect(AlignToGridRoundDown(work_area.right() -
+                                           popup_position.width(), grid_size_),
                       work_area.y(),
                       popup_position.width(), popup_position.height()),
                       top_right);
 }
 
 TEST_F(WindowPositionerTest, blockedByPanel) {
   const gfx::Rect work_area = gfx::Screen::GetPrimaryDisplay().work_area();
 
   gfx::Rect pop_position(0, 0, 200, 200);
   // Let the panel cover everything.
@@ skipping 14 matching lines @@
 
   // Check that the popup is placed full screen.
   gfx::Rect full = window_positioner()->GetPopupPosition(pop_position);
   EXPECT_EQ(gfx::Rect(work_area.x(), work_area.y(),
                       pop_position.width(), pop_position.height()),
                       full);
 }
 
 }  // namespace test
 }  // namespace ash